libsheepy
libsheepyCSmallDict.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 "libsheepyCSmallDict.h"
25 #include "libsheepyCSmallDictInternal.h"
26 #include "../../release/libsheepy.h"
27 
28 #define internal static
29 
30 #include <stdint.h>
31 #include <stdlib.h>
32 #include <stdbool.h>
33 #include <string.h>
34 #include <stdio.h>
35 
36 void initiateSmallDict(smallDictt *self);
37 void registerMethodsSmallDict(smallDictFunctionst *f);
38 void initiateAllocateSmallDict(smallDictt **self);
39 void finalizeRecycleSmallDict(void *arg UNUSED);
40 void finalizeSmallDict(void);
41 smallDictt* allocSmallDict(void);
42 void cleanUpSmallDictTerminateG(smallDictt **val);
43 void cleanUpSmallDictFreeLocalG(smallDictt *val);
44 void cleanUpSmallDictFreeG(smallDictt **val);
45 void cleanUpSmallDictFinishG(smallDictt **val);
46 void cleanUpSmallDictDisposeG(smallDictt *val);
47 void cleanUpSmallDictSmashG(smallDictt **val);
48 internal void freeSmallDict(smallDictt *self);
49 internal void terminateSmallDict(smallDictt **self);
50 internal char* toStringSmallDict(smallDictt *self);
51 internal smallDictt* duplicateSmallDict(smallDictt *self);
52 internal char* escapeSmallDict(smallDictt *self);
53 internal void disposeSmallDict(smallDictt *self);
54 internal void smashSmallDict(smallDictt **self);
55 #if (NFreeStackCheck)
56 internal void finishSmallDict(smallDictt **self);
57 #else
58 internal void finishSmallDict(smallDictt **self);
59 #endif
60 internal const char* helpSmallDict(smallDictt UNUSED *self);
61 internal void resetSmallDict(smallDictt *self);
62 internal sDictt* getsoSmallDict(smallDictt *self);
63 internal void setsoSmallDict(smallDictt *self, sDictt *so);
64 internal smallDictt* mirrorSmallDict(smallDictt *self);
65 internal smallDictt* setSmallDict(smallDictt *self, const char *key, baset *value);
66 internal smallDictt* setUndefinedSmallDict(smallDictt *self, const char *key);
67 internal smallDictt* setBoolSmallDict(smallDictt *self, const char *key, bool value);
68 internal smallDictt* setDoubleSmallDict(smallDictt *self, const char *key, double value);
69 internal smallDictt* setIntSmallDict(smallDictt *self, const char *key, int64_t value);
70 internal smallDictt* setSSmallDict(smallDictt *self, const char *key, const char *string);
71 internal smallDictt* setCharSmallDict(smallDictt *self, const char *key, char c);
72 internal smallDictt* setDictSmallDict(smallDictt *self, const char *key, smallDictt *dict);
73 internal smallDictt* setArraySmallDict(smallDictt *self, const char *key, smallArrayt *array);
74 internal smallDictt* setArraycSmallDict(smallDictt *self, const char *key, char **array);
75 internal smallDictt* setCArraycSmallDict(smallDictt *self, const char *key, const char **array);
76 internal smallDictt* setSmallBoolSmallDict(smallDictt *self, const char *key, smallBoolt *value);
77 internal smallDictt* setSmallBytesSmallDict(smallDictt *self, const char *key, smallBytest *value);
78 internal smallDictt* setSmallDoubleSmallDict(smallDictt *self, const char *key, smallDoublet *value);
79 internal smallDictt* setSmallIntSmallDict(smallDictt *self, const char *key, smallIntt *value);
80 internal smallDictt* setSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *value);
81 internal smallDictt* setSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string);
82 internal smallDictt* setSmallContainerSmallDict(smallDictt *self, const char *key, smallContainert *container);
83 internal smallDictt* setKCharSmallDict(smallDictt *self, char key, baset *value);
84 internal smallDictt* setUndefinedKCharSmallDict(smallDictt *self, char key);
85 internal smallDictt* setBoolKCharSmallDict(smallDictt *self, char key, bool value);
86 internal smallDictt* setDoubleKCharSmallDict(smallDictt *self, char key, double value);
87 internal smallDictt* setIntKCharSmallDict(smallDictt *self, char key, int64_t value);
88 internal smallDictt* setSKCharSmallDict(smallDictt *self, char key, const char *string);
89 internal smallDictt* setCharKCharSmallDict(smallDictt *self, char key, char c);
90 internal smallDictt* setDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict);
91 internal smallDictt* setArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array);
92 internal smallDictt* setArraycKCharSmallDict(smallDictt *self, char key, char **array);
93 internal smallDictt* setCArraycKCharSmallDict(smallDictt *self, char key, const char **array);
94 internal smallDictt* setSmallBoolKCharSmallDict(smallDictt *self, char key, smallBoolt *value);
95 internal smallDictt* setSmallBytesKCharSmallDict(smallDictt *self, char key, smallBytest *value);
96 internal smallDictt* setSmallDoubleKCharSmallDict(smallDictt *self, char key, smallDoublet *value);
97 internal smallDictt* setSmallIntKCharSmallDict(smallDictt *self, char key, smallIntt *value);
98 internal smallDictt* setSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *value);
99 internal smallDictt* setSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string);
100 internal smallDictt* setSmallContainerKCharSmallDict(smallDictt *self, char key, smallContainert *container);
101 internal smallDictt* setNFreeSmallDict(smallDictt *self, const char *key, baset *value);
102 internal smallDictt* setNFreeUndefinedSmallDict(smallDictt *self, const char *key, undefinedt *u);
103 internal smallDictt* setNFreeSSmallDict(smallDictt *self, const char *key, char *string);
104 internal smallDictt* setNFreeDictSmallDict(smallDictt *self, const char *key, smallDictt *dict);
105 internal smallDictt* setNFreeArraySmallDict(smallDictt *self, const char *key, smallArrayt *array);
106 internal smallDictt* setNFreeArraycSmallDict(smallDictt *self, const char *key, char **array);
107 internal smallDictt* setNFreeSmallBoolSmallDict(smallDictt *self, const char *key, smallBoolt *value);
108 internal smallDictt* setNFreeSmallBytesSmallDict(smallDictt *self, const char *key, smallBytest *value);
109 internal smallDictt* setNFreeSmallDoubleSmallDict(smallDictt *self, const char *key, smallDoublet *value);
110 internal smallDictt* setNFreeSmallIntSmallDict(smallDictt *self, const char *key, smallIntt *value);
111 internal smallDictt* setNFreeSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *value);
112 internal smallDictt* setNFreeSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string);
113 internal smallDictt* setNFreeSmallContainerSmallDict(smallDictt *self, const char *key, smallContainert *container);
114 internal smallDictt* setNFreeKCharSmallDict(smallDictt *self, char key, baset *value);
115 internal smallDictt* setNFreeUndefinedKCharSmallDict(smallDictt *self, char key, undefinedt *u);
116 internal smallDictt* setNFreeSKCharSmallDict(smallDictt *self, char key, char *string);
117 internal smallDictt* setNFreeDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict);
118 internal smallDictt* setNFreeArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array);
119 internal smallDictt* setNFreeArraycKCharSmallDict(smallDictt *self, char key, char **array);
120 internal smallDictt* setNFreeSmallBoolKCharSmallDict(smallDictt *self, char key, smallBoolt *value);
121 internal smallDictt* setNFreeSmallBytesKCharSmallDict(smallDictt *self, char key, smallBytest *value);
122 internal smallDictt* setNFreeSmallDoubleKCharSmallDict(smallDictt *self, char key, smallDoublet *value);
123 internal smallDictt* setNFreeSmallIntKCharSmallDict(smallDictt *self, char key, smallIntt *value);
124 internal smallDictt* setNFreeSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *value);
125 internal smallDictt* setNFreeSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string);
126 internal smallDictt* setNFreeSmallContainerKCharSmallDict(smallDictt *self, char key, smallContainert *container);
127 internal smallDictt* setPDictSmallDict(smallDictt *self, const char *key, smallDictt *dict);
128 internal smallDictt* setPArraySmallDict(smallDictt *self, const char *key, smallArrayt *array);
129 internal smallDictt* setPSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *json);
130 internal smallDictt* setPSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string);
131 internal smallDictt* setNFreePDictSmallDict(smallDictt *self, const char *key, smallDictt *dict);
132 internal smallDictt* setNFreePArraySmallDict(smallDictt *self, const char *key, smallArrayt *array);
133 internal smallDictt* setNFreePSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *json);
134 internal smallDictt* setNFreePSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string);
135 internal smallDictt* setPArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array);
136 internal smallDictt* setPDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict);
137 internal smallDictt* setPSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *json);
138 internal smallDictt* setPSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string);
139 internal smallDictt* setNFreePArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array);
140 internal smallDictt* setNFreePDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict);
141 internal smallDictt* setNFreePSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *json);
142 internal smallDictt* setNFreePSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string);
143 internal baset* getSmallDict(smallDictt *self, const char *key);
144 internal undefinedt* getUndefinedSmallDict(smallDictt *self, const char *key);
145 internal bool getBoolSmallDict(smallDictt *self, const char *key);
146 internal bool* getBoolPSmallDict(smallDictt *self, const char *key);
147 internal double getDoubleSmallDict(smallDictt *self, const char *key);
148 internal double* getDoublePSmallDict(smallDictt *self, const char *key);
149 internal int64_t getIntSmallDict(smallDictt *self, const char *key);
150 internal int64_t* getIntPSmallDict(smallDictt *self, const char *key);
151 internal int32_t getInt32SmallDict(smallDictt *self, const char *key);
152 internal int32_t* getInt32PSmallDict(smallDictt *self, const char *key);
153 internal uint64_t getUintSmallDict(smallDictt *self, const char *key);
154 internal uint64_t* getUintPSmallDict(smallDictt *self, const char *key);
155 internal uint32_t getUint32SmallDict(smallDictt *self, const char *key);
156 internal uint32_t* getUint32PSmallDict(smallDictt *self, const char *key);
157 internal char* getSSmallDict(smallDictt *self, const char *key);
158 internal smallDictt* getDictSmallDict(smallDictt *self, const char *key);
159 internal smallArrayt* getArraySmallDict(smallDictt *self, const char *key);
160 internal smallBoolt* getSmallBoolSmallDict(smallDictt *self, const char *key);
161 internal smallBytest* getSmallBytesSmallDict(smallDictt *self, const char *key);
162 internal smallDoublet* getSmallDoubleSmallDict(smallDictt *self, const char *key);
163 internal smallIntt* getSmallIntSmallDict(smallDictt *self, const char *key);
164 internal smallJsont* getSmallJsonSmallDict(smallDictt *self, const char *key);
165 internal smallStringt* getSmallStringSmallDict(smallDictt *self, const char *key);
166 internal void* getVoidSmallDict(smallDictt *self, const char *key);
167 internal smallContainert* getSmallContainerSmallDict(smallDictt *self, const char *key);
168 internal baset* getKCharSmallDict(smallDictt *self, char key);
169 internal undefinedt* getUndefinedKCharSmallDict(smallDictt *self, char key);
170 internal bool getBoolKCharSmallDict(smallDictt *self, char key);
171 internal bool* getBoolPKCharSmallDict(smallDictt *self, char key);
172 internal double getDoubleKCharSmallDict(smallDictt *self, char key);
173 internal double* getDoublePKCharSmallDict(smallDictt *self, char key);
174 internal int64_t getIntKCharSmallDict(smallDictt *self, char key);
175 internal int64_t* getIntPKCharSmallDict(smallDictt *self, char key);
176 internal int32_t getInt32KCharSmallDict(smallDictt *self, char key);
177 internal int32_t* getInt32PKCharSmallDict(smallDictt *self, char key);
178 internal uint64_t getUintKCharSmallDict(smallDictt *self, char key);
179 internal uint64_t* getUintPKCharSmallDict(smallDictt *self, char key);
180 internal uint32_t getUint32KCharSmallDict(smallDictt *self, char key);
181 internal uint32_t* getUint32PKCharSmallDict(smallDictt *self, char key);
182 internal char* getSKCharSmallDict(smallDictt *self, char key);
183 internal smallDictt* getDictKCharSmallDict(smallDictt *self, char key);
184 internal smallArrayt* getArrayKCharSmallDict(smallDictt *self, char key);
185 internal smallBoolt* getSmallBoolKCharSmallDict(smallDictt *self, char key);
186 internal smallBytest* getSmallBytesKCharSmallDict(smallDictt *self, char key);
187 internal smallDoublet* getSmallDoubleKCharSmallDict(smallDictt *self, char key);
188 internal smallIntt* getSmallIntKCharSmallDict(smallDictt *self, char key);
189 internal smallJsont* getSmallJsonKCharSmallDict(smallDictt *self, char key);
190 internal smallStringt* getSmallStringKCharSmallDict(smallDictt *self, char key);
191 internal void* getVoidKCharSmallDict(smallDictt *self, char key);
192 internal smallContainert* getSmallContainerKCharSmallDict(smallDictt *self, char key);
193 internal baset* getNDupSmallDict(smallDictt *self, const char *key);
194 internal undefinedt* getNDupUndefinedSmallDict(smallDictt *self, const char *key);
195 internal bool getNDupBoolSmallDict(smallDictt *self, const char *key);
196 internal double getNDupDoubleSmallDict(smallDictt *self, const char *key);
197 internal int64_t getNDupIntSmallDict(smallDictt *self, const char *key);
198 internal int32_t getNDupInt32SmallDict(smallDictt *self, const char *key);
199 internal uint64_t getNDupUintSmallDict(smallDictt *self, const char *key);
200 internal uint32_t getNDupUint32SmallDict(smallDictt *self, const char *key);
201 internal char* getNDupSSmallDict(smallDictt *self, const char *key);
202 internal smallDictt* getNDupDictSmallDict(smallDictt *self, const char *key);
203 internal smallArrayt* getNDupArraySmallDict(smallDictt *self, const char *key);
204 internal smallBoolt* getNDupSmallBoolSmallDict(smallDictt *self, const char *key);
205 internal smallBytest* getNDupSmallBytesSmallDict(smallDictt *self, const char *key);
206 internal smallDoublet* getNDupSmallDoubleSmallDict(smallDictt *self, const char *key);
207 internal smallIntt* getNDupSmallIntSmallDict(smallDictt *self, const char *key);
208 internal smallJsont* getNDupSmallJsonSmallDict(smallDictt *self, const char *key);
209 internal smallStringt* getNDupSmallStringSmallDict(smallDictt *self, const char *key);
210 internal void* getNDupVoidSmallDict(smallDictt *self, const char *key);
211 internal smallContainert* getNDupSmallContainerSmallDict(smallDictt *self, const char *key);
212 internal baset* getNDupKCharSmallDict(smallDictt *self, char key);
213 internal undefinedt* getNDupUndefinedKCharSmallDict(smallDictt *self, char key);
214 internal bool getNDupBoolKCharSmallDict(smallDictt *self, char key);
215 internal double getNDupDoubleKCharSmallDict(smallDictt *self, char key);
216 internal int64_t getNDupIntKCharSmallDict(smallDictt *self, char key);
217 internal int32_t getNDupInt32KCharSmallDict(smallDictt *self, char key);
218 internal uint64_t getNDupUintKCharSmallDict(smallDictt *self, char key);
219 internal uint32_t getNDupUint32KCharSmallDict(smallDictt *self, char key);
220 internal char* getNDupSKCharSmallDict(smallDictt *self, char key);
221 internal smallDictt* getNDupDictKCharSmallDict(smallDictt *self, char key);
222 internal smallArrayt* getNDupArrayKCharSmallDict(smallDictt *self, char key);
223 internal smallBoolt* getNDupSmallBoolKCharSmallDict(smallDictt *self, char key);
224 internal smallBytest* getNDupSmallBytesKCharSmallDict(smallDictt *self, char key);
225 internal smallDoublet* getNDupSmallDoubleKCharSmallDict(smallDictt *self, char key);
226 internal smallIntt* getNDupSmallIntKCharSmallDict(smallDictt *self, char key);
227 internal smallJsont* getNDupSmallJsonKCharSmallDict(smallDictt *self, char key);
228 internal smallStringt* getNDupSmallStringKCharSmallDict(smallDictt *self, char key);
229 internal void* getNDupVoidKCharSmallDict(smallDictt *self, char key);
230 internal smallContainert* getNDupSmallContainerKCharSmallDict(smallDictt *self, char key);
231 internal double getNumSmallDict(smallDictt *self, const char *key);
232 internal baset* cropElemSmallDict(smallDictt *self, const char* key);
233 internal undefinedt* cropElemUndefinedSmallDict(smallDictt *self, const char* key);
234 internal bool cropElemBoolSmallDict(smallDictt *self, const char* key);
235 internal double cropElemDoubleSmallDict(smallDictt *self, const char* key);
236 internal int64_t cropElemIntSmallDict(smallDictt *self, const char* key);
237 internal int32_t cropElemInt32SmallDict(smallDictt *self, const char* key);
238 internal uint64_t cropElemUintSmallDict(smallDictt *self, const char* key);
239 internal uint32_t cropElemUint32SmallDict(smallDictt *self, const char* key);
240 internal char* cropElemSSmallDict(smallDictt *self, const char* key);
241 internal smallDictt* cropElemDictSmallDict(smallDictt *self, const char* key);
242 internal smallArrayt* cropElemArraySmallDict(smallDictt *self, const char* key);
243 internal smallBoolt* cropElemSmallBoolSmallDict(smallDictt *self, const char* key);
244 internal smallBytest* cropElemSmallBytesSmallDict(smallDictt *self, const char* key);
245 internal smallDoublet* cropElemSmallDoubleSmallDict(smallDictt *self, const char* key);
246 internal smallIntt* cropElemSmallIntSmallDict(smallDictt *self, const char* key);
247 internal smallJsont* cropElemSmallJsonSmallDict(smallDictt *self, const char* key);
248 internal smallStringt* cropElemSmallStringSmallDict(smallDictt *self, const char* key);
249 internal void* cropElemVoidSmallDict(smallDictt *self, const char* key);
250 internal smallContainert* cropElemSmallContainerSmallDict(smallDictt *self, const char* key);
251 internal smallDictt* delSmallDict(smallDictt *self, const char *key);
252 internal smallDictt* delKCharSmallDict(smallDictt *self, char key);
253 internal smallDictt* removeSmallDict(smallDictt *self, const char *key);
254 internal smallDictt* removeKCharSmallDict(smallDictt *self, char key);
255 internal bool hasSmallDict(smallDictt *self, const char *key);
256 internal bool hasKCharSmallDict(smallDictt *self, char key);
257 internal char* keyBySmallDict(smallDictt *self, baset *value);
258 internal char* keyByUndefinedSmallDict(smallDictt *self, undefinedt *u);
259 internal char* keyByBoolSmallDict(smallDictt *self, bool value);
260 internal char* keyByDoubleSmallDict(smallDictt *self, double value);
261 internal char* keyByIntSmallDict(smallDictt *self, int64_t value);
262 internal char* keyBySSmallDict(smallDictt *self, const char *string);
263 internal char* keyByCharSmallDict(smallDictt *self, char c);
264 internal char* keyByDictSmallDict(smallDictt *self, smallDictt *dict);
265 internal char* keyByArraySmallDict(smallDictt *self, smallArrayt *array);
266 internal char* keyByArraycSmallDict(smallDictt *self, char **array);
267 internal char* keyByCArraycSmallDict(smallDictt *self, const char **array);
268 internal char* keyBySmallBoolSmallDict(smallDictt *self, smallBoolt *value);
269 internal char* keyBySmallBytesSmallDict(smallDictt *self, smallBytest *value);
270 internal char* keyBySmallDoubleSmallDict(smallDictt *self, smallDoublet *value);
271 internal char* keyBySmallIntSmallDict(smallDictt *self, smallIntt *value);
272 internal char* keyBySmallJsonSmallDict(smallDictt *self, smallJsont *string);
273 internal char* keyBySmallStringSmallDict(smallDictt *self, smallStringt *string);
274 internal char* keyBySmallContainerSmallDict(smallDictt *self, smallContainert *container);
275 internal char* icKeyBySmallDict(smallDictt *self, baset *value);
276 internal char* icKeyBySSmallDict(smallDictt *self, const char *string);
277 internal char* icKeyByCharSmallDict(smallDictt *self, char c);
278 internal char* icKeyByDictSmallDict(smallDictt *self, smallDictt *dict);
279 internal char* icKeyByArraySmallDict(smallDictt *self, smallArrayt *array);
280 internal char* icKeyByArraycSmallDict(smallDictt *self, char **array);
281 internal char* icKeyByCArraycSmallDict(smallDictt *self, const char **array);
282 internal char* icKeyBySmallJsonSmallDict(smallDictt *self, smallJsont *string);
283 internal char* icKeyBySmallStringSmallDict(smallDictt *self, smallStringt *string);
284 internal smallDictt* trimSmallDict(smallDictt *self);
285 internal char** keysSmallDict(smallDictt *self);
286 internal smallArrayt* keysSmallStringSmallDict(smallDictt *self);
287 internal smallArrayt* valuesSmallDict(smallDictt *self);
288 internal smallDictt* mergeSmallDict(smallDictt *self, smallDictt *smallDict);
289 internal smallDictt* mergeSmallJsonSmallDict(smallDictt *self, smallJsont *json);
290 internal smallDictt* mergeNSmashSmallDict(smallDictt *self, smallDictt *smallDict);
291 internal smallDictt* mergeNSmashSmallJsonSmallDict(smallDictt *self, smallJsont *json);
292 internal smallDictt* appendSmallDict(smallDictt *self, smallDictt *smallDict);
293 internal smallDictt* appendNSmashSmallDict(smallDictt *self, smallDictt *smallDict);
294 internal bool equalSmallDictBase(smallDictt* self, baset* p2);
295 internal bool equalSmallDictSmallJson(smallDictt* self, smallJsont* p2);
296 internal bool equalSmallDict(smallDictt* self, smallDictt* p2);
297 internal bool icEqualSmallDictBase(smallDictt* self, baset* p2);
298 internal bool icEqualSmallDictSmallJson(smallDictt* self, smallJsont* p2);
299 internal bool icEqualSmallDict(smallDictt* self, smallDictt* p2);
300 internal size_t lenSmallDict(smallDictt *self);
301 internal smallDictt* emptySmallDict(smallDictt *self);
302 internal bool isEmptySmallDict(smallDictt *self);
303 internal void enumerateSmallDictF(smallDictt *self, void *closure, enumerateElementSmallDictFt funcElem);
304 internal baset* iterStartSmallDict(smallDictt *self);
305 internal const char* iterStartKeySmallDict(smallDictt *self);
306 internal baset* iterNextSmallDict(smallDictt *self);
307 internal const char* iterNextKeySmallDict(smallDictt *self);
308 internal baset* iterElementSmallDict(smallDictt *self);
309 internal const char* iterKeySmallDict(smallDictt *self);
310 internal smallDictt* zipSmallDict(smallDictt *self, smallArrayt *keys, smallArrayt *values);
311 internal smallDictt* zipSmallJsonSmallDict(smallDictt *self, smallArrayt *keys, smallJsont *values);
312 internal smallDictt* zipSmallJsonSmallArraySmallDict(smallDictt *self, smallJsont *keys, smallArrayt *values);
313 internal smallDictt* zipSmallJsonSmallJsonSmallDict(smallDictt *self, smallJsont *keys, smallJsont *values);
314 internal smallDictt* zipSmallJsonVArraySmallDict(smallDictt *self, smallJsont *keys, char** values);
315 internal smallDictt* zipSmallJsonVCArraySmallDict(smallDictt *self, smallJsont *keys, const char** values);
316 internal smallDictt* zipArraySmallDict(smallDictt *self, char** keys, smallArrayt *values);
317 internal smallDictt* zipCArraySmallDict(smallDictt *self, const char** keys, smallArrayt *values);
318 internal smallDictt* zipArraySmallJsonSmallDict(smallDictt *self, char** keys, smallJsont *values);
319 internal smallDictt* zipCArraySmallJsonSmallDict(smallDictt *self, const char** keys, smallJsont *values);
320 internal smallDictt* zipArrayArraySmallDict(smallDictt *self, char** keys, char** values);
321 internal smallDictt* zipCArrayArraySmallDict(smallDictt *self, const char** keys, char** values);
322 internal smallDictt* zipArrayCArraySmallDict(smallDictt *self, char** keys, const char** values);
323 internal smallDictt* zipCArrayCArraySmallDict(smallDictt *self, const char** keys, const char** values);
324 internal smallDictt* zipVArraySmallDict(smallDictt *self, smallArrayt *keys, char** values);
325 internal smallDictt* zipVCArraySmallDict(smallDictt *self, smallArrayt *keys, const char** values);
326 internal smallDictt* fromArraySmallDict(smallDictt *self, smallArrayt *items);
327 internal smallArrayt* toArraySmallDict(smallDictt *self);
328 internal bool writeFileSmallDict(smallDictt *self, const char *filePath);
329 internal bool writeFileSmallJsonSmallDict(smallDictt *self, smallJsont *filePath);
330 internal bool writeFileSmallStringSmallDict(smallDictt *self, smallStringt *filePath);
331 internal bool writeStreamSmallDict(smallDictt *self, FILE *fp);
332 internal bool appendFileSmallDict(smallDictt *self, const char *filePath);
333 internal bool appendFileSmallStringSmallDict(smallDictt *self, smallStringt *filePath);
334 internal void logSmallDict(smallDictt *self);
335 internal const char* typeStringSmallDict(smallDictt *self, const char *key);
336 internal smallStringt* typeSmallStringSmallDict(smallDictt *self, const char *key);
337 internal const char* typeStringKCharSmallDict(smallDictt *self, char key);
338 internal smallStringt* typeSmallStringKCharSmallDict(smallDictt *self, char key);
339 internal char typeSmallDict(smallDictt *self, const char *key);
340 internal char typeKCharSmallDict(smallDictt *self, char key);
341 internal smallDictt* typeStringsSmallDict(smallDictt *self);
342 internal bool isETypeSmallDict(smallDictt *self, const char *key, const char *type);
343 internal bool isEUndefinedSmallDict(smallDictt *self, const char *key);
344 internal bool isEBoolSmallDict(smallDictt *self, const char *key);
345 internal bool isEContainerSmallDict(smallDictt *self, const char *key);
346 internal bool isEDictSmallDict(smallDictt *self, const char *key);
347 internal bool isEDoubleSmallDict(smallDictt *self, const char *key);
348 internal bool isEIntSmallDict(smallDictt *self, const char *key);
349 internal bool isEStringSmallDict(smallDictt *self, const char *key);
350 internal bool isEFaststringSmallDict(smallDictt *self, const char *key);
351 internal bool isEArraySmallDict(smallDictt *self, const char *key);
352 internal bool isEBytesSmallDict(smallDictt *self, const char *key);
353 internal bool areAllETypeSmallDict(smallDictt *self, const char *type);
354 internal bool areAllEUndefinedSmallDict(smallDictt *self);
355 internal bool areAllEBoolSmallDict(smallDictt *self);
356 internal bool areAllEContainerSmallDict(smallDictt *self);
357 internal bool areAllEDictSmallDict(smallDictt *self);
358 internal bool areAllEDoubleSmallDict(smallDictt *self);
359 internal bool areAllEIntSmallDict(smallDictt *self);
360 internal bool areAllEStringSmallDict(smallDictt *self);
361 internal bool areAllEFaststringSmallDict(smallDictt *self);
362 internal bool areAllEArraySmallDict(smallDictt *self);
363 internal bool areAllEBytesSmallDict(smallDictt *self);
364 smallDictt* allocSmallDictG(smallDictt *self UNUSED);
365 smallDictt* duplicateSmallDictG (smallDictt *self);
366 smallDictt* setSmallDictG (smallDictt *self, const char *key, baset *value);
367 baset* getSmallDictG (smallDictt *self, baset* retType UNUSED, const char *key);
368 undefinedt* getUndefinedSmallDictG (smallDictt *self, undefinedt* retType UNUSED, const char *key);
369 bool getBoolSmallDictG (smallDictt *self, bool retType UNUSED, const char *key);
370 bool* getBoolPSmallDictG (smallDictt *self, bool* retType UNUSED, const char *key);
371 double getDoubleSmallDictG (smallDictt *self, double retType UNUSED, const char *key);
372 double* getDoublePSmallDictG (smallDictt *self, double* retType UNUSED, const char *key);
373 int64_t getIntSmallDictG (smallDictt *self, int64_t retType UNUSED, const char *key);
374 int64_t* getIntPSmallDictG (smallDictt *self, int64_t* retType UNUSED, const char *key);
375 int32_t getInt32SmallDictG (smallDictt *self, int32_t retType UNUSED, const char *key);
376 int32_t* getInt32PSmallDictG (smallDictt *self, int32_t* retType UNUSED, const char *key);
377 uint64_t getUintSmallDictG (smallDictt *self, uint64_t retType UNUSED, const char *key);
378 uint64_t* getUintPSmallDictG (smallDictt *self, uint64_t* retType UNUSED, const char *key);
379 uint32_t getUint32SmallDictG (smallDictt *self, uint32_t retType UNUSED, const char *key);
380 uint32_t* getUint32PSmallDictG (smallDictt *self, uint32_t* retType UNUSED, const char *key);
381 char* getSSmallDictG (smallDictt *self, char* retType UNUSED, const char *key);
382 smallDictt* getDictSmallDictG (smallDictt *self, smallDictt* retType UNUSED, const char *key);
383 smallArrayt* getArraySmallDictG (smallDictt *self, smallArrayt* retType UNUSED, const char *key);
384 smallBoolt* getSmallBoolSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, const char *key);
385 smallBytest* getSmallBytesSmallDictG (smallDictt *self, smallBytest* retType UNUSED, const char *key);
386 smallDoublet* getSmallDoubleSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, const char *key);
387 smallIntt* getSmallIntSmallDictG (smallDictt *self, smallIntt* retType UNUSED, const char *key);
388 smallJsont* getSmallJsonSmallDictG(smallDictt *self, smallJsont* retType UNUSED, const char *key);
389 smallStringt* getSmallStringSmallDictG (smallDictt *self, smallStringt* retType UNUSED, const char *key);
390 void* getVoidSmallDictG (smallDictt *self, void* retType UNUSED, const char *key);
391 smallContainert* getSmallContainerSmallDictG(smallDictt *self, smallContainert* retType UNUSED, const char *key);
392 baset* getKCharSmallDictG (smallDictt *self, baset* retType UNUSED, char key);
393 undefinedt* getUndefinedKCharSmallDictG (smallDictt *self, undefinedt* retType UNUSED, char key);
394 bool getBoolKCharSmallDictG (smallDictt *self, bool retType UNUSED, char key);
395 bool* getBoolPKCharSmallDictG (smallDictt *self, bool* retType UNUSED, char key);
396 double getDoubleKCharSmallDictG (smallDictt *self, double retType UNUSED, char key);
397 double* getDoublePKCharSmallDictG (smallDictt *self, double* retType UNUSED, char key);
398 int64_t getIntKCharSmallDictG (smallDictt *self, int64_t retType UNUSED, char key);
399 int64_t* getIntPKCharSmallDictG (smallDictt *self, int64_t* retType UNUSED, char key);
400 int32_t getInt32KCharSmallDictG (smallDictt *self, int32_t retType UNUSED, char key);
401 int32_t* getInt32PKCharSmallDictG (smallDictt *self, int32_t* retType UNUSED, char key);
402 uint64_t getUintKCharSmallDictG (smallDictt *self, uint64_t retType UNUSED, char key);
403 uint64_t* getUintPKCharSmallDictG (smallDictt *self, uint64_t* retType UNUSED, char key);
404 uint32_t getUint32KCharSmallDictG (smallDictt *self, uint32_t retType UNUSED, char key);
405 uint32_t* getUint32PKCharSmallDictG (smallDictt *self, uint32_t* retType UNUSED, char key);
406 char* getSKCharSmallDictG (smallDictt *self, char* retType UNUSED, char key);
407 smallDictt* getDictKCharSmallDictG (smallDictt *self, smallDictt* retType UNUSED, char key);
408 smallArrayt* getArrayKCharSmallDictG (smallDictt *self, smallArrayt* retType UNUSED, char key);
409 smallBoolt* getSmallBoolKCharSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, char key);
410 smallBytest* getSmallBytesKCharSmallDictG (smallDictt *self, smallBytest* retType UNUSED, char key);
411 smallDoublet* getSmallDoubleKCharSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, char key);
412 smallIntt* getSmallIntKCharSmallDictG (smallDictt *self, smallIntt* retType UNUSED, char key);
413 smallJsont* getSmallJsonKCharSmallDictG(smallDictt *self, smallJsont* retType UNUSED, char key);
414 smallStringt* getSmallStringKCharSmallDictG (smallDictt *self, smallStringt* retType UNUSED, char key);
415 void* getVoidKCharSmallDictG (smallDictt *self, void* retType UNUSED, char key);
416 smallContainert* getSmallContainerKCharSmallDictG(smallDictt *self, smallContainert* retType UNUSED, char key);
417 baset* getNDupSmallDictG (smallDictt *self, baset* retType UNUSED, const char *key);
418 undefinedt* getNDupUndefinedSmallDictG (smallDictt *self, undefinedt* retType UNUSED, const char *key);
419 bool getNDupBoolSmallDictG (smallDictt *self, bool retType UNUSED, const char *key);
420 double getNDupDoubleSmallDictG (smallDictt *self, double retType UNUSED, const char *key);
421 int64_t getNDupIntSmallDictG (smallDictt *self, int64_t retType UNUSED, const char *key);
422 int32_t getNDupInt32SmallDictG (smallDictt *self, int32_t retType UNUSED, const char *key);
423 uint64_t getNDupUintSmallDictG (smallDictt *self, uint64_t retType UNUSED, const char *key);
424 uint32_t getNDupUint32SmallDictG (smallDictt *self, uint32_t retType UNUSED, const char *key);
425 char* getNDupSSmallDictG (smallDictt *self, char* retType UNUSED, const char *key);
426 smallDictt* getNDupDictSmallDictG (smallDictt *self, smallDictt* retType UNUSED, const char *key);
427 smallArrayt* getNDupArraySmallDictG (smallDictt *self, smallArrayt* retType UNUSED, const char *key);
428 smallBoolt* getNDupSmallBoolSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, const char *key);
429 smallBytest* getNDupSmallBytesSmallDictG (smallDictt *self, smallBytest* retType UNUSED, const char *key);
430 smallDoublet* getNDupSmallDoubleSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, const char *key);
431 smallIntt* getNDupSmallIntSmallDictG (smallDictt *self, smallIntt* retType UNUSED, const char *key);
432 smallJsont* getNDupSmallJsonSmallDictG (smallDictt *self, smallJsont* retType UNUSED, const char *key);
433 smallStringt* getNDupSmallStringSmallDictG (smallDictt *self, smallStringt* retType UNUSED, const char *key);
434 void* getNDupVoidSmallDictG (smallDictt *self, void* retType UNUSED, const char *key);
435 smallContainert* getNDupSmallContainerSmallDictG(smallDictt *self, smallContainert* retType UNUSED, const char *key);
436 baset* getNDupKCharSmallDictG (smallDictt *self, baset* retType UNUSED, char key);
437 undefinedt* getNDupUndefinedKCharSmallDictG (smallDictt *self, undefinedt* retType UNUSED, char key);
438 bool getNDupBoolKCharSmallDictG (smallDictt *self, bool retType UNUSED, char key);
439 double getNDupDoubleKCharSmallDictG (smallDictt *self, double retType UNUSED, char key);
440 int64_t getNDupIntKCharSmallDictG (smallDictt *self, int64_t retType UNUSED, char key);
441 int32_t getNDupInt32KCharSmallDictG (smallDictt *self, int32_t retType UNUSED, char key);
442 uint64_t getNDupUintKCharSmallDictG (smallDictt *self, uint64_t retType UNUSED, char key);
443 uint32_t getNDupUint32KCharSmallDictG (smallDictt *self, uint32_t retType UNUSED, char key);
444 char* getNDupSKCharSmallDictG (smallDictt *self, char* retType UNUSED, char key);
445 smallDictt* getNDupDictKCharSmallDictG (smallDictt *self, smallDictt* retType UNUSED, char key);
446 smallArrayt* getNDupArrayKCharSmallDictG (smallDictt *self, smallArrayt* retType UNUSED, char key);
447 smallBoolt* getNDupSmallBoolKCharSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, char key);
448 smallBytest* getNDupSmallBytesKCharSmallDictG (smallDictt *self, smallBytest* retType UNUSED, char key);
449 smallDoublet* getNDupSmallDoubleKCharSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, char key);
450 smallIntt* getNDupSmallIntKCharSmallDictG (smallDictt *self, smallIntt* retType UNUSED, char key);
451 smallJsont* getNDupSmallJsonKCharSmallDictG (smallDictt *self, smallJsont* retType UNUSED, char key);
452 smallStringt* getNDupSmallStringKCharSmallDictG (smallDictt *self, smallStringt* retType UNUSED, char key);
453 void* getNDupVoidKCharSmallDictG (smallDictt *self, void* retType UNUSED, char key);
454 smallContainert* getNDupSmallContainerKCharSmallDictG(smallDictt *self, smallContainert* retType UNUSED, char key);
455 smallDictt* setUndefinedSmallDictG(smallDictt *self, const char *key, void *value UNUSED);
456 smallDictt* setBoolSmallDictG (smallDictt *self, const char *key, bool value);
457 smallDictt* setDoubleSmallDictG (smallDictt *self, const char *key, double value);
458 smallDictt* setIntSmallDictG (smallDictt *self, const char *key, int64_t value);
459 smallDictt* setSSmallDictG (smallDictt *self, const char *key, const char *string);
460 smallDictt* setCharSmallDictG (smallDictt *self, const char *key, char c);
461 smallDictt* setDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict);
462 smallDictt* setArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array);
463 smallDictt* setArraycSmallDictG (smallDictt *self, const char *key, char **array);
464 smallDictt* setCArraycSmallDictG (smallDictt *self, const char *key, const char **array);
465 smallDictt* setVoidSmallDictG (smallDictt *self, const char *key, void *value);
466 smallDictt* setSmallBoolSmallDictG (smallDictt *self, const char *key, smallBoolt *value);
467 smallDictt* setSmallBytesSmallDictG (smallDictt *self, const char *key, smallBytest *value);
468 smallDictt* setSmallDoubleSmallDictG (smallDictt *self, const char *key, smallDoublet *value);
469 smallDictt* setSmallIntSmallDictG (smallDictt *self, const char *key, smallIntt *value);
470 smallDictt* setSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *value);
471 smallDictt* setSmallStringSmallDictG (smallDictt *self, const char *key, smallStringt *string);
472 smallDictt* setSmallContainerSmallDictG(smallDictt *self, const char *key, smallContainert *container);
473 smallDictt* setKCharSmallDictG (smallDictt *self, char key, baset *value);
474 smallDictt* setUndefinedKCharSmallDictG(smallDictt *self, char key, undefinedt *value UNUSED);
475 smallDictt* setBoolKCharSmallDictG (smallDictt *self, char key, bool value);
476 smallDictt* setDoubleKCharSmallDictG (smallDictt *self, char key, double value);
477 smallDictt* setIntKCharSmallDictG (smallDictt *self, char key, int64_t value);
478 smallDictt* setSKCharSmallDictG (smallDictt *self, char key, const char *string);
479 smallDictt* setCharKCharSmallDictG (smallDictt *self, char key, char c);
480 smallDictt* setDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict);
481 smallDictt* setArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array);
482 smallDictt* setArraycKCharSmallDictG (smallDictt *self, char key, char **array);
483 smallDictt* setCArraycKCharSmallDictG (smallDictt *self, char key, const char **array);
484 smallDictt* setVoidKCharSmallDictG (smallDictt *self, char key, void *value);
485 smallDictt* setSmallBoolKCharSmallDictG (smallDictt *self, char key, smallBoolt *value);
486 smallDictt* setSmallBytesKCharSmallDictG (smallDictt *self, char key, smallBytest *value);
487 smallDictt* setSmallDoubleKCharSmallDictG (smallDictt *self, char key, smallDoublet *value);
488 smallDictt* setSmallIntKCharSmallDictG (smallDictt *self, char key, smallIntt *value);
489 smallDictt* setSmallJsonKCharSmallDictG (smallDictt *self, char key, smallJsont *value);
490 smallDictt* setSmallStringKCharSmallDictG (smallDictt *self, char key, smallStringt *string);
491 smallDictt* setSmallContainerKCharSmallDictG(smallDictt *self, char key, smallContainert *container);
492 smallDictt* setNFreeSmallDictG (smallDictt *self, const char *key, baset *value);
493 smallDictt* setNFreeUndefinedSmallDictG(smallDictt *self, const char *key, undefinedt *value);
494 smallDictt* setNFreeSSmallDictG (smallDictt *self, const char *key, char *string);
495 smallDictt* setNFreeDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict);
496 smallDictt* setNFreeArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array);
497 smallDictt* setNFreeArraycSmallDictG (smallDictt *self, const char *key, char **array);
498 smallDictt* setNFreeSmallBoolSmallDictG (smallDictt *self, const char *key, smallBoolt *value);
499 smallDictt* setNFreeSmallBytesSmallDictG (smallDictt *self, const char *key, smallBytest *value);
500 smallDictt* setNFreeSmallDoubleSmallDictG (smallDictt *self, const char *key, smallDoublet *value);
501 smallDictt* setNFreeSmallIntSmallDictG (smallDictt *self, const char *key, smallIntt *value);
502 smallDictt* setNFreeSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *value);
503 smallDictt* setNFreeSmallStringSmallDictG (smallDictt *self, const char *key, smallStringt *string);
504 smallDictt* setNFreeSmallContainerSmallDictG(smallDictt *self, const char *key, smallContainert *container);
505 smallDictt* setNFreeKCharSmallDictG (smallDictt *self, char key, baset *value);
506 smallDictt* setNFreeUndefinedKCharSmallDictG(smallDictt *self, char key, undefinedt *u);
507 smallDictt* setNFreeSKCharSmallDictG (smallDictt *self, char key, char *string);
508 smallDictt* setNFreeDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict);
509 smallDictt* setNFreeArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array);
510 smallDictt* setNFreeArraycKCharSmallDictG (smallDictt *self, char key, char **array);
511 smallDictt* setNFreeSmallBoolKCharSmallDictG (smallDictt *self, char key, smallBoolt *value);
512 smallDictt* setNFreeSmallBytesKCharSmallDictG (smallDictt *self, char key, smallBytest *value);
513 smallDictt* setNFreeSmallDoubleKCharSmallDictG (smallDictt *self, char key, smallDoublet *value);
514 smallDictt* setNFreeSmallIntKCharSmallDictG (smallDictt *self, char key, smallIntt *value);
515 smallDictt* setNFreeSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *value);
516 smallDictt* setNFreeSmallStringKCharSmallDictG (smallDictt *self, char key, smallStringt *string);
517 smallDictt* setNFreeSmallContainerKCharSmallDictG(smallDictt *self, char key, smallContainert *container);
518 smallDictt* setPDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict);
519 smallDictt* setPArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array);
520 smallDictt* setPSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *json);
521 smallDictt* setPSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string);
522 smallDictt* setNFreePDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict);
523 smallDictt* setNFreePArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array);
524 smallDictt* setNFreePSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *json);
525 smallDictt* setNFreePSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string);
526 smallDictt* setPArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array);
527 smallDictt* setPDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict);
528 smallDictt* setPSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *json);
529 smallDictt* setPSmallStringKCharSmallDictG (smallDictt *self, char key, smallStringt *string);
530 smallDictt* setNFreePArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array);
531 smallDictt* setNFreePDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict);
532 smallDictt* setNFreePSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *json);
533 smallDictt* setNFreePSmallStringKCharSmallDictG(smallDictt *self, char key, smallStringt *string);
534 smallDictt* mergeSmallDictG (smallDictt *self, smallDictt *smallDict);
535 smallDictt* mergeSmallJsonSmallDictG(smallDictt *self, smallJsont *json);
536 smallDictt* mergeNSmashSmallDictG (smallDictt *self, smallDictt *smallDict);
537 smallDictt* mergeNSmashSmallJsonSmallDictG(smallDictt *self, smallJsont *json);
538 bool equalSmallDictBaseG(smallDictt* self, baset* p2);
539 bool equalSmallDictSmallJsonG (smallDictt* self, smallJsont* p2);
540 bool equalSmallDictG(smallDictt* self, smallDictt* p2);
541 bool icEqualSmallDictBaseG(smallDictt* self, baset* p2);
542 bool icEqualSmallDictSmallJsonG(smallDictt* self, smallJsont* p2);
543 bool icEqualSmallDictG(smallDictt* self, smallDictt* p2);
544 double getNumSmallDictG(smallDictt *self, const char *key);
545 baset* cropElemSmallDictG (smallDictt *self, const char* key);
546 undefinedt* cropElemUndefinedSmallDictG (smallDictt *self, const char* key);
547 bool cropElemBoolSmallDictG (smallDictt *self, const char* key);
548 double cropElemDoubleSmallDictG (smallDictt *self, const char* key);
549 int64_t cropElemIntSmallDictG (smallDictt *self, const char* key);
550 int32_t cropElemInt32SmallDictG (smallDictt *self, const char* key);
551 uint64_t cropElemUintSmallDictG (smallDictt *self, const char* key);
552 uint32_t cropElemUint32SmallDictG (smallDictt *self, const char* key);
553 char* cropElemSSmallDictG (smallDictt *self, const char* key);
554 smallDictt* cropElemDictSmallDictG (smallDictt *self, const char* key);
555 smallArrayt* cropElemArraySmallDictG (smallDictt *self, const char* key);
556 smallBoolt* cropElemSmallBoolSmallDictG (smallDictt *self, const char* key);
557 smallBytest* cropElemSmallBytesSmallDictG (smallDictt *self, const char* key);
558 smallDoublet* cropElemSmallDoubleSmallDictG (smallDictt *self, const char* key);
559 smallIntt* cropElemSmallIntSmallDictG (smallDictt *self, const char* key);
560 smallJsont* cropElemSmallJsonSmallDictG (smallDictt *self, const char* key);
561 smallStringt* cropElemSmallStringSmallDictG (smallDictt *self, const char* key);
562 void* cropElemVoidSmallDictG (smallDictt *self, const char* key);
563 smallContainert* cropElemSmallContainerSmallDictG(smallDictt *self, const char* key);
564 smallDictt* delSmallDictG (smallDictt *self, const char *key, int unused UNUSED);
565 smallDictt* delKCharSmallDictG (smallDictt *self, char key, int unused UNUSED);
566 smallDictt* delElemSmallDictG (smallDictt *self, const char *key);
567 smallDictt* delElemKCharSmallDictG(smallDictt *self, char key);
568 smallDictt* removeSmallDictG (smallDictt *self, const char *key, int unused UNUSED);
569 smallDictt* removeKCharSmallDictG (smallDictt *self, char key, int unused UNUSED);
570 smallDictt* removeElemSmallDictG (smallDictt *self, const char *key);
571 smallDictt* removeElemKCharSmallDictG(smallDictt *self, char key);
572 bool hasSmallDictG (smallDictt *self, const char *key);
573 bool hasKCharSmallDictG (smallDictt *self, char key);
574 char* keyBySmallDictG(smallDictt *self, baset *value);
575 char* keyByUndefinedSmallDictG(smallDictt *self, undefinedt *u);
576 char* keyByBoolSmallDictG(smallDictt *self, bool value);
577 char* keyByDoubleSmallDictG(smallDictt *self, double value);
578 char* keyByIntSmallDictG(smallDictt *self, int64_t value);
579 char* keyBySSmallDictG(smallDictt *self, const char *string);
580 char* keyByCharSmallDictG(smallDictt *self, char c);
581 char* keyByDictSmallDictG(smallDictt *self, smallDictt *dict);
582 char* keyByArraySmallDictG(smallDictt *self, smallArrayt *array);
583 char* keyByArraycSmallDictG(smallDictt *self, char **array);
584 char* keyByCArraycSmallDictG(smallDictt *self, const char **array);
585 char* keyBySmallBoolSmallDictG(smallDictt *self, smallBoolt *value);
586 char* keyBySmallBytesSmallDictG(smallDictt *self, smallBytest *value);
587 char* keyBySmallDoubleSmallDictG(smallDictt *self, smallDoublet *value);
588 char* keyBySmallIntSmallDictG(smallDictt *self, smallIntt *value);
589 char* keyBySmallJsonSmallDictG(smallDictt *self, smallJsont *string);
590 char* keyBySmallStringSmallDictG(smallDictt *self, smallStringt *string);
591 char* keyBySmallContainerSmallDictG(smallDictt *self, smallContainert *container);
592 char* icKeyBySmallDictG(smallDictt *self, baset *value);
593 char* icKeyBySSmallDictG(smallDictt *self, const char *string);
594 char* icKeyByCharSmallDictG(smallDictt *self, char c);
595 char* icKeyByDictSmallDictG(smallDictt *self, smallDictt *dict);
596 char* icKeyByArraySmallDictG(smallDictt *self, smallArrayt *array);
597 char* icKeyByArraycSmallDictG(smallDictt *self, char **array);
598 char* icKeyByCArraycSmallDictG(smallDictt *self, const char **array);
599 char* icKeyBySmallJsonSmallDictG(smallDictt *self, smallJsont *string);
600 char* icKeyBySmallStringSmallDictG(smallDictt *self, smallStringt *string);
601 smallDictt* trimSmallDictG(smallDictt *self);
602 smallArrayt* keysSmallStringSmallDictG(smallDictt *self);
603 size_t lenSmallDictG (smallDictt *self);
604 smallDictt* emptySmallDictG (smallDictt *self);
605 bool isEmptySmallDictG (smallDictt *self);
606 smallDictt* zipSmallDictG (smallDictt *self, smallArrayt *keys, smallArrayt *values);
607 smallDictt* zipSmallJsonSmallDictG(smallDictt *self, smallArrayt *keys, smallJsont *values);
608 smallDictt* zipSmallJsonSmallArraySmallDictG(smallDictt *self, smallJsont *keys, smallArrayt *values);
609 smallDictt* zipSmallJsonSmallJsonSmallDictG (smallDictt *self, smallJsont *keys, smallJsont *values);
610 smallDictt* zipSmallJsonVArraySmallDictG (smallDictt *self, smallJsont *keys, char **values);
611 smallDictt* zipSmallJsonVCArraySmallDictG (smallDictt *self, smallJsont *keys, const char **values);
612 smallDictt* zipArraySmallDictG(smallDictt *self, char** keys, smallArrayt *values);
613 smallDictt* zipArraySmallJsonSmallDictG (smallDictt *self, char** keys, smallJsont *values);
614 smallDictt* zipCArraySmallDictG(smallDictt *self, const char** keys, smallArrayt *values);
615 smallDictt* zipCArraySmallJsonSmallDictG (smallDictt *self, const char** keys, smallJsont *values);
616 smallDictt* zipArrayArraySmallDictG(smallDictt *self, char** keys, char** values);
617 smallDictt* zipCArrayArraySmallDictG(smallDictt *self, const char** keys, char** values);
618 smallDictt* zipArrayCArraySmallDictG(smallDictt *self, char** keys, const char** values);
619 smallDictt* zipCArrayCArraySmallDictG(smallDictt *self, const char** keys, const char** values);
620 smallDictt* zipVArraySmallDictG (smallDictt *self, smallArrayt *keys, char** values);
621 smallDictt* zipVCArraySmallDictG (smallDictt *self, smallArrayt *keys, const char** values);
622 smallDictt* fromArraySmallDictG (smallDictt *self, smallArrayt *items);
623 smallArrayt* toArraySmallDictG (smallDictt *self);
624 bool writeFileSmallDictG (smallDictt *self, const char *filePath);
625 bool writeFileSmallJsonSmallDictG (smallDictt *self, smallJsont *filePath);
626 bool writeFileSmallStringSmallDictG (smallDictt *self, smallStringt *filePath);
627 bool writeStreamSmallDictG (smallDictt *self, FILE *fp);
628 bool appendFileSmallDictG (smallDictt *self, const char *filePath);
629 bool appendFileSmallStringSmallDictG (smallDictt *self, smallStringt *filePath);
630 void logSmallDictG(smallDictt *self);
631 smallStringt* typeSmallStringSmallDictG(smallDictt *self, const char *key);
632 const char* typeStringKCharSmallDictG (smallDictt *self, char key);
633 smallStringt* typeSmallStringKCharSmallDictG (smallDictt *self, char key);
634 
635 void initiateSmallDict(smallDictt *self) {
636 
637  self->type = "smallDict";
638  if (!smallDictF) {
639  isError(smallDictF, malloc(sizeof(smallDictFunctionst))) {
640  self->f = NULL;
641  return;
642  }
643  registerMethodsSmallDict(smallDictF);
644  }
645  self->f = smallDictF;
646 
647  self->d = NULL;
648  self->iterIndex = -1;
649  self->iterKey = NULL;
650  self->iterElement = NULL;
651  self->iterElementDataType = 0;
652 }
653 
654 void registerMethodsSmallDict(smallDictFunctionst *f) {
655 
656  f->free = freeSmallDict;
657  f->terminate = terminateSmallDict;
658  f->toString = toStringSmallDict;
659  f->duplicate = duplicateSmallDict;
660 
661  f->escape = escapeSmallDict;
662  f->dispose = disposeSmallDict;
663  f->reset = resetSmallDict;
664  f->smash = smashSmallDict;
665  f->finish = finishSmallDict;
666  f->help = helpSmallDict;
667  f->getso = getsoSmallDict;
668  f->setso = setsoSmallDict;
669  f->mirror = mirrorSmallDict;
670  f->set = setSmallDict;
671  f->setUndefined = setUndefinedSmallDict;
672  f->setBool = setBoolSmallDict;
673  f->setDouble = setDoubleSmallDict;
674  f->setInt = setIntSmallDict;
675  f->setS = setSSmallDict;
676  f->setChar = setCharSmallDict;
677  f->setDict = setDictSmallDict;
678  f->setArray = setArraySmallDict;
679  f->setArrayc = setArraycSmallDict;
680  f->setCArrayc = setCArraycSmallDict;
681  f->setSmallBool = setSmallBoolSmallDict;
682  f->setSmallBytes = setSmallBytesSmallDict;
683  f->setSmallDouble = setSmallDoubleSmallDict;
684  f->setSmallInt = setSmallIntSmallDict;
685  f->setSmallJson = setSmallJsonSmallDict;
686  f->setSmallString = setSmallStringSmallDict;
687  f->setSmallContainer = setSmallContainerSmallDict;
688  f->setKChar = setKCharSmallDict;
689  f->setUndefinedKChar = setUndefinedKCharSmallDict;
690  f->setBoolKChar = setBoolKCharSmallDict;
691  f->setDoubleKChar = setDoubleKCharSmallDict;
692  f->setIntKChar = setIntKCharSmallDict;
693  f->setSKChar = setSKCharSmallDict;
694  f->setCharKChar = setCharKCharSmallDict;
695  f->setDictKChar = setDictKCharSmallDict;
696  f->setArrayKChar = setArrayKCharSmallDict;
697  f->setArraycKChar = setArraycKCharSmallDict;
698  f->setCArraycKChar = setCArraycKCharSmallDict;
699  f->setSmallBoolKChar = setSmallBoolKCharSmallDict;
700  f->setSmallBytesKChar = setSmallBytesKCharSmallDict;
701  f->setSmallDoubleKChar = setSmallDoubleKCharSmallDict;
702  f->setSmallIntKChar = setSmallIntKCharSmallDict;
703  f->setSmallJsonKChar = setSmallJsonKCharSmallDict;
704  f->setSmallStringKChar = setSmallStringKCharSmallDict;
705  f->setSmallContainerKChar = setSmallContainerKCharSmallDict;
706  f->setNFree = setNFreeSmallDict;
707  f->setNFreeUndefined = setNFreeUndefinedSmallDict;
708  f->setNFreeS = setNFreeSSmallDict;
709  f->setNFreeDict = setNFreeDictSmallDict;
710  f->setNFreeArray = setNFreeArraySmallDict;
711  f->setNFreeArrayc = setNFreeArraycSmallDict;
712  f->setNFreeSmallBool = setNFreeSmallBoolSmallDict;
713  f->setNFreeSmallBytes = setNFreeSmallBytesSmallDict;
714  f->setNFreeSmallDouble = setNFreeSmallDoubleSmallDict;
715  f->setNFreeSmallInt = setNFreeSmallIntSmallDict;
716  f->setNFreeSmallJson = setNFreeSmallJsonSmallDict;
717  f->setNFreeSmallString = setNFreeSmallStringSmallDict;
718  f->setNFreeSmallContainer = setNFreeSmallContainerSmallDict;
719  f->setNFreeKChar = setNFreeKCharSmallDict;
720  f->setNFreeUndefinedKChar = setNFreeUndefinedKCharSmallDict;
721  f->setNFreeSKChar = setNFreeSKCharSmallDict;
722  f->setNFreeDictKChar = setNFreeDictKCharSmallDict;
723  f->setNFreeArrayKChar = setNFreeArrayKCharSmallDict;
724  f->setNFreeArraycKChar = setNFreeArraycKCharSmallDict;
725  f->setNFreeSmallBoolKChar = setNFreeSmallBoolKCharSmallDict;
726  f->setNFreeSmallBytesKChar = setNFreeSmallBytesKCharSmallDict;
727  f->setNFreeSmallDoubleKChar = setNFreeSmallDoubleKCharSmallDict;
728  f->setNFreeSmallIntKChar = setNFreeSmallIntKCharSmallDict;
729  f->setNFreeSmallJsonKChar = setNFreeSmallJsonKCharSmallDict;
730  f->setNFreeSmallStringKChar = setNFreeSmallStringKCharSmallDict;
731  f->setNFreeSmallContainerKChar = setNFreeSmallContainerKCharSmallDict;
732  f->setPDict = setPDictSmallDict;
733  f->setPArray = setPArraySmallDict;
734  f->setPSmallJson = setPSmallJsonSmallDict;
735  f->setPSmallString = setPSmallStringSmallDict;
736  f->setNFreePDict = setNFreePDictSmallDict;
737  f->setNFreePArray = setNFreePArraySmallDict;
738  f->setNFreePSmallJson = setNFreePSmallJsonSmallDict;
739  f->setNFreePSmallString = setNFreePSmallStringSmallDict;
740  f->setPArrayKChar = setPArrayKCharSmallDict;
741  f->setPDictKChar = setPDictKCharSmallDict;
742  f->setPSmallJsonKChar = setPSmallJsonKCharSmallDict;
743  f->setPSmallStringKChar = setPSmallStringKCharSmallDict;
744  f->setNFreePArrayKChar = setNFreePArrayKCharSmallDict;
745  f->setNFreePDictKChar = setNFreePDictKCharSmallDict;
746  f->setNFreePSmallJsonKChar = setNFreePSmallJsonKCharSmallDict;
747  f->setNFreePSmallStringKChar = setNFreePSmallStringKCharSmallDict;
748  f->get = getSmallDict;
749  f->getUndefined = getUndefinedSmallDict;
750  f->getBool = getBoolSmallDict;
751  f->getBoolP = getBoolPSmallDict;
752  f->getDouble = getDoubleSmallDict;
753  f->getDoubleP = getDoublePSmallDict;
754  f->getInt = getIntSmallDict;
755  f->getIntP = getIntPSmallDict;
756  f->getInt32 = getInt32SmallDict;
757  f->getInt32P = getInt32PSmallDict;
758  f->getUint = getUintSmallDict;
759  f->getUintP = getUintPSmallDict;
760  f->getUint32 = getUint32SmallDict;
761  f->getUint32P = getUint32PSmallDict;
762  f->getS = getSSmallDict;
763  f->getDict = getDictSmallDict;
764  f->getArray = getArraySmallDict;
765  f->getSmallBool = getSmallBoolSmallDict;
766  f->getSmallBytes = getSmallBytesSmallDict;
767  f->getSmallDouble = getSmallDoubleSmallDict;
768  f->getSmallInt = getSmallIntSmallDict;
769  f->getSmallJson = getSmallJsonSmallDict;
770  f->getSmallString = getSmallStringSmallDict;
771  f->getVoid = getVoidSmallDict;
772  f->getSmallContainer = getSmallContainerSmallDict;
773  f->getKChar = getKCharSmallDict;
774  f->getUndefinedKChar = getUndefinedKCharSmallDict;
775  f->getBoolKChar = getBoolKCharSmallDict;
776  f->getBoolPKChar = getBoolPKCharSmallDict;
777  f->getDoubleKChar = getDoubleKCharSmallDict;
778  f->getDoublePKChar = getDoublePKCharSmallDict;
779  f->getIntKChar = getIntKCharSmallDict;
780  f->getIntPKChar = getIntPKCharSmallDict;
781  f->getInt32KChar = getInt32KCharSmallDict;
782  f->getInt32PKChar = getInt32PKCharSmallDict;
783  f->getUintKChar = getUintKCharSmallDict;
784  f->getUintPKChar = getUintPKCharSmallDict;
785  f->getUint32KChar = getUint32KCharSmallDict;
786  f->getUint32PKChar = getUint32PKCharSmallDict;
787  f->getSKChar = getSKCharSmallDict;
788  f->getDictKChar = getDictKCharSmallDict;
789  f->getArrayKChar = getArrayKCharSmallDict;
790  f->getSmallBoolKChar = getSmallBoolKCharSmallDict;
791  f->getSmallBytesKChar = getSmallBytesKCharSmallDict;
792  f->getSmallDoubleKChar = getSmallDoubleKCharSmallDict;
793  f->getSmallIntKChar = getSmallIntKCharSmallDict;
794  f->getSmallJsonKChar = getSmallJsonKCharSmallDict;
795  f->getSmallStringKChar = getSmallStringKCharSmallDict;
796  f->getVoidKChar = getVoidKCharSmallDict;
797  f->getSmallContainerKChar = getSmallContainerKCharSmallDict;
798  f->getNDup = getNDupSmallDict;
799  f->getNDupUndefined = getNDupUndefinedSmallDict;
800  f->getNDupBool = getNDupBoolSmallDict;
801  f->getNDupDouble = getNDupDoubleSmallDict;
802  f->getNDupInt = getNDupIntSmallDict;
803  f->getNDupInt32 = getNDupInt32SmallDict;
804  f->getNDupUint = getNDupUintSmallDict;
805  f->getNDupUint32 = getNDupUint32SmallDict;
806  f->getNDupS = getNDupSSmallDict;
807  f->getNDupDict = getNDupDictSmallDict;
808  f->getNDupArray = getNDupArraySmallDict;
809  f->getNDupSmallBool = getNDupSmallBoolSmallDict;
810  f->getNDupSmallBytes = getNDupSmallBytesSmallDict;
811  f->getNDupSmallDouble = getNDupSmallDoubleSmallDict;
812  f->getNDupSmallInt = getNDupSmallIntSmallDict;
813  f->getNDupSmallJson = getNDupSmallJsonSmallDict;
814  f->getNDupSmallString = getNDupSmallStringSmallDict;
815  f->getNDupVoid = getNDupVoidSmallDict;
816  f->getNDupSmallContainer = getNDupSmallContainerSmallDict;
817  f->getNDupKChar = getNDupKCharSmallDict;
818  f->getNDupUndefinedKChar = getNDupUndefinedKCharSmallDict;
819  f->getNDupBoolKChar = getNDupBoolKCharSmallDict;
820  f->getNDupDoubleKChar = getNDupDoubleKCharSmallDict;
821  f->getNDupIntKChar = getNDupIntKCharSmallDict;
822  f->getNDupInt32KChar = getNDupInt32KCharSmallDict;
823  f->getNDupUintKChar = getNDupUintKCharSmallDict;
824  f->getNDupUint32KChar = getNDupUint32KCharSmallDict;
825  f->getNDupSKChar = getNDupSKCharSmallDict;
826  f->getNDupDictKChar = getNDupDictKCharSmallDict;
827  f->getNDupArrayKChar = getNDupArrayKCharSmallDict;
828  f->getNDupSmallBoolKChar = getNDupSmallBoolKCharSmallDict;
829  f->getNDupSmallBytesKChar = getNDupSmallBytesKCharSmallDict;
830  f->getNDupSmallDoubleKChar = getNDupSmallDoubleKCharSmallDict;
831  f->getNDupSmallIntKChar = getNDupSmallIntKCharSmallDict;
832  f->getNDupSmallJsonKChar = getNDupSmallJsonKCharSmallDict;
833  f->getNDupSmallStringKChar = getNDupSmallStringKCharSmallDict;
834  f->getNDupVoidKChar = getNDupVoidKCharSmallDict;
835  f->getNDupSmallContainerKChar = getNDupSmallContainerKCharSmallDict;
836  f->getNum = getNumSmallDict;
837  f->cropElem = cropElemSmallDict;
838  f->cropElemUndefined = cropElemUndefinedSmallDict;
839  f->cropElemBool = cropElemBoolSmallDict;
840  f->cropElemDouble = cropElemDoubleSmallDict;
841  f->cropElemInt = cropElemIntSmallDict;
842  f->cropElemInt32 = cropElemInt32SmallDict;
843  f->cropElemUint = cropElemUintSmallDict;
844  f->cropElemUint32 = cropElemUint32SmallDict;
845  f->cropElemS = cropElemSSmallDict;
846  f->cropElemDict = cropElemDictSmallDict;
847  f->cropElemArray = cropElemArraySmallDict;
848  f->cropElemSmallBool = cropElemSmallBoolSmallDict;
849  f->cropElemSmallBytes = cropElemSmallBytesSmallDict;
850  f->cropElemSmallDouble = cropElemSmallDoubleSmallDict;
851  f->cropElemSmallInt = cropElemSmallIntSmallDict;
852  f->cropElemSmallJson = cropElemSmallJsonSmallDict;
853  f->cropElemSmallString = cropElemSmallStringSmallDict;
854  f->cropElemVoid = cropElemVoidSmallDict;
855  f->cropElemSmallContainer = cropElemSmallContainerSmallDict;
856  f->del = delSmallDict;
857  f->delKChar = delKCharSmallDict;
858  f->remove = removeSmallDict;
859  f->removeKChar = removeKCharSmallDict;
860  f->has = hasSmallDict;
861  f->hasKChar = hasKCharSmallDict;
862  f->keyBy = keyBySmallDict;
863  f->keyByUndefined = keyByUndefinedSmallDict;
864  f->keyByBool = keyByBoolSmallDict;
865  f->keyByDouble = keyByDoubleSmallDict;
866  f->keyByInt = keyByIntSmallDict;
867  f->keyByS = keyBySSmallDict;
868  f->keyByChar = keyByCharSmallDict;
869  f->keyByDict = keyByDictSmallDict;
870  f->keyByArray = keyByArraySmallDict;
871  f->keyByArrayc = keyByArraycSmallDict;
872  f->keyByCArrayc = keyByCArraycSmallDict;
873  f->keyBySmallBool = keyBySmallBoolSmallDict;
874  f->keyBySmallBytes = keyBySmallBytesSmallDict;
875  f->keyBySmallDouble = keyBySmallDoubleSmallDict;
876  f->keyBySmallInt = keyBySmallIntSmallDict;
877  f->keyBySmallJson = keyBySmallJsonSmallDict;
878  f->keyBySmallString = keyBySmallStringSmallDict;
879  f->keyBySmallContainer = keyBySmallContainerSmallDict;
880  f->icKeyBy = icKeyBySmallDict;
881  f->icKeyByS = icKeyBySSmallDict;
882  f->icKeyByChar = icKeyByCharSmallDict;
883  f->icKeyByDict = icKeyByDictSmallDict;
884  f->icKeyByArray = icKeyByArraySmallDict;
885  f->icKeyByArrayc = icKeyByArraycSmallDict;
886  f->icKeyByCArrayc = icKeyByCArraycSmallDict;
887  f->icKeyBySmallJson = icKeyBySmallJsonSmallDict;
888  f->icKeyBySmallString = icKeyBySmallStringSmallDict;
889  f->trim = trimSmallDict;
890  f->keys = keysSmallDict;
891  f->keysSmallString = keysSmallStringSmallDict;
892  f->values = valuesSmallDict;
893  f->merge = mergeSmallDict;
894  f->mergeSmallJson = mergeSmallJsonSmallDict;
895  f->mergeNSmash = mergeNSmashSmallDict;
896  f->mergeNSmashSmallJson = mergeNSmashSmallJsonSmallDict;
897  f->append = appendSmallDict;
898  f->appendNSmash = appendNSmashSmallDict;
899  f->equalBase = equalSmallDictBase;
900  f->equalSmallJson = equalSmallDictSmallJson;
901  f->equal = equalSmallDict;
902  f->icEqualBase = icEqualSmallDictBase;
903  f->icEqualSmallJson = icEqualSmallDictSmallJson;
904  f->icEqual = icEqualSmallDict;
905  f->len = lenSmallDict;
906  f->empty = emptySmallDict;
907  f->isEmpty = isEmptySmallDict;
908  f->enumerate = enumerateSmallDictF; {
909  f->iterStart = iterStartSmallDict;
910  f->iterStartKey = iterStartKeySmallDict;
911  f->iterNext = iterNextSmallDict;
912  f->iterNextKey = iterNextKeySmallDict;
913  f->iterElement = iterElementSmallDict;
914  f->iterKey = iterKeySmallDict;
915  f->zip = zipSmallDict;
916  f->zipSmallJson = zipSmallJsonSmallDict;
917  f->zipSmallJsonSmallArray = zipSmallJsonSmallArraySmallDict;
918  f->zipSmallJsonSmallJson = zipSmallJsonSmallJsonSmallDict;
919  f->zipSmallJsonVArray = zipSmallJsonVArraySmallDict;
920  f->zipSmallJsonVCArray = zipSmallJsonVCArraySmallDict;
921  f->zipArray = zipArraySmallDict;
922  f->zipCArray = zipCArraySmallDict;
923  f->zipArraySmallJson = zipArraySmallJsonSmallDict;
924  f->zipCArraySmallJson = zipCArraySmallJsonSmallDict;
925  f->zipArrayArray = zipArrayArraySmallDict;
926  f->zipCArrayArray = zipCArrayArraySmallDict;
927  f->zipArrayCArray = zipArrayCArraySmallDict;
928  f->zipCArrayCArray = zipCArrayCArraySmallDict;
929  f->zipVArray = zipVArraySmallDict;
930  f->zipVCArray = zipVCArraySmallDict;
931  f->fromArray = fromArraySmallDict;
932  f->toArray = toArraySmallDict;
933  f->writeFile = writeFileSmallDict;
934  f->writeFileSmallJson = writeFileSmallJsonSmallDict;
935  f->writeFileSmallString = writeFileSmallStringSmallDict;
936  f->writeStream = writeStreamSmallDict;
937  f->appendFile = appendFileSmallDict;
938  f->appendFileSmallString = appendFileSmallStringSmallDict;
939  f->log = logSmallDict;
940  f->typeString = typeStringSmallDict;
941  f->typeSmallString = typeSmallStringSmallDict;
942  f->typeStringKChar = typeStringKCharSmallDict;
943  f->typeSmallStringKChar = typeSmallStringKCharSmallDict;
944  f->type = typeSmallDict;
945  f->typeKChar = typeKCharSmallDict;
946  f->typeStrings = typeStringsSmallDict;
947  f->isEType = isETypeSmallDict;
948  f->isEUndefined = isEUndefinedSmallDict;
949  f->isEBool = isEBoolSmallDict;
950  f->isEContainer = isEContainerSmallDict;
951  f->isEDict = isEDictSmallDict;
952  f->isEDouble = isEDoubleSmallDict;
953  f->isEInt = isEIntSmallDict;
954  f->isEString = isEStringSmallDict;
955  f->isEFaststring = isEFaststringSmallDict;
956  f->isEArray = isEArraySmallDict;
957  f->isEBytes = isEBytesSmallDict;
958  f->areAllEType = areAllETypeSmallDict;
959  f->areAllEUndefined = areAllEUndefinedSmallDict;
960  f->areAllEBool = areAllEBoolSmallDict;
961  f->areAllEContainer = areAllEContainerSmallDict;
962  f->areAllEDict = areAllEDictSmallDict;
963  f->areAllEDouble = areAllEDoubleSmallDict;
964  f->areAllEInt = areAllEIntSmallDict;
965  f->areAllEString = areAllEStringSmallDict;
966  f->areAllEFaststring = areAllEFaststringSmallDict;
967  f->areAllEArray = areAllEArraySmallDict;
968  f->areAllEBytes = areAllEBytesSmallDict;
969  // cg_c bug
970 }
971  }
972 
973 void initiateAllocateSmallDict(smallDictt **self) {
974 
975  if (self) {
976  #if (recycleContainers)
977  initAllocateRecycle(smallDictt);
978  #else
979  isError(*self, malloc(sizeof(smallDictt)))
980  return;
981  #endif
982  if (*self) {
983  initiateSmallDict(*self);
984  if (!(*self)->f) {
985  finishSmallDict(self);
986 }
987  }
988  }
989  }
990 
991 void finalizeRecycleSmallDict(void *arg UNUSED) {
992 
993  #if (recycleContainers)
994  finalizeRecycle
995  #endif
996  // recycleContainers
997 }
998 
999 void finalizeSmallDict(void) {
1000 
1001  if (smallDictF) {
1002  free(smallDictF);
1003  smallDictF = NULL;
1004  }
1005  finalizeRecycleSmallDict(NULL);
1006 }
1007 
1008 smallDictt* allocSmallDict(void) {
1009  smallDictt *r = NULL;
1010 
1011  initiateAllocateSmallDict(&r);
1012  if (!r) {
1013  return(NULL);
1014  }
1015  return(r);
1016 }
1017 
1018 void cleanUpSmallDictTerminateG(smallDictt **val) {
1019 
1020  terminateO(*val);
1021 }
1022 
1023 void cleanUpSmallDictFreeLocalG(smallDictt *val) {
1024 
1025  freeO(val);
1026 }
1027 
1028 void cleanUpSmallDictFreeG(smallDictt **val) {
1029 
1030  freeO(*val);
1031 }
1032 
1033 void cleanUpSmallDictFinishG(smallDictt **val) {
1034 
1035  finishO(*val);
1036 }
1037 
1038 void cleanUpSmallDictDisposeG(smallDictt *val) {
1039 
1040  disposeO(val);
1041 }
1042 
1043 void cleanUpSmallDictSmashG(smallDictt **val) {
1044 
1045  smashO(*val);
1046 }
1047 
1048 internal void freeSmallDict(smallDictt *self) {
1049 
1050  sFree((smallt *)self->d);
1051  resetSmallDict(self);
1052 }
1053 
1054 internal void terminateSmallDict(smallDictt **self) {
1055 
1056  freeSmallDict(*self);
1057  finishSmallDict(self);
1058 }
1059 
1060 internal char* toStringSmallDict(smallDictt *self) {
1061 
1062  if (!self->d) {
1063  return(strdup("{}"));
1064  }
1065  return(sToStringTiny((smallt *)self->d));
1066 }
1067 
1068 internal smallDictt* duplicateSmallDict(smallDictt *self) {
1069 
1070  createAllocateSmallDict(dup);
1071  if (!dup) {
1072  return(NULL);
1073  }
1074 
1075  if (!self->d) {
1076  // empty dictionary
1077  return(dup);
1078  }
1079 
1080  forEachSDict(self->d, o) {
1081  if (o->key) {
1082  smallt *sO = sDuplicateTiny(o->data);
1083  sDictPushTiny(&(dup->d), o->key, sO);
1084  }
1085  }
1086 
1087  dup->iterElementDataType = self->iterElementDataType;
1088  dup->iterIndex = self->iterIndex;
1089  if (dup->iterIndex != -1) {
1090  dup->iterKey = (&((dup->d)->elements) + dup->iterIndex)->key;
1091  }
1092  if (dup->iterIndex != -1) {
1093  dup->iterElement = toBaset((&((dup->d)->elements) + dup->iterIndex)->data);
1094  }
1095  return(dup);
1096 }
1097 
1098 internal char* escapeSmallDict(smallDictt *self) {
1099 
1100  if (!self->d) {
1101  return(strdup("{}"));
1102  }
1103  return(sEscapeTiny((smallt *)self->d));
1104 }
1105 
1106 internal void disposeSmallDict(smallDictt *self) {
1107 
1108  if (self->d) {
1109  forEachSDict(self->d, e) {
1110  if (e->key) {
1111  free(e->key);
1112  // free containers of baset object to avoid leaks
1113  // e->data is valid only when e->key is not null
1114  if (e->data && e->data->type == CONTAINER && (((sContainert*)e->data)->dataType == SH_DT_BASET)) {
1115  free(e->data);
1116  }
1117  }
1118  }
1119  free(self->d);
1120  resetSmallDict(self);
1121 }
1122  }
1123 
1124 internal void smashSmallDict(smallDictt **self) {
1125 
1126  (*self)->f->dispose(*self);
1127  finishSmallDict(self);
1128 }
1129 
1130 #if (NFreeStackCheck)
1131 internal void finishSmallDict(smallDictt **self) {
1132 
1133  resetSmallDict(*self);
1134 
1135  register u64 rsp asm("rsp");
1136  if ((u64)*self > rsp) {
1137  logW("Probably trying to free a smallDict on stack: "BLD PRIx64 RST" sp: "BLD PRIx64 RST, *self, rsp);
1138  logBtrace;
1139  }
1140  else {
1141  #if (recycleContainers)
1142  finishRecycle
1143  #else
1144  free(*self);
1145  #endif
1146  // recycleContainers
1147  *self = NULL;
1148 }
1149  }
1150 
1151 #else
1152 // #if NFreeStackCheck
1153 internal void finishSmallDict(smallDictt **self) {
1154 
1155  resetSmallDict(*self);
1156 
1157  #if (recycleContainers)
1158  finishRecycle
1159  #else
1160  free(*self);
1161  #endif
1162  // recycleContainers
1163  *self = NULL;
1164 }
1165 
1166 #endif
1167 // #if NFreeStackCheck
1168 
1169 internal const char* helpSmallDict(smallDictt UNUSED *self) {
1170 
1171  return(helpTextSmallDict);
1172 }
1173 
1174 internal void resetSmallDict(smallDictt *self) {
1175 
1176  if (self->iterIndex != -1) {
1177  if (self->iterElementDataType != SH_DT_BASET) {
1178  finishO(self->iterElement);
1179  }
1180  self->iterKey = NULL;
1181  self->iterElement = NULL;
1182  self->iterIndex = -1;
1183  }
1184  self->d = NULL;
1185 }
1186 
1187 internal sDictt* getsoSmallDict(smallDictt *self) {
1188 
1189  return(self->d);
1190 }
1191 
1192 internal void setsoSmallDict(smallDictt *self, sDictt *so) {
1193 
1194  resetSmallDict(self);
1195  self->d = so;
1196 }
1197 
1198 internal smallDictt* mirrorSmallDict(smallDictt *self) {
1199 
1200  createAllocateSmallDict(mirror);
1201  if (!mirror) {
1202  return(NULL);
1203  }
1204 
1205  if (!self->d) {
1206  // empty dictionary
1207  return(mirror);
1208  }
1209 
1210  mirror->d = self->d;
1211 
1212  mirror->iterElementDataType = self->iterElementDataType;
1213  mirror->iterIndex = self->iterIndex;
1214  if (mirror->iterIndex != -1) {
1215  mirror->iterKey = (&((mirror->d)->elements) + mirror->iterIndex)->key;
1216  }
1217  if (mirror->iterIndex != -1) {
1218  mirror->iterElement = toBaset((&((mirror->d)->elements) + mirror->iterIndex)->data);
1219  }
1220  return(mirror);
1221 }
1222 
1223 
1224 internal smallDictt* setSmallDict(smallDictt *self, const char *key, baset *value) {
1225 
1226  if (!key) {
1227  // can't insert NULL in sDict
1228  return(NULL);
1229  }
1230  if (!value) {
1231  return(NULL);
1232  }
1233  sDictSetTiny(&(self->d), key, toSmallt(value));
1234  return(self);
1235 }
1236 
1237 internal smallDictt* setUndefinedSmallDict(smallDictt *self, const char *key) {
1238 
1239  if (!key) {
1240  // can't insert NULL in sDict
1241  return(NULL);
1242  }
1243  smallt *o = (smallt *) allocSUndefined();
1244  if (!o) {
1245  return(NULL);
1246  }
1247  sDictSetTiny(&(self->d), key, o);
1248  return(self);
1249 }
1250 
1251 internal smallDictt* setBoolSmallDict(smallDictt *self, const char *key, bool value) {
1252 
1253  if (!key) {
1254  // can't insert NULL in sDict
1255  return(NULL);
1256  }
1257  smallt *o = (smallt *) allocSBool(value);
1258  if (!o) {
1259  return(NULL);
1260  }
1261  sDictSetTiny(&(self->d), key, o);
1262  return(self);
1263 }
1264 
1265 internal smallDictt* setDoubleSmallDict(smallDictt *self, const char *key, double value) {
1266 
1267  if (!key) {
1268  // can't insert NULL in sDict
1269  return(NULL);
1270  }
1271  smallt *o = (smallt *) allocSDouble(value);
1272  if (!o) {
1273  return(NULL);
1274  }
1275  sDictSetTiny(&(self->d), key, o);
1276  return(self);
1277 }
1278 
1279 internal smallDictt* setIntSmallDict(smallDictt *self, const char *key, int64_t value) {
1280 
1281  if (!key) {
1282  // can't insert NULL in sDict
1283  return(NULL);
1284  }
1285  smallt *o = (smallt *) allocSInt(value);
1286  if (!o) {
1287  return(NULL);
1288  }
1289  sDictSetTiny(&(self->d), key, o);
1290  return(self);
1291 }
1292 
1293 internal smallDictt* setSSmallDict(smallDictt *self, const char *key, const char *string) {
1294 
1295  if (!key || !string) {
1296  return(NULL);
1297  }
1298 
1299  smallt *o;
1300  o = (smallt *) allocSStringTiny(string);
1301  if (!o) {
1302  return(NULL);
1303  }
1304  sDictSetTiny(&(self->d), key, o);
1305  return(self);
1306 }
1307 
1308 internal smallDictt* setCharSmallDict(smallDictt *self, const char *key, char c) {
1309 
1310  charToS(s, c);
1311  return(setSSmallDict(self, key, s));
1312 }
1313 
1314 internal smallDictt* setDictSmallDict(smallDictt *self, const char *key, smallDictt *dict) {
1315 
1316  if (!key || !dict) {
1317  return(NULL);
1318  }
1319 
1320  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
1321  return(NULL);
1322  }
1323 
1324  if (!dict->d) {
1325  isError(dict->d, allocSDict()) return(NULL);
1326  }
1327 
1328  sDictSetTiny(&(self->d), key, (smallt *)dict->d);
1329  return(self);
1330 }
1331 
1332 internal smallDictt* setArraySmallDict(smallDictt *self, const char *key, smallArrayt *array) {
1333 
1334  if (!key || !array) {
1335  return(NULL);
1336  }
1337 
1338  if (checkObjectTypes && array && !isOSmallArray(array)) {
1339  return(NULL);
1340  }
1341 
1342  if (!array->a) {
1343  // allocate empty array
1344  isError(array->a, allocSArray()) return(NULL);
1345  }
1346 
1347  sDictSetTiny(&(self->d), key, (smallt *)array->a);
1348  return(self);
1349 }
1350 
1351 internal smallDictt* setArraycSmallDict(smallDictt *self, const char *key, char **array) {
1352 
1353  if (!key || !array) {
1354  return(NULL);
1355  }
1356 
1357  sArrayt *a = allocSArray();
1358  if (!a) {
1359  return(NULL);
1360  }
1361 
1362  forEachCharP(array, e) {
1363  sStringt *s = allocSStringTiny(*e);
1364  if (!s) {
1365  if (a) {
1366  sArrayFreeTiny(a);
1367  }
1368  return(NULL);
1369  }
1370  sArrayPushTiny(&a, (smallt *) s);
1371  }
1372 
1373  sDictSetTiny(&(self->d), key, (smallt *)a);
1374  return(self);
1375 }
1376 
1377 internal smallDictt* setCArraycSmallDict(smallDictt *self, const char *key, const char **array) {
1378 
1379  if (!key || !array) {
1380  return(NULL);
1381  }
1382 
1383  sArrayt *a = allocSArray();
1384  if (!a) {
1385  return(NULL);
1386  }
1387 
1388  forEachCCharP(array, e) {
1389  sStringt *s = allocSStringTiny(*e);
1390  if (!s) {
1391  if (a) {
1392  sArrayFreeTiny(a);
1393  }
1394  return(NULL);
1395  }
1396  sArrayPushTiny(&a, (smallt *) s);
1397  }
1398 
1399  sDictSetTiny(&(self->d), key, (smallt *)a);
1400  return(self);
1401 }
1402 
1403 internal smallDictt* setSmallBoolSmallDict(smallDictt *self, const char *key, smallBoolt *value) {
1404 
1405  if (!key || !value) {
1406  return(NULL);
1407  }
1408 
1409  if (checkObjectTypes && value && !isOSmallBool(value)) {
1410  return(NULL);
1411  }
1412 
1413  if (!value->value) {
1414  isError(value->value, allocSBool(false)) return(NULL);
1415  }
1416  sDictSetTiny(&(self->d), key, (smallt *) value->value);
1417  return(self);
1418 }
1419 
1420 internal smallDictt* setSmallBytesSmallDict(smallDictt *self, const char *key, smallBytest *value) {
1421 
1422  if (!key || !value) {
1423  return(NULL);
1424  }
1425 
1426  if (checkObjectTypes && value && !isOSmallBytes(value)) {
1427  return(NULL);
1428  }
1429 
1430  if (!value->B) {
1431  isError(value->B, allocSBytes()) return(NULL);
1432  }
1433  sDictSetTiny(&(self->d), key, (smallt *) value->B);
1434  return(self);
1435 }
1436 
1437 internal smallDictt* setSmallDoubleSmallDict(smallDictt *self, const char *key, smallDoublet *value) {
1438 
1439  if (!key || !value) {
1440  return(NULL);
1441  }
1442 
1443  if (checkObjectTypes && value && !isOSmallDouble(value)) {
1444  return(NULL);
1445  }
1446 
1447  if (!value->value) {
1448  isError(value->value, allocSDouble(0)) return(NULL);
1449  }
1450  sDictSetTiny(&(self->d), key, (smallt *) value->value);
1451  return(self);
1452 }
1453 
1454 internal smallDictt* setSmallIntSmallDict(smallDictt *self, const char *key, smallIntt *value) {
1455 
1456  if (!key || !value) {
1457  return(NULL);
1458  }
1459 
1460  if (checkObjectTypes && value && !isOSmallInt(value)) {
1461  return(NULL);
1462  }
1463 
1464  if (!value->value) {
1465  isError(value->value, allocSInt(0)) return(NULL);
1466  }
1467  sDictSetTiny(&(self->d), key, (smallt *) value->value);
1468  return(self);
1469 }
1470 
1471 internal smallDictt* setSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *value) {
1472 
1473  if (!key || !value) {
1474  return(NULL);
1475  }
1476 
1477  if (checkObjectTypes && value && !isOSmallJson(value)) {
1478  return(NULL);
1479  }
1480 
1481  smallt *o = getsoO(value);
1482  if (!o) {
1483  // smallJson is empty, create an empty dict
1484  isError(o, (smallt*)allocSDict()) return(NULL);
1485  setsoO(value, o);
1486  }
1487 
1488  sDictSetTiny(&(self->d), key, o);
1489  return(self);
1490 }
1491 
1492 internal smallDictt* setSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string) {
1493 
1494  if (!key || !string) {
1495  return(NULL);
1496  }
1497 
1498  if (checkObjectTypes && string && !isOSmallString(string)) {
1499  return(NULL);
1500  }
1501 
1502  if (!string->data) {
1503  // set empty string when NULL
1504  isError(string->data, allocSStringTiny("")) return(NULL);
1505  }
1506  sDictSetTiny(&(self->d), key, (smallt *) string->data);
1507  return(self);
1508 }
1509 
1510 internal smallDictt* setSmallContainerSmallDict(smallDictt *self, const char *key, smallContainert *container) {
1511 
1512  if (!key || !container) {
1513  return(NULL);
1514  }
1515 
1516  if (checkObjectTypes && container && !isOSmallContainer(container)) {
1517  return(NULL);
1518  }
1519 
1520  if (!container->data) {
1521  isError(container->data, allocSContainer(NULL)) return(NULL);
1522  }
1523  sDictSetTiny(&(self->d), key, (smallt *) container->data);
1524  return(self);
1525 }
1526 
1527 internal smallDictt* setKCharSmallDict(smallDictt *self, char key, baset *value) {
1528 
1529  charToS(s, key);
1530  return(setSmallDict(self, s, value));
1531 }
1532 
1533 internal smallDictt* setUndefinedKCharSmallDict(smallDictt *self, char key) {
1534 
1535  charToS(s, key);
1536  return(setUndefinedSmallDict(self, s));
1537 }
1538 
1539 internal smallDictt* setBoolKCharSmallDict(smallDictt *self, char key, bool value) {
1540 
1541  charToS(s, key);
1542  return(setBoolSmallDict(self, s, value));
1543 }
1544 
1545 internal smallDictt* setDoubleKCharSmallDict(smallDictt *self, char key, double value) {
1546 
1547  charToS(s, key);
1548  return(setDoubleSmallDict(self, s, value));
1549 }
1550 
1551 internal smallDictt* setIntKCharSmallDict(smallDictt *self, char key, int64_t value) {
1552 
1553  charToS(s, key);
1554  return(setIntSmallDict(self, s, value));
1555 }
1556 
1557 internal smallDictt* setSKCharSmallDict(smallDictt *self, char key, const char *string) {
1558 
1559  charToS(s, key);
1560  return(setSSmallDict(self, s, string));
1561 }
1562 
1563 internal smallDictt* setCharKCharSmallDict(smallDictt *self, char key, char c) {
1564 
1565  charToS(s, key);
1566  return(setCharSmallDict(self, s, c));
1567 }
1568 
1569 internal smallDictt* setDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict) {
1570 
1571  charToS(s, key);
1572  return(setDictSmallDict(self, s, dict));
1573 }
1574 
1575 internal smallDictt* setArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array) {
1576 
1577  charToS(s, key);
1578  return(setArraySmallDict(self, s, array));
1579 }
1580 
1581 internal smallDictt* setArraycKCharSmallDict(smallDictt *self, char key, char **array) {
1582 
1583  charToS(s, key);
1584  return(setArraycSmallDict(self, s, array));
1585 }
1586 
1587 internal smallDictt* setCArraycKCharSmallDict(smallDictt *self, char key, const char **array) {
1588 
1589  charToS(s, key);
1590  return(setCArraycSmallDict(self, s, array));
1591 }
1592 
1593 internal smallDictt* setSmallBoolKCharSmallDict(smallDictt *self, char key, smallBoolt *value) {
1594 
1595  charToS(s, key);
1596  return(setSmallBoolSmallDict(self, s, value));
1597 }
1598 
1599 internal smallDictt* setSmallBytesKCharSmallDict(smallDictt *self, char key, smallBytest *value) {
1600 
1601  charToS(s, key);
1602  return(setSmallBytesSmallDict(self, s, value));
1603 }
1604 
1605 internal smallDictt* setSmallDoubleKCharSmallDict(smallDictt *self, char key, smallDoublet *value) {
1606 
1607  charToS(s, key);
1608  return(setSmallDoubleSmallDict(self, s, value));
1609 }
1610 
1611 internal smallDictt* setSmallIntKCharSmallDict(smallDictt *self, char key, smallIntt *value) {
1612 
1613  charToS(s, key);
1614  return(setSmallIntSmallDict(self, s, value));
1615 }
1616 
1617 internal smallDictt* setSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *value) {
1618 
1619  charToS(s, key);
1620  return(setSmallJsonSmallDict(self, s, value));
1621 }
1622 
1623 internal smallDictt* setSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string) {
1624 
1625  charToS(s, key);
1626  return(setSmallStringSmallDict(self, s, string));
1627 }
1628 
1629 internal smallDictt* setSmallContainerKCharSmallDict(smallDictt *self, char key, smallContainert *container) {
1630 
1631  charToS(s, key);
1632  return(setSmallContainerSmallDict(self, s, container));
1633 }
1634 
1635 
1636 internal smallDictt* setNFreeSmallDict(smallDictt *self, const char *key, baset *value) {
1637 
1638  if (!key) {
1639  // can't insert NULL in sDict
1640  return(NULL);
1641  }
1642  if (!value) {
1643  return(NULL);
1644  }
1645 
1646  smallt *o = toSmallt(value);
1647  if (!o) {
1648  return(NULL);
1649  }
1650  sDictSetTiny(&(self->d), key, o);
1651 
1652  if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) {
1653  finishO(value);
1654  }
1655  return(self);
1656 }
1657 
1658 internal smallDictt* setNFreeUndefinedSmallDict(smallDictt *self, const char *key, undefinedt *u) {
1659 
1660  if (!u) {
1661  return(NULL);
1662  }
1663  smallDictt *r = setUndefinedSmallDict(self, key);
1664  if (r) {
1665  terminateO(u);
1666  }
1667  return(r);
1668 }
1669 
1670 internal smallDictt* setNFreeSSmallDict(smallDictt *self, const char *key, char *string) {
1671 
1672  smallDictt *r = setSSmallDict(self, key, string);
1673  if (r) {
1674  free(string);
1675  }
1676  return(r);
1677 }
1678 
1679 internal smallDictt* setNFreeDictSmallDict(smallDictt *self, const char *key, smallDictt *dict) {
1680 
1681  smallDictt *r = setDictSmallDict(self, key, dict);
1682  if (r) {
1683  finishO(dict);
1684  }
1685  return(r);
1686 }
1687 
1688 internal smallDictt* setNFreeArraySmallDict(smallDictt *self, const char *key, smallArrayt *array) {
1689 
1690  smallDictt *r = setArraySmallDict(self, key, array);
1691  if (r) {
1692  finishO(array);
1693  }
1694  return(r);
1695 }
1696 
1697 internal smallDictt* setNFreeArraycSmallDict(smallDictt *self, const char *key, char **array) {
1698 
1699  smallDictt *r = setArraycSmallDict(self, key, array);
1700  if (r) {
1701  listFreeS(array);
1702  }
1703  return(r);
1704 }
1705 
1706 internal smallDictt* setNFreeSmallBoolSmallDict(smallDictt *self, const char *key, smallBoolt *value) {
1707 
1708  smallDictt *r = setSmallBoolSmallDict(self, key, value);
1709  if (r) {
1710  finishO(value);
1711  }
1712  return(r);
1713 }
1714 
1715 internal smallDictt* setNFreeSmallBytesSmallDict(smallDictt *self, const char *key, smallBytest *value) {
1716 
1717  smallDictt *r = setSmallBytesSmallDict(self, key, value);
1718  if (r) {
1719  finishO(value);
1720  }
1721  return(r);
1722 }
1723 
1724 internal smallDictt* setNFreeSmallDoubleSmallDict(smallDictt *self, const char *key, smallDoublet *value) {
1725 
1726  smallDictt *r = setSmallDoubleSmallDict(self, key, value);
1727  if (r) {
1728  finishO(value);
1729  }
1730  return(r);
1731 }
1732 
1733 internal smallDictt* setNFreeSmallIntSmallDict(smallDictt *self, const char *key, smallIntt *value) {
1734 
1735  smallDictt *r = setSmallIntSmallDict(self, key, value);
1736  if (r) {
1737  finishO(value);
1738  }
1739  return(r);
1740 }
1741 
1742 internal smallDictt* setNFreeSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *value) {
1743 
1744  smallDictt *r = setSmallJsonSmallDict(self, key, value);
1745  if (r) {
1746  finishO(value);
1747  }
1748  return(r);
1749 }
1750 
1751 internal smallDictt* setNFreeSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string) {
1752 
1753  smallDictt *r = setSmallStringSmallDict(self, key, string);
1754  if (r) {
1755  finishO(string);
1756  }
1757  return(r);
1758 }
1759 
1760 internal smallDictt* setNFreeSmallContainerSmallDict(smallDictt *self, const char *key, smallContainert *container) {
1761 
1762  smallDictt *r = setSmallContainerSmallDict(self, key, container);
1763  if (r) {
1764  finishO(container);
1765  }
1766  return(r);
1767 }
1768 
1769 internal smallDictt* setNFreeKCharSmallDict(smallDictt *self, char key, baset *value) {
1770 
1771  charToS(s, key);
1772  return(setNFreeSmallDict(self, s, value));
1773 }
1774 
1775 internal smallDictt* setNFreeUndefinedKCharSmallDict(smallDictt *self, char key, undefinedt *u) {
1776 
1777  charToS(s, key);
1778  return(setNFreeUndefinedSmallDict(self, s, u));
1779 }
1780 
1781 internal smallDictt* setNFreeSKCharSmallDict(smallDictt *self, char key, char *string) {
1782 
1783  charToS(s, key);
1784  return(setNFreeSSmallDict(self, s, string));
1785 }
1786 
1787 internal smallDictt* setNFreeDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict) {
1788 
1789  charToS(s, key);
1790  return(setNFreeDictSmallDict(self, s, dict));
1791 }
1792 
1793 internal smallDictt* setNFreeArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array) {
1794 
1795  charToS(s, key);
1796  return(setNFreeArraySmallDict(self, s, array));
1797 }
1798 
1799 internal smallDictt* setNFreeArraycKCharSmallDict(smallDictt *self, char key, char **array) {
1800 
1801  charToS(s, key);
1802  return(setNFreeArraycSmallDict(self, s, array));
1803 }
1804 
1805 internal smallDictt* setNFreeSmallBoolKCharSmallDict(smallDictt *self, char key, smallBoolt *value) {
1806 
1807  charToS(s, key);
1808  return(setNFreeSmallBoolSmallDict(self, s, value));
1809 }
1810 
1811 internal smallDictt* setNFreeSmallBytesKCharSmallDict(smallDictt *self, char key, smallBytest *value) {
1812 
1813  charToS(s, key);
1814  return(setNFreeSmallBytesSmallDict(self, s, value));
1815 }
1816 
1817 internal smallDictt* setNFreeSmallDoubleKCharSmallDict(smallDictt *self, char key, smallDoublet *value) {
1818 
1819  charToS(s, key);
1820  return(setNFreeSmallDoubleSmallDict(self, s, value));
1821 }
1822 
1823 internal smallDictt* setNFreeSmallIntKCharSmallDict(smallDictt *self, char key, smallIntt *value) {
1824 
1825  charToS(s, key);
1826  return(setNFreeSmallIntSmallDict(self, s, value));
1827 }
1828 
1829 internal smallDictt* setNFreeSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *value) {
1830 
1831  charToS(s, key);
1832  return(setNFreeSmallJsonSmallDict(self, s, value));
1833 }
1834 
1835 internal smallDictt* setNFreeSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string) {
1836 
1837  charToS(s, key);
1838  return(setNFreeSmallStringSmallDict(self, s, string));
1839 }
1840 
1841 internal smallDictt* setNFreeSmallContainerKCharSmallDict(smallDictt *self, char key, smallContainert *container) {
1842 
1843  charToS(s, key);
1844  return(setNFreeSmallContainerSmallDict(self, s, container));
1845 }
1846 
1847 
1848 internal smallDictt* setPDictSmallDict(smallDictt *self, const char *key, smallDictt *dict) {
1849 
1850  if (!key || !dict) {
1851  return(NULL);
1852  }
1853 
1854  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
1855  return(NULL);
1856  }
1857 
1858  if (!dict->d) {
1859  return(NULL);
1860  }
1861 
1862  sDictSetP(&(self->d), key, (smallt *)dict->d);
1863  return(self);
1864 }
1865 
1866 internal smallDictt* setPArraySmallDict(smallDictt *self, const char *key, smallArrayt *array) {
1867 
1868  if (!key || !array) {
1869  return(NULL);
1870  }
1871 
1872  if (checkObjectTypes && !isOSmallArray(array)) {
1873  return(NULL);
1874  }
1875 
1876  if (!array->a) {
1877  return(NULL);
1878  }
1879 
1880  sDictSetP(&(self->d), key, (smallt *)array->a);
1881  return(self);
1882 }
1883 
1884 internal smallDictt* setPSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *json) {
1885 
1886  if (!key || !json) {
1887  return(NULL);
1888  }
1889 
1890  if (checkObjectTypes && json && !isOSmallJson(json)) {
1891  return(NULL);
1892  }
1893 
1894  smallt *o;
1895  o = getsoO(json);
1896  if (!o) {
1897  return(NULL);
1898  }
1899  sDictSetP(&(self->d), key, (smallt *)o);
1900  return(self);
1901 }
1902 
1903 internal smallDictt* setPSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string) {
1904 
1905  if (!key || !string) {
1906  return(NULL);
1907  }
1908 
1909  if (checkObjectTypes && string && !isOSmallString(string)) {
1910  return(NULL);
1911  }
1912 
1913  if (!string->data) {
1914  return(NULL);
1915  }
1916  sDictSetP(&(self->d), key, (smallt *)string->data);
1917  return(self);
1918 }
1919 
1920 internal smallDictt* setNFreePDictSmallDict(smallDictt *self, const char *key, smallDictt *dict) {
1921 
1922  if (!key || !dict) {
1923  return(NULL);
1924  }
1925 
1926  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
1927  return(NULL);
1928  }
1929 
1930  if (!dict->d) {
1931  return(NULL);
1932  }
1933 
1934  sDictSetP(&(self->d), key, (smallt *)dict->d);
1935  finishO(dict);
1936  return(self);
1937 }
1938 
1939 internal smallDictt* setNFreePArraySmallDict(smallDictt *self, const char *key, smallArrayt *array) {
1940 
1941  if (!key || !array) {
1942  return(NULL);
1943  }
1944 
1945  if (checkObjectTypes && array && !isOSmallArray(array)) {
1946  return(NULL);
1947  }
1948 
1949  if (!array->a) {
1950  return(NULL);
1951  }
1952 
1953  sDictSetP(&(self->d), key, (smallt *)array->a);
1954  finishO(array);
1955  return(self);
1956 }
1957 
1958 internal smallDictt* setNFreePSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *json) {
1959 
1960  if (!key || !json) {
1961  return(NULL);
1962  }
1963 
1964  if (checkObjectTypes && json && !isOSmallJson(json)) {
1965  return(NULL);
1966  }
1967 
1968  smallt *o = getsoO(json);
1969  if (!o) {
1970  return(NULL);
1971  }
1972 
1973  sDictSetP(&(self->d), key, o);
1974  finishO(json);
1975  return(self);
1976 }
1977 
1978 internal smallDictt* setNFreePSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string) {
1979 
1980  if (!key || !string) {
1981  return(NULL);
1982  }
1983 
1984  if (checkObjectTypes && string && !isOSmallString(string)) {
1985  return(NULL);
1986  }
1987 
1988  if (!string->data) {
1989  return(NULL);
1990  }
1991 
1992  sDictSetP(&(self->d), key, (smallt *)string->data);
1993  finishO(string);
1994  return(self);
1995 }
1996 
1997 internal smallDictt* setPArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array) {
1998 
1999  charToS(s, key);
2000  return(setPArraySmallDict(self, s, array));
2001 }
2002 
2003 internal smallDictt* setPDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict) {
2004 
2005  charToS(s, key);
2006  return(setPDictSmallDict(self, s, dict));
2007 }
2008 
2009 internal smallDictt* setPSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *json) {
2010 
2011  charToS(s, key);
2012  return(setPSmallJsonSmallDict(self, s, json));
2013 }
2014 
2015 internal smallDictt* setPSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string) {
2016 
2017  charToS(s, key);
2018  return(setPSmallStringSmallDict(self, s, string));
2019 }
2020 
2021 internal smallDictt* setNFreePArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array) {
2022 
2023  charToS(s, key);
2024  return(setNFreePArraySmallDict(self, s, array));
2025 }
2026 
2027 internal smallDictt* setNFreePDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict) {
2028 
2029  charToS(s, key);
2030  return(setNFreePDictSmallDict(self, s, dict));
2031 }
2032 
2033 internal smallDictt* setNFreePSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *json) {
2034 
2035  charToS(s, key);
2036  return(setNFreePSmallJsonSmallDict(self, s, json));
2037 }
2038 
2039 internal smallDictt* setNFreePSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string) {
2040 
2041  charToS(s, key);
2042  return(setNFreePSmallStringSmallDict(self, s, string));
2043 }
2044 
2045 
2046 internal baset* getSmallDict(smallDictt *self, const char *key) {
2047 
2048  if (!key || !self->d) {
2049  return(NULL);
2050  }
2051 
2052  return(toBaset(sDictGetTiny(self->d, key)));
2053 }
2054 
2055 internal undefinedt* getUndefinedSmallDict(smallDictt *self, const char *key) {
2056 
2057  if (!key || !self->d) {
2058  return(NULL);
2059  }
2060 
2061  smallt *o = sDictGetTiny(self->d, key);
2062 
2063  if (!o) {
2064  return(NULL);
2065  }
2066 
2067  if (o->type != UNDEFINED) {
2068  return(NULL);
2069  }
2070  return(allocUndefined());
2071 }
2072 
2073 internal bool getBoolSmallDict(smallDictt *self, const char *key) {
2074  smallBoolt *e = NULL;
2075  bool r = false;;
2076 
2077  e = getSmallBoolSmallDict(self, key);
2078  if (e) {
2079  r = e->f->get(e);
2080  finishO(e);
2081  }
2082  return(r);
2083 }
2084 
2085 internal bool* getBoolPSmallDict(smallDictt *self, const char *key) {
2086  smallBoolt *e = NULL;
2087  bool* r = NULL;
2088 
2089  e = getSmallBoolSmallDict(self, key);
2090  if (e) {
2091  r = e->f->getP(e);
2092  finishO(e);
2093  }
2094  return(r);
2095 }
2096 
2097 internal double getDoubleSmallDict(smallDictt *self, const char *key) {
2098  smallDoublet *e = NULL;
2099  double r = 0;;
2100 
2101  e = getSmallDoubleSmallDict(self, key);
2102  if (e) {
2103  r = e->f->get(e);
2104  finishO(e);
2105  }
2106  return(r);
2107 }
2108 
2109 internal double* getDoublePSmallDict(smallDictt *self, const char *key) {
2110  smallDoublet *e = NULL;
2111  double* r = NULL;
2112 
2113  e = getSmallDoubleSmallDict(self, key);
2114  if (e) {
2115  r = e->f->getP(e);
2116  finishO(e);
2117  }
2118  return(r);
2119 }
2120 
2121 internal int64_t getIntSmallDict(smallDictt *self, const char *key) {
2122  smallIntt *e = NULL;
2123  int64_t r = 0;;
2124 
2125  e = getSmallIntSmallDict(self, key);
2126  if (e) {
2127  r = e->f->get(e);
2128  finishO(e);
2129  }
2130  return(r);
2131 }
2132 
2133 internal int64_t* getIntPSmallDict(smallDictt *self, const char *key) {
2134  smallIntt *e = NULL;
2135  int64_t* r = NULL;
2136 
2137  e = getSmallIntSmallDict(self, key);
2138  if (e) {
2139  r = e->f->getP(e);
2140  finishO(e);
2141  }
2142  return(r);
2143 }
2144 
2145 internal int32_t getInt32SmallDict(smallDictt *self, const char *key) {
2146  smallIntt *e = NULL;
2147  int32_t r = 0;;
2148 
2149  e = getSmallIntSmallDict(self, key);
2150  if (e) {
2151  r = (int32_t)e->f->get(e);
2152  finishO(e);
2153  }
2154  return(r);
2155 }
2156 
2157 internal int32_t* getInt32PSmallDict(smallDictt *self, const char *key) {
2158  smallIntt *e = NULL;
2159  int32_t* r = NULL;
2160 
2161  e = getSmallIntSmallDict(self, key);
2162  if (e) {
2163  r = (int32_t *)e->f->getP(e);
2164  finishO(e);
2165  }
2166  return(r);
2167 }
2168 
2169 internal uint64_t getUintSmallDict(smallDictt *self, const char *key) {
2170  smallIntt *e = NULL;
2171  uint64_t r = 0;;
2172 
2173  e = getSmallIntSmallDict(self, key);
2174  if (e) {
2175  r = (uint64_t)e->f->get(e);
2176  finishO(e);
2177  }
2178  return(r);
2179 }
2180 
2181 internal uint64_t* getUintPSmallDict(smallDictt *self, const char *key) {
2182  smallIntt *e = NULL;
2183  uint64_t* r = NULL;
2184 
2185  e = getSmallIntSmallDict(self, key);
2186  if (e) {
2187  r = (uint64_t *)e->f->getP(e);
2188  finishO(e);
2189  }
2190  return(r);
2191 }
2192 
2193 internal uint32_t getUint32SmallDict(smallDictt *self, const char *key) {
2194  smallIntt *e = NULL;
2195  uint32_t r = 0;;
2196 
2197  e = getSmallIntSmallDict(self, key);
2198  if (e) {
2199  r = (uint32_t)e->f->get(e);
2200  finishO(e);
2201  }
2202  return(r);
2203 }
2204 
2205 internal uint32_t* getUint32PSmallDict(smallDictt *self, const char *key) {
2206  smallIntt *e = NULL;
2207  uint32_t* r = NULL;
2208 
2209  e = getSmallIntSmallDict(self, key);
2210  if (e) {
2211  r = (uint32_t *)e->f->getP(e);
2212  finishO(e);
2213  }
2214  return(r);
2215 }
2216 
2217 internal char* getSSmallDict(smallDictt *self, const char *key) {
2218  smallStringt *e = NULL;
2219  char* r = NULL;
2220 
2221  e = getSmallStringSmallDict(self, key);
2222  if (e) {
2223  r = e->f->get(e);
2224  finishO(e);
2225  }
2226  return(r);
2227 }
2228 
2229 internal smallDictt* getDictSmallDict(smallDictt *self, const char *key) {
2230 
2231  if (!key || !self->d) {
2232  return(NULL);
2233  }
2234 
2235  smallt *o = sDictGetTiny(self->d, key);
2236 
2237  if (!o) {
2238  return(NULL);
2239  }
2240 
2241  if (o->type != DICT) {
2242  return(NULL);
2243  }
2244  return((smallDictt*) toBaset(o));
2245 }
2246 
2247 internal smallArrayt* getArraySmallDict(smallDictt *self, const char *key) {
2248 
2249  if (!key || !self->d) {
2250  return(NULL);
2251  }
2252 
2253  smallt *o = sDictGetTiny(self->d, key);
2254 
2255  if (!o) {
2256  return(NULL);
2257  }
2258 
2259  if (o->type != ARRAY) {
2260  return(NULL);
2261  }
2262  return((smallArrayt*) toBaset(o));
2263 }
2264 
2265 internal smallBoolt* getSmallBoolSmallDict(smallDictt *self, const char *key) {
2266 
2267  if (!key || !self->d) {
2268  return(NULL);
2269  }
2270 
2271  smallt *o = sDictGetTiny(self->d, key);
2272 
2273  if (!o) {
2274  return(NULL);
2275  }
2276 
2277  if (o->type != BOOL) {
2278  return(NULL);
2279  }
2280  return((smallBoolt*) toBaset(o));
2281 }
2282 
2283 internal smallBytest* getSmallBytesSmallDict(smallDictt *self, const char *key) {
2284 
2285  if (!key || !self->d) {
2286  return(NULL);
2287  }
2288 
2289  smallt *o = sDictGetTiny(self->d, key);
2290 
2291  if (!o) {
2292  return(NULL);
2293  }
2294 
2295  if (o->type != BYTES) {
2296  return(NULL);
2297  }
2298  return((smallBytest*) toBaset(o));
2299 }
2300 
2301 internal smallDoublet* getSmallDoubleSmallDict(smallDictt *self, const char *key) {
2302 
2303  if (!key || !self->d) {
2304  return(NULL);
2305  }
2306 
2307  smallt *o = sDictGetTiny(self->d, key);
2308 
2309  if (!o) {
2310  return(NULL);
2311  }
2312 
2313  if (o->type != DOUBLE) {
2314  return(NULL);
2315  }
2316  return((smallDoublet*) toBaset(o));
2317 }
2318 
2319 internal smallIntt* getSmallIntSmallDict(smallDictt *self, const char *key) {
2320 
2321  if (!key || !self->d) {
2322  return(NULL);
2323  }
2324 
2325  smallt *o = sDictGetTiny(self->d, key);
2326 
2327  if (!o) {
2328  return(NULL);
2329  }
2330 
2331  if (o->type != INT) {
2332  return(NULL);
2333  }
2334  return((smallIntt*) toBaset(o));
2335 }
2336 
2337 internal smallJsont* getSmallJsonSmallDict(smallDictt *self, const char *key) {
2338 
2339  if (!key || !self->d) {
2340  return(NULL);
2341  }
2342 
2343  smallt *o = sDictGetTiny(self->d, key);
2344 
2345  if (!o) {
2346  return(NULL);
2347  }
2348 
2349  if ((o->type == BYTES) || (o->type == CONTAINER)) {
2350  return(NULL);
2351  }
2352 
2353  baset *e = toBaset(o);
2354  createAllocateSmallJson(r);
2355  if (!r) {
2356  finishO(e);
2357  return(NULL);
2358  }
2359  setTopNFreeO(r, e);
2360  return(r);
2361 }
2362 
2363 internal smallStringt* getSmallStringSmallDict(smallDictt *self, const char *key) {
2364 
2365  if (!key || !self->d) {
2366  return(NULL);
2367  }
2368 
2369  smallt *o = sDictGetTiny(self->d, key);
2370 
2371  if (!o) {
2372  return(NULL);
2373  }
2374 
2375  if (o->type != STRING) {
2376  return(NULL);
2377  }
2378  return((smallStringt*) toBaset(o));
2379 }
2380 
2381 internal void* getVoidSmallDict(smallDictt *self, const char *key) {
2382  smallContainert *e = NULL;
2383  void* r = NULL;
2384 
2385  e = getSmallContainerSmallDict(self, key);
2386  if (e) {
2387  r = e->f->get(e);
2388  finishO(e);
2389  }
2390  return(r);
2391 }
2392 
2393 internal smallContainert* getSmallContainerSmallDict(smallDictt *self, const char *key) {
2394 
2395  if (!key || !self->d) {
2396  return(NULL);
2397  }
2398 
2399  smallt *o = sDictGetTiny(self->d, key);
2400 
2401  if (!o) {
2402  return(NULL);
2403  }
2404 
2405  if (o->type != CONTAINER) {
2406  return(NULL);
2407  }
2408 
2409  if (((sContainert*)o)->dataType == SH_DT_BASET) {
2410  return(NULL);
2411  }
2412 
2413  return((smallContainert*) toBaset(o));
2414 }
2415 
2416 internal baset* getKCharSmallDict(smallDictt *self, char key) {
2417 
2418  charToS(s, key);
2419  return(getSmallDict(self, s));
2420 }
2421 
2422 internal undefinedt* getUndefinedKCharSmallDict(smallDictt *self, char key) {
2423 
2424  charToS(s, key);
2425  return(getUndefinedSmallDict(self, s));
2426 }
2427 
2428 internal bool getBoolKCharSmallDict(smallDictt *self, char key) {
2429 
2430  charToS(s, key);
2431  return(getBoolSmallDict(self, s));
2432 }
2433 
2434 internal bool* getBoolPKCharSmallDict(smallDictt *self, char key) {
2435 
2436  charToS(s, key);
2437  return(getBoolPSmallDict(self, s));
2438 }
2439 
2440 internal double getDoubleKCharSmallDict(smallDictt *self, char key) {
2441 
2442  charToS(s, key);
2443  return(getDoubleSmallDict(self, s));
2444 }
2445 
2446 internal double* getDoublePKCharSmallDict(smallDictt *self, char key) {
2447 
2448  charToS(s, key);
2449  return(getDoublePSmallDict(self, s));
2450 }
2451 
2452 internal int64_t getIntKCharSmallDict(smallDictt *self, char key) {
2453 
2454  charToS(s, key);
2455  return(getIntSmallDict(self, s));
2456 }
2457 
2458 internal int64_t* getIntPKCharSmallDict(smallDictt *self, char key) {
2459 
2460  charToS(s, key);
2461  return(getIntPSmallDict(self, s));
2462 }
2463 
2464 internal int32_t getInt32KCharSmallDict(smallDictt *self, char key) {
2465 
2466  charToS(s, key);
2467  return(getInt32SmallDict(self, s));
2468 }
2469 
2470 internal int32_t* getInt32PKCharSmallDict(smallDictt *self, char key) {
2471 
2472  charToS(s, key);
2473  return(getInt32PSmallDict(self, s));
2474 }
2475 
2476 internal uint64_t getUintKCharSmallDict(smallDictt *self, char key) {
2477 
2478  charToS(s, key);
2479  return(getUintSmallDict(self, s));
2480 }
2481 
2482 internal uint64_t* getUintPKCharSmallDict(smallDictt *self, char key) {
2483 
2484  charToS(s, key);
2485  return(getUintPSmallDict(self, s));
2486 }
2487 
2488 internal uint32_t getUint32KCharSmallDict(smallDictt *self, char key) {
2489 
2490  charToS(s, key);
2491  return(getUint32SmallDict(self, s));
2492 }
2493 
2494 internal uint32_t* getUint32PKCharSmallDict(smallDictt *self, char key) {
2495 
2496  charToS(s, key);
2497  return(getUint32PSmallDict(self, s));
2498 }
2499 
2500 internal char* getSKCharSmallDict(smallDictt *self, char key) {
2501 
2502  charToS(s, key);
2503  return(getSSmallDict(self, s));
2504 }
2505 
2506 internal smallDictt* getDictKCharSmallDict(smallDictt *self, char key) {
2507 
2508  charToS(s, key);
2509  return(getDictSmallDict(self, s));
2510 }
2511 
2512 internal smallArrayt* getArrayKCharSmallDict(smallDictt *self, char key) {
2513 
2514  charToS(s, key);
2515  return(getArraySmallDict(self, s));
2516 }
2517 
2518 internal smallBoolt* getSmallBoolKCharSmallDict(smallDictt *self, char key) {
2519 
2520  charToS(s, key);
2521  return(getSmallBoolSmallDict(self, s));
2522 }
2523 
2524 internal smallBytest* getSmallBytesKCharSmallDict(smallDictt *self, char key) {
2525 
2526  charToS(s, key);
2527  return(getSmallBytesSmallDict(self, s));
2528 }
2529 
2530 internal smallDoublet* getSmallDoubleKCharSmallDict(smallDictt *self, char key) {
2531 
2532  charToS(s, key);
2533  return(getSmallDoubleSmallDict(self, s));
2534 }
2535 
2536 internal smallIntt* getSmallIntKCharSmallDict(smallDictt *self, char key) {
2537 
2538  charToS(s, key);
2539  return(getSmallIntSmallDict(self, s));
2540 }
2541 
2542 internal smallJsont* getSmallJsonKCharSmallDict(smallDictt *self, char key) {
2543 
2544  charToS(s, key);
2545  return(getSmallJsonSmallDict(self, s));
2546 }
2547 
2548 internal smallStringt* getSmallStringKCharSmallDict(smallDictt *self, char key) {
2549 
2550  charToS(s, key);
2551  return(getSmallStringSmallDict(self, s));
2552 }
2553 
2554 internal void* getVoidKCharSmallDict(smallDictt *self, char key) {
2555 
2556  charToS(s, key);
2557  return(getVoidSmallDict(self, s));
2558 }
2559 
2560 internal smallContainert* getSmallContainerKCharSmallDict(smallDictt *self, char key) {
2561 
2562  charToS(s, key);
2563  return(getSmallContainerSmallDict(self, s));
2564 }
2565 
2566 internal baset* getNDupSmallDict(smallDictt *self, const char *key) {
2567 
2568  if (!key || !self->d) {
2569  return(NULL);
2570  }
2571 
2572  smallt *o = sDictGetTiny(self->d, key);
2573 
2574  if (!o) {
2575  return(NULL);
2576  }
2577 
2578  if (o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET)) {
2579  baset *b = ((sContainert*)o)->data;
2580  return(duplicateO(b));
2581  }
2582  return(toBaset(sDuplicate(o)));
2583 }
2584 
2585 internal undefinedt* getNDupUndefinedSmallDict(smallDictt *self, const char *key) {
2586 
2587  if (!key || !self->d) {
2588  return(NULL);
2589  }
2590 
2591  smallt *o = sDictGetTiny(self->d, key);
2592 
2593  if (!o) {
2594  return(NULL);
2595  }
2596 
2597  if (o->type != UNDEFINED) {
2598  return(NULL);
2599  }
2600  return(allocUndefined());
2601 }
2602 
2603 internal bool getNDupBoolSmallDict(smallDictt *self, const char *key) {
2604  smallBoolt *e = NULL;
2605  bool r = false;;
2606 
2607  e = getSmallBoolSmallDict(self, key);
2608  if (e) {
2609  r = e->f->get(e);
2610  finishO(e);
2611  }
2612  return(r);
2613 }
2614 
2615 internal double getNDupDoubleSmallDict(smallDictt *self, const char *key) {
2616  smallDoublet *e = NULL;
2617  double r = 0;;
2618 
2619  e = getSmallDoubleSmallDict(self, key);
2620  if (e) {
2621  r = e->f->get(e);
2622  finishO(e);
2623  }
2624  return(r);
2625 }
2626 
2627 internal int64_t getNDupIntSmallDict(smallDictt *self, const char *key) {
2628  smallIntt *e = NULL;
2629  int64_t r = 0;;
2630 
2631  e = getSmallIntSmallDict(self, key);
2632  if (e) {
2633  r = e->f->get(e);
2634  finishO(e);
2635  }
2636  return(r);
2637 }
2638 
2639 internal int32_t getNDupInt32SmallDict(smallDictt *self, const char *key) {
2640  smallIntt *e = NULL;
2641  int32_t r = 0;;
2642 
2643  e = getSmallIntSmallDict(self, key);
2644  if (e) {
2645  r = (int32_t)e->f->get(e);
2646  finishO(e);
2647  }
2648  return(r);
2649 }
2650 
2651 internal uint64_t getNDupUintSmallDict(smallDictt *self, const char *key) {
2652  smallIntt *e = NULL;
2653  uint64_t r = 0;;
2654 
2655  e = getSmallIntSmallDict(self, key);
2656  if (e) {
2657  r = (uint64_t)e->f->get(e);
2658  finishO(e);
2659  }
2660  return(r);
2661 }
2662 
2663 internal uint32_t getNDupUint32SmallDict(smallDictt *self, const char *key) {
2664  smallIntt *e = NULL;
2665  uint32_t r = 0;;
2666 
2667  e = getSmallIntSmallDict(self, key);
2668  if (e) {
2669  r = (uint32_t)e->f->get(e);
2670  finishO(e);
2671  }
2672  return(r);
2673 }
2674 
2675 internal char* getNDupSSmallDict(smallDictt *self, const char *key) {
2676  smallStringt *e = NULL;
2677  char* r = NULL;
2678 
2679  e = getSmallStringSmallDict(self, key);
2680  if (e) {
2681  r = e->f->toString(e);
2682  finishO(e);
2683  }
2684  return(r);
2685 }
2686 
2687 internal smallDictt* getNDupDictSmallDict(smallDictt *self, const char *key) {
2688 
2689  if (!key || !self->d) {
2690  return(NULL);
2691  }
2692 
2693  smallt *o = sDictGetTiny(self->d, key);
2694 
2695  if (!o) {
2696  return(NULL);
2697  }
2698 
2699  if (o->type != DICT) {
2700  return(NULL);
2701  }
2702  return((smallDictt*) toBaset(sDuplicate(o)));
2703 }
2704 
2705 internal smallArrayt* getNDupArraySmallDict(smallDictt *self, const char *key) {
2706 
2707  if (!key || !self->d) {
2708  return(NULL);
2709  }
2710 
2711  smallt *o = sDictGetTiny(self->d, key);
2712 
2713  if (!o) {
2714  return(NULL);
2715  }
2716 
2717  if (o->type != ARRAY) {
2718  return(NULL);
2719  }
2720  return((smallArrayt*) toBaset(sDuplicate(o)));
2721 }
2722 
2723 internal smallBoolt* getNDupSmallBoolSmallDict(smallDictt *self, const char *key) {
2724 
2725  if (!key || !self->d) {
2726  return(NULL);
2727  }
2728 
2729  smallt *o = sDictGetTiny(self->d, key);
2730 
2731  if (!o) {
2732  return(NULL);
2733  }
2734 
2735  if (o->type != BOOL) {
2736  return(NULL);
2737  }
2738  return((smallBoolt*) toBaset(sDuplicate(o)));
2739 }
2740 
2741 internal smallBytest* getNDupSmallBytesSmallDict(smallDictt *self, const char *key) {
2742 
2743  if (!key || !self->d) {
2744  return(NULL);
2745  }
2746 
2747  smallt *o = sDictGetTiny(self->d, key);
2748 
2749  if (!o) {
2750  return(NULL);
2751  }
2752 
2753  if (o->type != BYTES) {
2754  return(NULL);
2755  }
2756  return((smallBytest*) toBaset(sDuplicate(o)));
2757 }
2758 
2759 internal smallDoublet* getNDupSmallDoubleSmallDict(smallDictt *self, const char *key) {
2760 
2761  if (!key || !self->d) {
2762  return(NULL);
2763  }
2764 
2765  smallt *o = sDictGetTiny(self->d, key);
2766 
2767  if (!o) {
2768  return(NULL);
2769  }
2770 
2771  if (o->type != DOUBLE) {
2772  return(NULL);
2773  }
2774  return((smallDoublet*) toBaset(sDuplicate(o)));
2775 }
2776 
2777 internal smallIntt* getNDupSmallIntSmallDict(smallDictt *self, const char *key) {
2778 
2779  if (!key || !self->d) {
2780  return(NULL);
2781  }
2782 
2783  smallt *o = sDictGetTiny(self->d, key);
2784 
2785  if (!o) {
2786  return(NULL);
2787  }
2788 
2789  if (o->type != INT) {
2790  return(NULL);
2791  }
2792  return((smallIntt*) toBaset(sDuplicate(o)));
2793 }
2794 
2795 internal smallJsont* getNDupSmallJsonSmallDict(smallDictt *self, const char *key) {
2796 
2797  if (!key || !self->d) {
2798  return(NULL);
2799  }
2800 
2801  smallt *o = sDictGetTiny(self->d, key);
2802 
2803  if (!o) {
2804  return(NULL);
2805  }
2806  if ((o->type == BYTES) || (o->type == CONTAINER)) {
2807  return(NULL);
2808  }
2809 
2810  baset *e = toBaset(sDuplicate(o));
2811  createAllocateSmallJson(r);
2812  if (!r) {
2813  finishO(e);
2814  return(NULL);
2815  }
2816  setTopNFreeO(r, e);
2817  return(r);
2818 }
2819 
2820 internal smallStringt* getNDupSmallStringSmallDict(smallDictt *self, const char *key) {
2821 
2822  if (!key || !self->d) {
2823  return(NULL);
2824  }
2825 
2826  smallt *o = sDictGetTiny(self->d, key);
2827 
2828  if (!o) {
2829  return(NULL);
2830  }
2831 
2832  if (o->type != STRING) {
2833  return(NULL);
2834  }
2835  return((smallStringt*) toBaset(sDuplicate(o)));
2836 }
2837 
2838 internal void* getNDupVoidSmallDict(smallDictt *self, const char *key) {
2839  smallContainert *e = NULL;
2840  void* r = NULL;
2841 
2842  e = getNDupSmallContainerSmallDict(self, key);
2843  if (e) {
2844  r = e->f->get(e);
2845  smashO(e);
2846  }
2847  return(r);
2848 }
2849 
2850 internal smallContainert* getNDupSmallContainerSmallDict(smallDictt *self, const char *key) {
2851 
2852  if (!key || !self->d) {
2853  return(NULL);
2854  }
2855 
2856  smallt *o = sDictGetTiny(self->d, key);
2857 
2858  if (!o) {
2859  return(NULL);
2860  }
2861 
2862  if (o->type != CONTAINER) {
2863  return(NULL);
2864  }
2865  if (((sContainert*)o)->dataType == SH_DT_BASET) {
2866  return(NULL);
2867  }
2868  smallContainert *e = (smallContainert*) toBaset(o);
2869  smallContainert *r = duplicateO(e);
2870  finishO(e);
2871  return(r);
2872 }
2873 
2874 
2875 internal baset* getNDupKCharSmallDict(smallDictt *self, char key) {
2876 
2877  charToS(s, key);
2878  return(getNDupSmallDict(self, s));
2879 }
2880 
2881 internal undefinedt* getNDupUndefinedKCharSmallDict(smallDictt *self, char key) {
2882 
2883  charToS(s, key);
2884  return(getNDupUndefinedSmallDict(self, s));
2885 }
2886 
2887 internal bool getNDupBoolKCharSmallDict(smallDictt *self, char key) {
2888 
2889  charToS(s, key);
2890  return(getNDupBoolSmallDict(self, s));
2891 }
2892 
2893 internal double getNDupDoubleKCharSmallDict(smallDictt *self, char key) {
2894 
2895  charToS(s, key);
2896  return(getNDupDoubleSmallDict(self, s));
2897 }
2898 
2899 internal int64_t getNDupIntKCharSmallDict(smallDictt *self, char key) {
2900 
2901  charToS(s, key);
2902  return(getNDupIntSmallDict(self, s));
2903 }
2904 
2905 internal int32_t getNDupInt32KCharSmallDict(smallDictt *self, char key) {
2906 
2907  charToS(s, key);
2908  return(getNDupInt32SmallDict(self, s));
2909 }
2910 
2911 internal uint64_t getNDupUintKCharSmallDict(smallDictt *self, char key) {
2912 
2913  charToS(s, key);
2914  return(getNDupUintSmallDict(self, s));
2915 }
2916 
2917 internal uint32_t getNDupUint32KCharSmallDict(smallDictt *self, char key) {
2918 
2919  charToS(s, key);
2920  return(getNDupUint32SmallDict(self, s));
2921 }
2922 
2923 internal char* getNDupSKCharSmallDict(smallDictt *self, char key) {
2924 
2925  charToS(s, key);
2926  return(getNDupSSmallDict(self, s));
2927 }
2928 
2929 internal smallDictt* getNDupDictKCharSmallDict(smallDictt *self, char key) {
2930 
2931  charToS(s, key);
2932  return(getNDupDictSmallDict(self, s));
2933 }
2934 
2935 internal smallArrayt* getNDupArrayKCharSmallDict(smallDictt *self, char key) {
2936 
2937  charToS(s, key);
2938  return(getNDupArraySmallDict(self, s));
2939 }
2940 
2941 internal smallBoolt* getNDupSmallBoolKCharSmallDict(smallDictt *self, char key) {
2942 
2943  charToS(s, key);
2944  return(getNDupSmallBoolSmallDict(self, s));
2945 }
2946 
2947 internal smallBytest* getNDupSmallBytesKCharSmallDict(smallDictt *self, char key) {
2948 
2949  charToS(s, key);
2950  return(getNDupSmallBytesSmallDict(self, s));
2951 }
2952 
2953 internal smallDoublet* getNDupSmallDoubleKCharSmallDict(smallDictt *self, char key) {
2954 
2955  charToS(s, key);
2956  return(getNDupSmallDoubleSmallDict(self, s));
2957 }
2958 
2959 internal smallIntt* getNDupSmallIntKCharSmallDict(smallDictt *self, char key) {
2960 
2961  charToS(s, key);
2962  return(getNDupSmallIntSmallDict(self, s));
2963 }
2964 
2965 internal smallJsont* getNDupSmallJsonKCharSmallDict(smallDictt *self, char key) {
2966 
2967  charToS(s, key);
2968  return(getNDupSmallJsonSmallDict(self, s));
2969 }
2970 
2971 internal smallStringt* getNDupSmallStringKCharSmallDict(smallDictt *self, char key) {
2972 
2973  charToS(s, key);
2974  return(getNDupSmallStringSmallDict(self, s));
2975 }
2976 
2977 internal void* getNDupVoidKCharSmallDict(smallDictt *self, char key) {
2978 
2979  charToS(s, key);
2980  return(getNDupVoidSmallDict(self, s));
2981 }
2982 
2983 internal smallContainert* getNDupSmallContainerKCharSmallDict(smallDictt *self, char key) {
2984 
2985  charToS(s, key);
2986  return(getNDupSmallContainerSmallDict(self, s));
2987 }
2988 
2989 
2990 internal double getNumSmallDict(smallDictt *self, const char *key) {
2991 
2992  if (!key || !self->d) {
2993  return(0);
2994  }
2995 
2996  smallt *o = sDictGetTiny(self->d, key);
2997 
2998  if (!o) {
2999  return(0);
3000  }
3001  if (o->type != INT && o->type != DOUBLE) {
3002  return(0);
3003  }
3004 
3005  baset *e = toBaset(o);
3006 
3007  double r = 0;
3008  if (isOSmallDouble(e)) {
3009  r = getValO((smallDoublet*)e);
3010  }
3011  elif (isOSmallInt(e)) {
3012  r = (double)getValO((smallIntt*)e);
3013  }
3014  finishO(e);
3015  return(r);
3016 }
3017 
3018 
3019 internal baset* cropElemSmallDict(smallDictt *self, const char* key) {
3020 
3021  if (!key || !self->d) {
3022  return(NULL);
3023  }
3024 
3025  smallt *sm = NULL;
3026  forEachSDict(self->d, e) {
3027  if (e->key && strEq(key, e->key)) {
3028  sm = e->data;
3029  free(e->key);
3030  e->key = NULL;
3031  break;
3032  }
3033  }
3034 
3035  if (!sm) {
3036  return(NULL);
3037  }
3038  if (sm->type == UNDEFINED) {
3039  free(sm);
3040  return((baset*) allocUndefined());
3041  }
3042  else if (sm->type == CONTAINER) {
3043  cast(sContainert*, sc, sm);
3044  if (sc->dataType == SH_DT_BASET) {
3045  // baset object in stored in the container, free the container since
3046  // it was allocated automatically in the toSmallt function in libsheepyObject.c
3047  baset *r = toBaset(sm);
3048  free(sm);
3049  return(r);
3050  }
3051  }
3052  return(toBaset(sm));
3053 }
3054 
3055 
3056 internal undefinedt* cropElemUndefinedSmallDict(smallDictt *self, const char* key) {
3057 
3058  if (!key || !self->d) {
3059  return(NULL);
3060  }
3061 
3062  smallt *sm = NULL;
3063  undefinedt *r = NULL;
3064  forEachSDict(self->d, e) {
3065  if (e->key && strEq(key, e->key)) {
3066  sm = e->data;
3067  if (sm->type != UNDEFINED) {
3068  return(NULL);
3069  }
3070  r = (undefinedt*)toBaset(sm);
3071  free(e->key);
3072  free(e->data);
3073  e->key = NULL;
3074  e->data = NULL;
3075  break;
3076  }
3077  }
3078 
3079  return(r);
3080 }
3081 
3082 internal bool cropElemBoolSmallDict(smallDictt *self, const char* key) {
3083 
3084  if (!key || !self->d) {
3085  return(false);
3086  }
3087 
3088  smallt *sm = NULL;
3089  smallBoolt *o = NULL;
3090  forEachSDict(self->d, e) {
3091  if (e->key && strEq(key, e->key)) {
3092  sm = e->data;
3093  o = (smallBoolt*)toBaset(sm);
3094  if (!o) {
3095  return(false);
3096  }
3097  if (checkObjectTypes && o && !isOSmallBool(o)) {
3098  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3099  return(false);
3100  }
3101  finishO(o);
3102  return(false);
3103  }
3104  free(e->key);
3105  e->key = NULL;
3106 
3107  bool r = o->f->get(o);
3108  terminateO(o);
3109  return(r);
3110  }
3111  }
3112 
3113  return(false);
3114 }
3115 
3116 internal double cropElemDoubleSmallDict(smallDictt *self, const char* key) {
3117 
3118  if (!key || !self->d) {
3119  return(0);
3120  }
3121 
3122  smallt *sm = NULL;
3123  smallDoublet *o = NULL;
3124  forEachSDict(self->d, e) {
3125  if (e->key && strEq(key, e->key)) {
3126  sm = e->data;
3127  o = (smallDoublet*)toBaset(sm);
3128  if (!o) {
3129  return(0);
3130  }
3131  if (checkObjectTypes && o && !isOSmallDouble(o)) {
3132  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3133  return(0);
3134  }
3135  finishO(o);
3136  return(0);
3137  }
3138  free(e->key);
3139  e->key = NULL;
3140 
3141  double r = o->f->get(o);
3142  terminateO(o);
3143  return(r);
3144  }
3145  }
3146 
3147  return(0);
3148 }
3149 
3150 internal int64_t cropElemIntSmallDict(smallDictt *self, const char* key) {
3151 
3152  if (!key || !self->d) {
3153  return(0);
3154  }
3155 
3156  smallt *sm = NULL;
3157  smallIntt *o = NULL;
3158  forEachSDict(self->d, e) {
3159  if (e->key && strEq(key, e->key)) {
3160  sm = e->data;
3161  o = (smallIntt*)toBaset(sm);
3162  if (!o) {
3163  return(0);
3164  }
3165  if (checkObjectTypes && o && !isOSmallInt(o)) {
3166  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3167  return(0);
3168  }
3169  finishO(o);
3170  return(0);
3171  }
3172  free(e->key);
3173  e->key = NULL;
3174 
3175  int64_t r = o->f->get(o);
3176  terminateO(o);
3177  return(r);
3178  }
3179  }
3180 
3181  return(0);
3182 }
3183 
3184 internal int32_t cropElemInt32SmallDict(smallDictt *self, const char* key) {
3185 
3186  if (!key || !self->d) {
3187  return(0);
3188  }
3189 
3190  smallt *sm = NULL;
3191  smallIntt *o = NULL;
3192  forEachSDict(self->d, e) {
3193  if (e->key && strEq(key, e->key)) {
3194  sm = e->data;
3195  o = (smallIntt*)toBaset(sm);
3196  if (!o) {
3197  return(0);
3198  }
3199  if (checkObjectTypes && o && !isOSmallInt(o)) {
3200  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3201  return(0);
3202  }
3203  finishO(o);
3204  return(0);
3205  }
3206  free(e->key);
3207  e->key = NULL;
3208 
3209  int32_t r = (int32_t)o->f->get(o);
3210  terminateO(o);
3211  return(r);
3212  }
3213  }
3214 
3215  return(0);
3216 }
3217 
3218 internal uint64_t cropElemUintSmallDict(smallDictt *self, const char* key) {
3219 
3220  if (!key || !self->d) {
3221  return(0);
3222  }
3223 
3224  smallt *sm = NULL;
3225  smallIntt *o = NULL;
3226  forEachSDict(self->d, e) {
3227  if (e->key && strEq(key, e->key)) {
3228  sm = e->data;
3229  o = (smallIntt*)toBaset(sm);
3230  if (!o) {
3231  return(0);
3232  }
3233  if (checkObjectTypes && o && !isOSmallInt(o)) {
3234  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3235  return(0);
3236  }
3237  finishO(o);
3238  return(0);
3239  }
3240  free(e->key);
3241  e->key = NULL;
3242 
3243  uint64_t r = (uint64_t)o->f->get(o);
3244  terminateO(o);
3245  return(r);
3246  }
3247  }
3248 
3249  return(0);
3250 }
3251 
3252 internal uint32_t cropElemUint32SmallDict(smallDictt *self, const char* key) {
3253 
3254  if (!key || !self->d) {
3255  return(0);
3256  }
3257 
3258  smallt *sm = NULL;
3259  smallIntt *o = NULL;
3260  forEachSDict(self->d, e) {
3261  if (e->key && strEq(key, e->key)) {
3262  sm = e->data;
3263  o = (smallIntt*)toBaset(sm);
3264  if (!o) {
3265  return(0);
3266  }
3267  if (checkObjectTypes && o && !isOSmallInt(o)) {
3268  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3269  return(0);
3270  }
3271  finishO(o);
3272  return(0);
3273  }
3274  free(e->key);
3275  e->key = NULL;
3276 
3277  uint32_t r = (uint32_t)o->f->get(o);
3278  terminateO(o);
3279  return(r);
3280  }
3281  }
3282 
3283  return(0);
3284 }
3285 
3286 internal char* cropElemSSmallDict(smallDictt *self, const char* key) {
3287 
3288  if (!key || !self->d) {
3289  return(NULL);
3290  }
3291 
3292  smallt *sm = NULL;
3293  smallStringt *o = NULL;
3294  forEachSDict(self->d, e) {
3295  if (e->key && strEq(key, e->key)) {
3296  sm = e->data;
3297  o = (smallStringt*)toBaset(sm);
3298  if (!o) {
3299  return(NULL);
3300  }
3301  if (checkObjectTypes && o && !isOSmallString(o)) {
3302  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3303  return(NULL);
3304  }
3305  finishO(o);
3306  return(NULL);
3307  }
3308  free(e->key);
3309  e->key = NULL;
3310 
3311  char *r = dupS(o->f->get(o));
3312  terminateO(o);
3313  return(r);
3314  }
3315  }
3316 
3317  return(NULL);
3318 }
3319 
3320 internal smallDictt* cropElemDictSmallDict(smallDictt *self, const char* key) {
3321 
3322  if (!key || !self->d) {
3323  return(NULL);
3324  }
3325 
3326  smallt *sm = NULL;
3327  smallDictt *r = NULL;
3328  forEachSDict(self->d, e) {
3329  if (e->key && strEq(key, e->key)) {
3330  sm = e->data;
3331  r = (smallDictt*)toBaset(sm);
3332  if (checkObjectTypes && r && !isOSmallDict(r)) {
3333  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3334  return(NULL);
3335  }
3336  finishO(r);
3337  return(NULL);
3338  }
3339  free(e->key);
3340  e->key = NULL;
3341  break;
3342  }
3343  }
3344 
3345  return(r);
3346 }
3347 
3348 internal smallArrayt* cropElemArraySmallDict(smallDictt *self, const char* key) {
3349 
3350  if (!key || !self->d) {
3351  return(NULL);
3352  }
3353 
3354  smallt *sm = NULL;
3355  smallArrayt *r = NULL;
3356  forEachSDict(self->d, e) {
3357  if (e->key && strEq(key, e->key)) {
3358  sm = e->data;
3359  r = (smallArrayt*)toBaset(sm);
3360  if (checkObjectTypes && r && !isOSmallArray(r)) {
3361  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3362  return(NULL);
3363  }
3364  finishO(r);
3365  return(NULL);
3366  }
3367  free(e->key);
3368  e->key = NULL;
3369  break;
3370  }
3371  }
3372 
3373  return(r);
3374 }
3375 
3376 internal smallBoolt* cropElemSmallBoolSmallDict(smallDictt *self, const char* key) {
3377 
3378  if (!key || !self->d) {
3379  return(NULL);
3380  }
3381 
3382  smallt *sm = NULL;
3383  smallBoolt *r = NULL;
3384  forEachSDict(self->d, e) {
3385  if (e->key && strEq(key, e->key)) {
3386  sm = e->data;
3387  r = (smallBoolt*)toBaset(sm);
3388  if (checkObjectTypes && r && !isOSmallBool(r)) {
3389  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3390  return(NULL);
3391  }
3392  finishO(r);
3393  return(NULL);
3394  }
3395  free(e->key);
3396  e->key = NULL;
3397  break;
3398  }
3399  }
3400 
3401  return(r);
3402 }
3403 
3404 internal smallBytest* cropElemSmallBytesSmallDict(smallDictt *self, const char* key) {
3405 
3406  if (!key || !self->d) {
3407  return(NULL);
3408  }
3409 
3410  smallt *sm = NULL;
3411  smallBytest *r = NULL;
3412  forEachSDict(self->d, e) {
3413  if (e->key && strEq(key, e->key)) {
3414  sm = e->data;
3415  r = (smallBytest*)toBaset(sm);
3416  if (checkObjectTypes && r && !isOSmallBytes(r)) {
3417  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3418  return(NULL);
3419  }
3420  finishO(r);
3421  return(NULL);
3422  }
3423  free(e->key);
3424  e->key = NULL;
3425  break;
3426  }
3427  }
3428 
3429  return(r);
3430 }
3431 
3432 internal smallDoublet* cropElemSmallDoubleSmallDict(smallDictt *self, const char* key) {
3433 
3434  if (!key || !self->d) {
3435  return(NULL);
3436  }
3437 
3438  smallt *sm = NULL;
3439  smallDoublet *r = NULL;
3440  forEachSDict(self->d, e) {
3441  if (e->key && strEq(key, e->key)) {
3442  sm = e->data;
3443  r = (smallDoublet*)toBaset(sm);
3444  if (checkObjectTypes && r && !isOSmallDouble(r)) {
3445  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3446  return(NULL);
3447  }
3448  finishO(r);
3449  return(NULL);
3450  }
3451  free(e->key);
3452  e->key = NULL;
3453  break;
3454  }
3455  }
3456 
3457  return(r);
3458 }
3459 
3460 internal smallIntt* cropElemSmallIntSmallDict(smallDictt *self, const char* key) {
3461 
3462  if (!key || !self->d) {
3463  return(NULL);
3464  }
3465 
3466  smallt *sm = NULL;
3467  smallIntt *r = NULL;
3468  forEachSDict(self->d, e) {
3469  if (e->key && strEq(key, e->key)) {
3470  sm = e->data;
3471  r = (smallIntt*)toBaset(sm);
3472  if (checkObjectTypes && r && !isOSmallInt(r)) {
3473  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3474  return(NULL);
3475  }
3476  finishO(r);
3477  return(NULL);
3478  }
3479  free(e->key);
3480  e->key = NULL;
3481  break;
3482  }
3483  }
3484 
3485  return(r);
3486 }
3487 
3488 internal smallJsont* cropElemSmallJsonSmallDict(smallDictt *self, const char* key) {
3489 
3490  if (!key || !self->d) {
3491  return(NULL);
3492  }
3493 
3494  smallt *sm = NULL;
3495  forEachSDict(self->d, e) {
3496  if (e->key && strEq(key, e->key)) {
3497  sm = e->data;
3498  if ((sm->type == BYTES) || (sm->type == CONTAINER)) {
3499  return(NULL);
3500  }
3501  baset *o = toBaset(sm);
3502  if (!o) {
3503  return(NULL);
3504  }
3505  free(e->key);
3506  e->key = NULL;
3507  createAllocateSmallJson(r);
3508  if (!r) {
3509  finishO(o);
3510  return(NULL);
3511  }
3512  setTopNFreeO(r, o);
3513  return(r);
3514  }
3515  }
3516 
3517  return(NULL);
3518 }
3519 
3520 internal smallStringt* cropElemSmallStringSmallDict(smallDictt *self, const char* key) {
3521 
3522  if (!key || !self->d) {
3523  return(NULL);
3524  }
3525 
3526  smallt *sm = NULL;
3527  smallStringt *r = NULL;
3528  forEachSDict(self->d, e) {
3529  if (e->key && strEq(key, e->key)) {
3530  sm = e->data;
3531  r = (smallStringt*)toBaset(sm);
3532  if (checkObjectTypes && r && !isOSmallString(r)) {
3533  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3534  return(NULL);
3535  }
3536  finishO(r);
3537  return(NULL);
3538  }
3539  free(e->key);
3540  e->key = NULL;
3541  break;
3542  }
3543  }
3544 
3545  return(r);
3546 }
3547 
3548 internal void* cropElemVoidSmallDict(smallDictt *self, const char* key) {
3549 
3550  if (!key || !self->d) {
3551  return(NULL);
3552  }
3553 
3554  smallt *sm = NULL;
3555  smallContainert *o = NULL;
3556  forEachSDict(self->d, e) {
3557  if (e->key && strEq(key, e->key)) {
3558  sm = e->data;
3559  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3560  return(NULL);
3561  }
3562  o = (smallContainert*)toBaset(sm);
3563  if (!o) {
3564  return(NULL);
3565  }
3566  if (checkObjectTypes && o && !isOSmallContainer(o)) {
3567  finishO(o);
3568  return(NULL);
3569  }
3570  free(e->key);
3571  e->key = NULL;
3572 
3573  void *r = o->f->get(o);
3574  terminateO(o);
3575  return(r);
3576  }
3577  }
3578 
3579  return(NULL);
3580 }
3581 
3582 internal smallContainert* cropElemSmallContainerSmallDict(smallDictt *self, const char* key) {
3583 
3584  if (!key || !self->d) {
3585  return(NULL);
3586  }
3587 
3588  smallt *sm = NULL;
3589  smallContainert *r = NULL;
3590  forEachSDict(self->d, e) {
3591  if (e->key && strEq(key, e->key)) {
3592  sm = e->data;
3593  if ((sm->type == CONTAINER) && (((sContainert*)sm)->dataType == SH_DT_BASET)) {
3594  return(NULL);
3595  }
3596  r = (smallContainert*)toBaset(sm);
3597  if (checkObjectTypes && r && !isOSmallContainer(r)) {
3598  finishO(r);
3599  return(NULL);
3600  }
3601  free(e->key);
3602  e->key = NULL;
3603  break;
3604  }
3605  }
3606 
3607  return(r);
3608 }
3609 
3610 internal smallDictt* delSmallDict(smallDictt *self, const char *key) {
3611 
3612  if (key && self->d) {
3613  // TODO report error (null) when key is not found
3614  sDictDelTiny(self->d, key);
3615  return(self);
3616  }
3617  return(NULL);
3618 }
3619 
3620 internal smallDictt* delKCharSmallDict(smallDictt *self, char key) {
3621 
3622  charToS(s, key);
3623  return(delSmallDict(self, s));
3624 }
3625 
3626 internal smallDictt* removeSmallDict(smallDictt *self, const char *key) {
3627 
3628  if (key && self->d) {
3629  forEachSDict(self->d, e) {
3630  if (e->key && eqS(key, e->key)) {
3631  free(e->key);
3632  e->key = NULL;
3633  break;
3634  }
3635  }
3636  return(self);
3637  }
3638  return(NULL);
3639 }
3640 
3641 internal smallDictt* removeKCharSmallDict(smallDictt *self, char key) {
3642 
3643  charToS(s, key);
3644  return(removeSmallDict(self, s));
3645 }
3646 
3647 internal bool hasSmallDict(smallDictt *self, const char *key) {
3648 
3649  if (!key) {
3650  return(false);
3651  }
3652 
3653  if (!self->d) {
3654  return(false);
3655  }
3656 
3657  smallt *o = sDictGetTiny(self->d, key);
3658 
3659  if (!o) {
3660  return(false);
3661  }
3662 
3663  return(true);
3664 }
3665 
3666 internal bool hasKCharSmallDict(smallDictt *self, char key) {
3667 
3668  charToS(s, key);
3669  return(hasSmallDict(self, s));
3670 }
3671 
3672 internal char* keyBySmallDict(smallDictt *self, baset *value) {
3673 
3674  // sanity checks
3675  if (!lenSmallDict(self) || !value) {
3676  return(NULL);
3677  }
3678 
3679  // search string in elements
3680  char *s = toStringO(value);
3681  char *es = NULL;
3682 
3683  forEachSDict(self->d, e) {
3684  if (e->key) {
3685  es = sToString(e->data);
3686  if (strEq(es, s)) {
3687  free(es);
3688  free(s);
3689  return(e->key);
3690  }
3691  free(es);
3692  }
3693  }
3694  free(s);
3695  return(NULL);
3696 }
3697 
3698 internal char* keyByUndefinedSmallDict(smallDictt *self, undefinedt *u) {
3699 
3700  // sanity checks
3701  if (!lenSmallDict(self) || !u) {
3702  return(NULL);
3703  }
3704 
3705  if (checkObjectTypes && !isOUndefined(u)) {
3706  return(NULL);
3707  }
3708 
3709  // search string in elements
3710  forEachSDict(self->d, e) {
3711  if (e->key && e->data->type == UNDEFINED) {
3712  return(e->key);
3713  }
3714  }
3715  return(NULL);
3716 }
3717 
3718 internal char* keyByBoolSmallDict(smallDictt *self, bool value) {
3719 
3720  // sanity checks
3721  if (!lenSmallDict(self)) {
3722  return(NULL);
3723  }
3724 
3725  // search value in elements
3726  forEachSDict(self->d, e) {
3727  if (e->key && e->data->type == BOOL && ((sBoolt*)(e->data))->value == value) {
3728  return(e->key);
3729  }
3730  }
3731  return(NULL);
3732 }
3733 
3734 internal char* keyByDoubleSmallDict(smallDictt *self, double value) {
3735 
3736  // sanity checks
3737  if (!lenSmallDict(self)) {
3738  return(NULL);
3739  }
3740 
3741  // search value in elements
3742  forEachSDict(self->d, e) {
3743  if (e->key && e->data->type == DOUBLE && ((sDoublet*)(e->data))->value == value) {
3744  return(e->key);
3745  }
3746  }
3747  return(NULL);
3748 }
3749 
3750 internal char* keyByIntSmallDict(smallDictt *self, int64_t value) {
3751 
3752  // sanity checks
3753  if (!lenSmallDict(self)) {
3754  return(NULL);
3755  }
3756 
3757  // search value in elements
3758  forEachSDict(self->d, e) {
3759  if (e->key && e->data->type == INT && ((sIntt*)(e->data))->value == value) {
3760  return(e->key);
3761  }
3762  }
3763  return(NULL);
3764 }
3765 
3766 internal char* keyBySSmallDict(smallDictt *self, const char *string) {
3767 
3768  // sanity checks
3769  if (!lenSmallDict(self) || !string) {
3770  return(NULL);
3771  }
3772  // search string in elements
3773  forEachSDict(self->d, e) {
3774  if (e->key && e->data->type == STRING && eqS(sStringGetTiny((sStringt*)(e->data)), string)) {
3775  return(e->key);
3776  }
3777  }
3778  return(NULL);
3779 }
3780 
3781 internal char* keyByCharSmallDict(smallDictt *self, char c) {
3782 
3783  charToS(s, c);
3784  return(keyBySSmallDict(self, s));
3785 }
3786 
3787 internal char* keyByDictSmallDict(smallDictt *self, smallDictt *dict) {
3788 
3789  // sanity checks
3790  if (!lenSmallDict(self) || !dict) {
3791  return(NULL);
3792  }
3793 
3794  if (checkObjectTypes && !isOSmallDict(dict)) {
3795  return(NULL);
3796  }
3797 
3798  // search object in elements
3799  char *s = toStringO(dict);
3800  char *es = NULL;
3801 
3802  forEachSDict(self->d, e) {
3803  if (e->key && e->data->type == DICT) {
3804  es = sToString(e->data);
3805  if (eqS(es, s)) {
3806  free(es);
3807  free(s);
3808  return(e->key);
3809  }
3810  free(es);
3811  }
3812  }
3813  free(s);
3814  return(NULL);
3815 }
3816 
3817 internal char* keyByArraySmallDict(smallDictt *self, smallArrayt *array) {
3818 
3819  // sanity checks
3820  if (!lenSmallDict(self) || !array) {
3821  return(NULL);
3822  }
3823 
3824  if (checkObjectTypes && !isOSmallArray(array)) {
3825  return(NULL);
3826  }
3827 
3828  // search object in elements
3829  char *s = toStringO(array);
3830  char *es = NULL;
3831 
3832  forEachSDict(self->d, e) {
3833  if (e->key && e->data->type == ARRAY) {
3834  es = sToString(e->data);
3835  if (eqS(es, s)) {
3836  free(es);
3837  free(s);
3838  return(e->key);
3839  }
3840  free(es);
3841  }
3842  }
3843  free(s);
3844  return(NULL);
3845 }
3846 
3847 internal char* keyByArraycSmallDict(smallDictt *self, char **array) {
3848 
3849  // sanity checks
3850  if (!lenSmallDict(self) || !array) {
3851  return(NULL);
3852  }
3853 
3854  // search object in elements
3855  char *s = toStringListSGF(array);
3856  char *es = NULL;
3857 
3858  forEachSDict(self->d, e) {
3859  if (e->key && e->data->type == ARRAY) {
3860  es = sToString(e->data);
3861  if (eqS(es, s)) {
3862  free(es);
3863  free(s);
3864  return(e->key);
3865  }
3866  free(es);
3867  }
3868  }
3869  free(s);
3870  return(NULL);
3871 }
3872 
3873 internal char* keyByCArraycSmallDict(smallDictt *self, const char **array) {
3874 
3875  // sanity checks
3876  if (!lenSmallDict(self) || !array) {
3877  return(NULL);
3878  }
3879 
3880  // search object in elements
3881  char *s = toStringListCSGF(array);
3882  char *es = NULL;
3883 
3884  forEachSDict(self->d, e) {
3885  if (e->key && e->data->type == ARRAY) {
3886  es = sToString(e->data);
3887  if (eqS(es, s)) {
3888  free(es);
3889  free(s);
3890  return(e->key);
3891  }
3892  free(es);
3893  }
3894  }
3895  free(s);
3896  return(NULL);
3897 }
3898 
3899 internal char* keyBySmallBoolSmallDict(smallDictt *self, smallBoolt *value) {
3900 
3901  // sanity checks
3902  if (!lenSmallDict(self) || !value) {
3903  return(NULL);
3904  }
3905 
3906  if (checkObjectTypes && !isOSmallBool(value)) {
3907  return(NULL);
3908  }
3909 
3910  // search object in elements
3911  bool b = value->f->get(value);
3912 
3913  forEachSDict(self->d, e) {
3914  if (e->key && e->data->type == BOOL && ((sBoolt*)(e->data))->value == b) {
3915  return(e->key);
3916  }
3917  }
3918  return(NULL);
3919 }
3920 
3921 internal char* keyBySmallBytesSmallDict(smallDictt *self, smallBytest *value) {
3922 
3923  // sanity checks
3924  if (!lenSmallDict(self) || !value || !value->B) {
3925  return(NULL);
3926  }
3927 
3928  if (checkObjectTypes && !isOSmallBytes(value)) {
3929  return(NULL);
3930  }
3931 
3932  // search object in elements
3933  void *b = sBytesGet(value->B);
3934  uint32_t count = value->B->count;
3935 
3936  forEachSDict(self->d, e) {
3937  if (e->key && e->data->type == BYTES && ((sBytest*)e->data)->count == count && !memcmp(&(((sBytest*)e->data)->data), b, count)) {
3938  return(e->key);
3939  }
3940  }
3941  return(NULL);
3942 }
3943 
3944 internal char* keyBySmallDoubleSmallDict(smallDictt *self, smallDoublet *value) {
3945 
3946  // sanity checks
3947  if (!lenSmallDict(self) || !value) {
3948  return(NULL);
3949  }
3950 
3951  if (checkObjectTypes && !isOSmallDouble(value)) {
3952  return(NULL);
3953  }
3954 
3955  // search object in elements
3956  double v = value->f->get(value);
3957 
3958  forEachSDict(self->d, e) {
3959  if (e->key && e->data->type == DOUBLE && ((sDoublet*)(e->data))->value == v) {
3960  return(e->key);
3961  }
3962  }
3963  return(NULL);
3964 }
3965 
3966 internal char* keyBySmallIntSmallDict(smallDictt *self, smallIntt *value) {
3967 
3968  // sanity checks
3969  if (!lenSmallDict(self) || !value) {
3970  return(NULL);
3971  }
3972 
3973  if (checkObjectTypes && !isOSmallInt(value)) {
3974  return(NULL);
3975  }
3976 
3977  // search object in elements
3978  int64_t v = value->f->get(value);
3979 
3980  forEachSDict(self->d, e) {
3981  if (e->key && e->data->type == INT && ((sIntt*)(e->data))->value == v) {
3982  return(e->key);
3983  }
3984  }
3985  return(NULL);
3986 }
3987 
3988 internal char* keyBySmallJsonSmallDict(smallDictt *self, smallJsont *string) {
3989 
3990  // sanity checks
3991  if (!lenSmallDict(self) || !string) {
3992  return(NULL);
3993  }
3994 
3995  if (checkObjectTypes && !isOSmallJson(string)) {
3996  return(NULL);
3997  }
3998 
3999  const char *type = getTopTypeO(string);
4000 
4001  if (!type) {
4002  // smallJson is empty
4003  return(NULL);
4004  }
4005 
4006  baset *O = NULL;
4007  char *r = NULL;
4008  if (eqS(type, "undefined")) {
4009  O = getTopO(string);
4010  r = keyBySmallDict(self, O);
4011  finishO(O);
4012  }
4013  else if (eqS(type, "bool")) {
4014  O = getTopO(string);
4015  r = keyBySmallBoolSmallDict(self, (smallBoolt*)O);
4016  finishO(O);
4017  }
4018  else if (eqS(type, "double")) {
4019  O = getTopO(string);
4020  r = keyBySmallDoubleSmallDict(self, (smallDoublet*)O);
4021  finishO(O);
4022  }
4023  else if (eqS(type, "int")) {
4024  O = getTopO(string);
4025  r = keyBySmallIntSmallDict(self, (smallIntt*)O);
4026  finishO(O);
4027  }
4028  else if (eqS(type, "string")) {
4029  O = getTopO(string);
4030  r = keyBySmallStringSmallDict(self, (smallStringt*)O);
4031  finishO(O);
4032  }
4033  else if (eqS(type, "dict")) {
4034  O = getTopO(string);
4035  r = keyByDictSmallDict(self, (smallDictt*)O);
4036  finishO(O);
4037  }
4038  else if (eqS(type, "array")) {
4039  O = getTopO(string);
4040  r = keyByArraySmallDict(self, (smallArrayt*)O);
4041  finishO(O);
4042  }
4043  return(r);
4044 }
4045 
4046 internal char* keyBySmallStringSmallDict(smallDictt *self, smallStringt *string) {
4047 
4048  // sanity checks
4049  if (!lenSmallDict(self)) {
4050  return(NULL);
4051  }
4052 
4053  if (!string || !string->data) {
4054  return(NULL);
4055  }
4056 
4057  if (checkObjectTypes && !isOSmallString(string)) {
4058  return(NULL);
4059  }
4060 
4061  // search string in elements
4062  char *s = sStringGetTiny(string->data);
4063 
4064  forEachSDict(self->d, e) {
4065  if (e->key && e->data->type == STRING && strEq(sStringGetTiny((sStringt*)(e->data)), s)) {
4066  return(e->key);
4067  }
4068  }
4069  return(NULL);
4070 }
4071 
4072 internal char* keyBySmallContainerSmallDict(smallDictt *self, smallContainert *container) {
4073 
4074  if (!lenSmallDict(self) || !container) {
4075  return(NULL);
4076  }
4077 
4078  if (checkObjectTypes && !isOSmallContainer(container)) {
4079  return(NULL);
4080  }
4081 
4082  return(NULL);
4083 }
4084 
4085 internal char* icKeyBySmallDict(smallDictt *self, baset *value) {
4086 
4087  // sanity checks
4088  if (!lenSmallDict(self) || !value) {
4089  return(NULL);
4090  }
4091 
4092  // search string in elements
4093  char *s = toStringO(value);
4094  char *es = NULL;
4095 
4096  forEachSDict(self->d, e) {
4097  if (e->key) {
4098  es = sToString(e->data);
4099  if (icEqS(es, s)) {
4100  free(es);
4101  free(s);
4102  return(e->key);
4103  }
4104  free(es);
4105  }
4106  }
4107  free(s);
4108  return(NULL);
4109 }
4110 
4111 internal char* icKeyBySSmallDict(smallDictt *self, const char *string) {
4112 
4113  // sanity checks
4114  if (!lenSmallDict(self) || !string) {
4115  return(NULL);
4116  }
4117  // search string in elements
4118  forEachSDict(self->d, e) {
4119  if (e->key && e->data->type == STRING && icEqS(sStringGetTiny((sStringt*)(e->data)), string)) {
4120  return(e->key);
4121  }
4122  }
4123  return(NULL);
4124 }
4125 
4126 internal char* icKeyByCharSmallDict(smallDictt *self, char c) {
4127 
4128  charToS(s, c);
4129  return(icKeyBySSmallDict(self, s));
4130 }
4131 
4132 internal char* icKeyByDictSmallDict(smallDictt *self, smallDictt *dict) {
4133 
4134  // sanity checks
4135  if (!lenSmallDict(self) || !dict) {
4136  return(NULL);
4137  }
4138 
4139  if (checkObjectTypes && !isOSmallDict(dict)) {
4140  return(NULL);
4141  }
4142 
4143  // search object in elements
4144  char *s = toStringO(dict);
4145  char *es = NULL;
4146 
4147  forEachSDict(self->d, e) {
4148  if (e->key && e->data->type == DICT) {
4149  es = sToString(e->data);
4150  if (icEqS(es, s)) {
4151  free(es);
4152  free(s);
4153  return(e->key);
4154  }
4155  free(es);
4156  }
4157  }
4158  free(s);
4159  return(NULL);
4160 }
4161 
4162 internal char* icKeyByArraySmallDict(smallDictt *self, smallArrayt *array) {
4163 
4164  // sanity checks
4165  if (!lenSmallDict(self) || !array) {
4166  return(NULL);
4167  }
4168 
4169  if (checkObjectTypes && !isOSmallArray(array)) {
4170  return(NULL);
4171  }
4172 
4173  // search object in elements
4174  char *s = toStringO(array);
4175  char *es = NULL;
4176 
4177  forEachSDict(self->d, e) {
4178  if (e->key && e->data->type == ARRAY) {
4179  es = sToString(e->data);
4180  if (icEqS(es, s)) {
4181  free(es);
4182  free(s);
4183  return(e->key);
4184  }
4185  free(es);
4186  }
4187  }
4188  free(s);
4189  return(NULL);
4190 }
4191 
4192 internal char* icKeyByArraycSmallDict(smallDictt *self, char **array) {
4193 
4194  // sanity checks
4195  if (!lenSmallDict(self) || !array) {
4196  return(NULL);
4197  }
4198 
4199  // search object in elements
4200  char *s = toStringListSGF(array);
4201  char *es = NULL;
4202 
4203  forEachSDict(self->d, e) {
4204  if (e->key && e->data->type == ARRAY) {
4205  es = sToString(e->data);
4206  if (icEqS(es, s)) {
4207  free(es);
4208  free(s);
4209  return(e->key);
4210  }
4211  free(es);
4212  }
4213  }
4214  free(s);
4215  return(NULL);
4216 }
4217 
4218 internal char* icKeyByCArraycSmallDict(smallDictt *self, const char **array) {
4219 
4220  // sanity checks
4221  if (!lenSmallDict(self) || !array) {
4222  return(NULL);
4223  }
4224 
4225  // search object in elements
4226  char *s = toStringListCSGF(array);
4227  char *es = NULL;
4228 
4229  forEachSDict(self->d, e) {
4230  if (e->key && e->data->type == ARRAY) {
4231  es = sToString(e->data);
4232  if (icEqS(es, s)) {
4233  free(es);
4234  free(s);
4235  return(e->key);
4236  }
4237  free(es);
4238  }
4239  }
4240  free(s);
4241  return(NULL);
4242 }
4243 
4244 internal char* icKeyBySmallJsonSmallDict(smallDictt *self, smallJsont *string) {
4245 
4246  // sanity checks
4247  if (!lenSmallDict(self) || !string) {
4248  return(NULL);
4249  }
4250 
4251  if (checkObjectTypes && !isOSmallJson(string)) {
4252  return(NULL);
4253  }
4254 
4255  const char *type = getTopTypeO(string);
4256 
4257  if (!type) {
4258  // smallJson is empty
4259  return(NULL);
4260  }
4261 
4262  baset *O = NULL;
4263  char *r = NULL;
4264  if (eqS(type, "undefined")) {
4265  O = getTopO(string);
4266  r = keyBySmallDict(self, O);
4267  finishO(O);
4268  }
4269  else if (eqS(type, "bool")) {
4270  O = getTopO(string);
4271  r = keyBySmallBoolSmallDict(self, (smallBoolt*)O);
4272  finishO(O);
4273  }
4274  else if (eqS(type, "double")) {
4275  O = getTopO(string);
4276  r = keyBySmallDoubleSmallDict(self, (smallDoublet*)O);
4277  finishO(O);
4278  }
4279  else if (eqS(type, "int")) {
4280  O = getTopO(string);
4281  r = keyBySmallIntSmallDict(self, (smallIntt*)O);
4282  finishO(O);
4283  }
4284  else if (eqS(type, "string")) {
4285  O = getTopO(string);
4286  r = icKeyBySmallStringSmallDict(self, (smallStringt*)O);
4287  finishO(O);
4288  }
4289  else if (eqS(type, "dict")) {
4290  O = getTopO(string);
4291  r = icKeyByDictSmallDict(self, (smallDictt*)O);
4292  finishO(O);
4293  }
4294  else if (eqS(type, "array")) {
4295  O = getTopO(string);
4296  r = icKeyByArraySmallDict(self, (smallArrayt*)O);
4297  finishO(O);
4298  }
4299  return(r);
4300 }
4301 
4302 internal char* icKeyBySmallStringSmallDict(smallDictt *self, smallStringt *string) {
4303 
4304  // sanity checks
4305  if (!lenSmallDict(self)) {
4306  return(NULL);
4307  }
4308 
4309  if (!string || !string->data) {
4310  return(NULL);
4311  }
4312 
4313  if (checkObjectTypes && !isOSmallString(string)) {
4314  return(NULL);
4315  }
4316 
4317  // search string in elements
4318  char *s = sStringGetTiny(string->data);
4319 
4320  forEachSDict(self->d, e) {
4321  if (e->key && e->data->type == STRING && icEqS(sStringGetTiny((sStringt*)(e->data)), s)) {
4322  return(e->key);
4323  }
4324  }
4325  return(NULL);
4326 }
4327 
4328 
4329 internal smallDictt* trimSmallDict(smallDictt *self) {
4330  sDictt *d = NULL;
4331 
4332  if (!lenSmallDict(self)) {
4333  return(self);
4334  }
4335 
4336  isError(d, allocSDict()) return(NULL);
4337 
4338  forEachSDict(self->d, e) {
4339  if (e->key) {
4340  sDictSetTiny(&d, e->key, e->data);
4341  free(e->key);
4342  }
4343  }
4344 
4345  free(self->d);
4346  self->d = d;
4347  return(self);
4348 }
4349 
4350 internal char** keysSmallDict(smallDictt *self) {
4351  char **r = NULL;
4352 
4353  if (!lenSmallDict(self)) {
4354  // empty
4355  return(NULL);
4356  }
4357 
4358  forEachSDict(self->d, e) {
4359  if (e->key) {
4360  pErrorNULL(listPushS(&r, e->key));
4361  }
4362  }
4363  return(r);
4364 }
4365 
4366 internal smallArrayt* keysSmallStringSmallDict(smallDictt *self) {
4367 
4368  char** r = keysSmallDict(self);
4369  createAllocateSmallArray(a);
4370  if (!a) {
4371  listFreeS(r);
4372  return(NULL);
4373  }
4374  fromArrayNFreeO(a, r, 0);
4375  return(a);
4376 }
4377 
4378 internal smallArrayt* valuesSmallDict(smallDictt *self) {
4379 
4380  if (!lenSmallDict(self)) {
4381  // empty
4382  return(NULL);
4383  }
4384 
4385  createAllocateSmallArray(a);
4386  if (!a) {
4387  return(NULL);
4388  }
4389 
4390  forEachSDict(self->d, e) {
4391  if (e->key) {
4392  sArrayPushTiny(&(a->a), e->data);
4393  }
4394  }
4395 
4396  return(a);
4397 }
4398 
4399 internal smallDictt* mergeSmallDict(smallDictt *self, smallDictt *smallDict) {
4400 
4401  // sanity checks
4402  if (!smallDict) {
4403  return(NULL);
4404  }
4405 
4406  if (checkObjectTypes && !isOSmallDict(smallDict)) {
4407  return(NULL);
4408  }
4409 
4410  if (!smallDict->f->len(smallDict)) {
4411  return(self);
4412  }
4413 
4414  forEachSDict(smallDict->d, e) {
4415  if (e->key) {
4416  sDictSetTiny(&(self->d), e->key, e->data);
4417  }
4418  }
4419  return(self);
4420 }
4421 
4422 internal smallDictt* mergeSmallJsonSmallDict(smallDictt *self, smallJsont *json) {
4423 
4424  // sanity checks
4425  if (!json) {
4426  return(NULL);
4427  }
4428 
4429  if (checkObjectTypes && !isOSmallJson(json)) {
4430  return(NULL);
4431  }
4432 
4433  const char *type = getTopTypeO(json);
4434 
4435  if (!eqS(type,"dict")) {
4436  return(NULL);
4437  }
4438 
4439  if (!json->f->len(json)) {
4440  return(self);
4441  }
4442 
4443  forEachSDict(json->top, e) {
4444  if (e->key) {
4445  sDictSetTiny(&(self->d), e->key, e->data);
4446  }
4447  }
4448  return(self);
4449 }
4450 
4451 internal smallDictt* mergeNSmashSmallDict(smallDictt *self, smallDictt *smallDict) {
4452  smallDictt *r = NULL;
4453 
4454  r = mergeSmallDict(self, smallDict);
4455  if (r) {
4456  smashO(smallDict);
4457  }
4458  return(r);
4459 }
4460 
4461 internal smallDictt* mergeNSmashSmallJsonSmallDict(smallDictt *self, smallJsont *json) {
4462  smallDictt *r = NULL;
4463 
4464  r = mergeSmallJsonSmallDict(self, json);
4465  if (r) {
4466  smashO(json);
4467  }
4468  return(r);
4469 }
4470 
4471 
4472 internal smallDictt* appendSmallDict(smallDictt *self, smallDictt *smallDict) {
4473 
4474  // sanity checks
4475  if (!smallDict) {
4476  return(NULL);
4477  }
4478 
4479  if (checkObjectTypes && !isOSmallDict(smallDict)) {
4480  return(NULL);
4481  }
4482 
4483  if (!smallDict->f->len(smallDict)) {
4484  return(self);
4485  }
4486 
4487  forEachSDict(smallDict->d, e) {
4488  if (e->key) {
4489  if (self->d && sDictGetTiny(self->d, e->key)) {
4490  // keep existing value
4491  continue;
4492  }
4493  sDictSetTiny(&(self->d), e->key, e->data);
4494  }
4495  }
4496  return(self);
4497 }
4498 
4499 internal smallDictt* appendNSmashSmallDict(smallDictt *self, smallDictt *smallDict) {
4500  smallDictt *r = NULL;
4501 
4502  r = appendSmallDict(self, smallDict);
4503  if (r) {
4504  smashO(smallDict);
4505  }
4506  return(r);
4507 }
4508 
4509 internal bool equalSmallDictBase(smallDictt* self, baset* p2) {
4510 
4511  if (!p2) {
4512  return(false);
4513  }
4514 
4515  if (!isOType(p2, "smallDict")) {
4516  return(false);
4517  }
4518  return(equalSmallDict(self, (smallDictt *) p2));
4519 }
4520 
4521 internal bool equalSmallDictSmallJson(smallDictt* self, smallJsont* p2) {
4522 
4523  // sanity checks
4524  if (!p2) {
4525  return(false);
4526  }
4527 
4528  if (checkObjectTypes && !isOSmallJson(p2)) {
4529  return(false);
4530  }
4531 
4532  const char *type = getTopTypeO(p2);
4533 
4534  if (!eqS(type,"dict")) {
4535  return(false);
4536  }
4537 
4538  return(p2->f->equalSmallDict(p2, self));
4539 }
4540 
4541 internal bool equalSmallDict(smallDictt* self, smallDictt* p2) {
4542 
4543  if (!self->d || !p2) {
4544  return(false);
4545  }
4546 
4547  if (checkObjectTypes && !isOSmallDict(p2)) {
4548  return(false);
4549  }
4550 
4551  if (!p2->d) {
4552  return(false);
4553  }
4554 
4555  if (lenSmallDict(self) != lenSmallDict(p2)) {
4556  // different key counts in self and p2
4557  return(false);
4558  }
4559 
4560 
4561  //TODO - sort keys, use binary search
4562  forEachSDict(self->d, e) {
4563  if (e->key) {
4564  bool foundK = false;
4565  forEachSDict(p2->d, E) {
4566  if (E->key) {
4567  if (strEq(e->key, E->key)) {
4568  foundK = true;
4569  char *s = sToString(e->data);
4570  char *S = sToString(E->data);
4571  if (!strEq(s, S)) {
4572  freeManyS(s, S);
4573  return(false);
4574  }
4575  freeManyS(s, S);
4576  break;
4577  }
4578  }
4579  }
4580  if (!foundK) {
4581  return(false);
4582  }
4583  }
4584  }
4585  return(true);
4586 }
4587 
4588 internal bool icEqualSmallDictBase(smallDictt* self, baset* p2) {
4589 
4590  if (!p2) {
4591  return(false);
4592  }
4593 
4594  if (!isOType(p2, "smallDict")) {
4595  return(false);
4596  }
4597  return(icEqualSmallDict(self, (smallDictt *) p2));
4598 }
4599 
4600 internal bool icEqualSmallDictSmallJson(smallDictt* self, smallJsont* p2) {
4601 
4602  // sanity checks
4603  if (!p2) {
4604  return(false);
4605  }
4606 
4607  if (checkObjectTypes && !isOSmallJson(p2)) {
4608  return(false);
4609  }
4610 
4611  const char *type = getTopTypeO(p2);
4612 
4613  if (!eqS(type,"dict")) {
4614  return(false);
4615  }
4616 
4617  return(p2->f->icEqualSmallDict(p2, self));
4618 }
4619 
4620 internal bool icEqualSmallDict(smallDictt* self, smallDictt* p2) {
4621 
4622  if (!self->d || !p2) {
4623  return(false);
4624  }
4625 
4626  if (checkObjectTypes && !isOSmallDict(p2)) {
4627  return(false);
4628  }
4629 
4630  if (!p2->d) {
4631  return(false);
4632  }
4633 
4634  if (lenSmallDict(self) != lenSmallDict(p2)) {
4635  // different key counts in self and p2
4636  return(false);
4637  }
4638 
4639 
4640  //TODO - sort keys, use binary search
4641  forEachSDict(self->d, e) {
4642  if (e->key) {
4643  bool foundK = false;
4644  forEachSDict(p2->d, E) {
4645  if (E->key) {
4646  if (eqS(e->key, E->key)) {
4647  foundK = true;
4648  char *s = sToString(e->data);
4649  char *S = sToString(E->data);
4650  if (!icEqS(s, S)) {
4651  freeManyS(s, S);
4652  return(false);
4653  }
4654  freeManyS(s, S);
4655  break;
4656  }
4657  }
4658  }
4659  if (!foundK) {
4660  return(false);
4661  }
4662  }
4663  }
4664  return(true);
4665 }
4666 
4667 
4668 internal size_t lenSmallDict(smallDictt *self) {
4669  size_t len;
4670 
4671  if (!self->d || !self->d->count) {
4672  return(0);
4673  }
4674 
4675  len = 0;
4676  forEachSDict(self->d, e) {
4677  if (e->key) {
4678  len++;
4679  }
4680  }
4681 
4682  return(len);
4683 }
4684 
4685 internal smallDictt* emptySmallDict(smallDictt *self) {
4686 
4687  freeSmallDict(self);
4688  return(self);
4689 }
4690 
4691 internal bool isEmptySmallDict(smallDictt *self) {
4692  size_t len;
4693 
4694  len = lenSmallDict(self);
4695 
4696  if (!len) {
4697  return(true);
4698  }
4699 
4700  forEachSDict(self->d, e) {
4701  if (e->key) {
4702  return(false);
4703  }
4704  }
4705 
4706  // should not be reached, make sure a value is returned
4707  return(true);
4708 }
4709 
4710 internal void enumerateSmallDictF(smallDictt *self, void *closure, enumerateElementSmallDictFt funcElem) {
4711 
4712  if (!lenSmallDict(self)) {
4713  return;
4714  }
4715 
4716  forEachSDict(self->d, e) {
4717  if (e->key) {
4718  baset *E = toBaset(e->data);
4719  if (!funcElem(closure, e->key, E)) {
4720  if (e->data->type == CONTAINER && ((sContainert*)e->data)->dataType == SH_DT_BASET) {
4721  break;
4722  }
4723  finishO(E);
4724  break;
4725  }
4726  if (e->data->type == CONTAINER && ((sContainert*)e->data)->dataType == SH_DT_BASET) {
4727  continue;
4728  }
4729  finishO(E);
4730 }
4731  }
4732  }
4733 
4734 internal baset* iterStartSmallDict(smallDictt *self) {
4735 
4736  // reset iterIndex to a known value
4737  self->iterIndex = -1;
4738  if (isEmptySmallDict(self)) {
4739  // no iteration on empty arrays
4740  return(NULL);
4741  }
4742 
4743  // get first element
4744  range(i, self->d->count)
4745  if ((&((self->d)->elements) + i)->key) {
4746  self->iterIndex = (ssize_t)i;
4747  break;
4748  }
4749  if (self->iterElementDataType != SH_DT_BASET) {
4750  // free already created base object
4751  finishO(self->iterElement);
4752  }
4753  self->iterKey = (&((self->d)->elements) + self->iterIndex)->key;
4754  smallt *o = (&((self->d)->elements) + self->iterIndex)->data;
4755  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4756  self->iterElementDataType = SH_DT_BASET;
4757  }
4758  else {
4759  self->iterElementDataType = SH_DT_UNKNOWN;
4760  }
4761  self->iterElement = toBaset(o);
4762  return(self->iterElement);
4763 }
4764 
4765 internal const char* iterStartKeySmallDict(smallDictt *self) {
4766 
4767  // reset iterIndex to a known value
4768  self->iterIndex = -1;
4769  if (isEmptySmallDict(self)) {
4770  // no iteration on empty arrays
4771  return(NULL);
4772  }
4773 
4774  // get first element
4775  range(i, self->d->count)
4776  if ((&((self->d)->elements) + i)->key) {
4777  self->iterIndex = (ssize_t)i;
4778  break;
4779  }
4780  if (self->iterElementDataType != SH_DT_BASET) {
4781  // free already created base object
4782  finishO(self->iterElement);
4783  }
4784  self->iterKey = (&((self->d)->elements) + self->iterIndex)->key;
4785  smallt *o = (&((self->d)->elements) + self->iterIndex)->data;
4786  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4787  self->iterElementDataType = SH_DT_BASET;
4788  }
4789  else {
4790  self->iterElementDataType = SH_DT_UNKNOWN;
4791  }
4792  self->iterElement = toBaset(o);
4793  return(self->iterKey);
4794 }
4795 
4796 internal baset* iterNextSmallDict(smallDictt *self) {
4797 
4798  if (self->iterIndex == -1) {
4799  // the iteration hasn't started
4800  return(NULL);
4801  }
4802  // get next element
4803  self->iterIndex++;
4804  if (self->iterElementDataType != SH_DT_BASET) {
4805  // free already created base object
4806  finishO(self->iterElement);
4807  }
4808  rangeFrom(i, (size_t)self->iterIndex, self->d->count) {
4809  if ((&((self->d)->elements) + i)->key) {
4810  self->iterIndex = (ssize_t)i;
4811  break;
4812  }
4813  if (!(&((self->d)->elements) + i)->key && (i == (self->d->count -1))) {
4814  // last element is null, finish iteration
4815  self->iterIndex = self->d->count;
4816  }
4817  }
4818  if ((self->iterIndex >= self->d->count)) {
4819  // the index is outside the array, the iteration is finished
4820  self->iterIndex = -1;
4821  return(NULL);
4822  }
4823  self->iterKey = (&((self->d)->elements) + self->iterIndex)->key;
4824  smallt *o = (&((self->d)->elements) + self->iterIndex)->data;
4825  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4826  self->iterElementDataType = SH_DT_BASET;
4827  }
4828  else {
4829  self->iterElementDataType = SH_DT_UNKNOWN;
4830  }
4831  self->iterElement = toBaset(o);
4832  return(self->iterElement);
4833 }
4834 
4835 internal const char* iterNextKeySmallDict(smallDictt *self) {
4836 
4837  if (self->iterIndex == -1) {
4838  // the iteration hasn't started
4839  return(NULL);
4840  }
4841  // get next element
4842  self->iterIndex++;
4843  if (self->iterElementDataType != SH_DT_BASET) {
4844  // free already created base object
4845  finishO(self->iterElement);
4846  }
4847  rangeFrom(i, (size_t)self->iterIndex, self->d->count) {
4848  if ((&((self->d)->elements) + i)->key) {
4849  self->iterIndex = (ssize_t)i;
4850  break;
4851  }
4852  if (!(&((self->d)->elements) + i)->key && (i == (self->d->count -1))) {
4853  // last element is null, finish iteration
4854  self->iterIndex = self->d->count;
4855  }
4856  }
4857  if ((self->iterIndex >= self->d->count)) {
4858  // the index is outside the array, the iteration is finished
4859  self->iterIndex = -1;
4860  return(NULL);
4861  }
4862  self->iterKey = (&((self->d)->elements) + self->iterIndex)->key;
4863  smallt *o = (&((self->d)->elements) + self->iterIndex)->data;
4864  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4865  self->iterElementDataType = SH_DT_BASET;
4866  }
4867  else {
4868  self->iterElementDataType = SH_DT_UNKNOWN;
4869  }
4870  self->iterElement = toBaset(o);
4871  return(self->iterKey);
4872 }
4873 
4874 internal baset* iterElementSmallDict(smallDictt *self) {
4875 
4876  return(self->iterElement);
4877 }
4878 
4879 internal const char* iterKeySmallDict(smallDictt *self) {
4880 
4881  return(self->iterKey);
4882 }
4883 
4884 internal smallDictt* zipSmallDict(smallDictt *self, smallArrayt *keys, smallArrayt *values) {
4885  size_t len;
4886  uint32_t count;
4887 
4888  if (!keys || !values) {
4889  return(NULL);
4890  }
4891 
4892  if (checkObjectTypes && (!isOSmallArray(keys) || !isOSmallArray(values))) {
4893  return(NULL);
4894  }
4895 
4896  if (!keys->f->len(keys) || !values->f->len(values)) {
4897  return(self);
4898  }
4899 
4900  len = MIN(keys->f->len(keys), values->f->len(values));
4901 
4902  count = 0;
4903 
4904  forEachSmallArray(keys, K) {
4905  if (!isOSmallString(K)) {
4906  finishO(K);
4907  return(NULL);
4908  }
4909  sDictSetTiny(&(self->d), ssGet(K), sArrayGetTiny(values->a, count));
4910  finishO(K);
4911  count++;
4912  if (count == len) {
4913  break;
4914  }
4915  }
4916 
4917  //if keys->f->len(keys) != values->f->len(values)
4918  // return 0
4919  //else
4920  // return 1
4921  return(self);
4922 }
4923 
4924 internal smallDictt* zipSmallJsonSmallDict(smallDictt *self, smallArrayt *keys, smallJsont *values) {
4925 
4926  if (!keys || !values) {
4927  return(NULL);
4928  }
4929 
4930  if (checkObjectTypes && !isOSmallArray(keys)) {
4931  return(NULL);
4932  }
4933 
4934  if (checkObjectTypes && !isOSmallJson(values)) {
4935  return(NULL);
4936  }
4937 
4938  const char *type = getTopTypeO(values);
4939 
4940  if (!eqS(type,"array")) {
4941  return(NULL);
4942  }
4943 
4944  createSmallArray(a);
4945  if (!a.f) {
4946  return(NULL);
4947  }
4948  setsoO(&a, (sArrayt*)getsoO(values));
4949  return(zipSmallDict(self, keys, &a));
4950 }
4951 
4952 internal smallDictt* zipSmallJsonSmallArraySmallDict(smallDictt *self, smallJsont *keys, smallArrayt *values) {
4953 
4954  if (!keys || !values) {
4955  return(NULL);
4956  }
4957 
4958  if (checkObjectTypes && !isOSmallJson(keys)) {
4959  return(NULL);
4960  }
4961 
4962  if (checkObjectTypes && !isOSmallArray(values)) {
4963  return(NULL);
4964  }
4965 
4966  const char *type = getTopTypeO(keys);
4967 
4968  if (!eqS(type,"array")) {
4969  return(NULL);
4970  }
4971 
4972  createSmallArray(a);
4973  if (!a.f) {
4974  return(NULL);
4975  }
4976  setsoO(&a, (sArrayt*)getsoO(keys));
4977  return(zipSmallDict(self, &a, values));
4978 }
4979 
4980 internal smallDictt* zipSmallJsonSmallJsonSmallDict(smallDictt *self, smallJsont *keys, smallJsont *values) {
4981 
4982  if (!keys || !values) {
4983  return(NULL);
4984  }
4985 
4986  if (checkObjectTypes && !isOSmallJson(keys)) {
4987  return(NULL);
4988  }
4989 
4990  if (checkObjectTypes && !isOSmallJson(values)) {
4991  return(NULL);
4992  }
4993 
4994  const char *type = getTopTypeO(keys);
4995 
4996  if (!eqS(type,"array")) {
4997  return(NULL);
4998  }
4999 
5000  type = getTopTypeO(values);
5001 
5002  if (!eqS(type,"array")) {
5003  return(NULL);
5004  }
5005 
5006  createSmallArray(a);
5007  if (!a.f) {
5008  return(NULL);
5009  }
5010  createSmallArray(b);
5011  if (!b.f) {
5012  return(NULL);
5013  }
5014  setsoO(&a, (sArrayt*)getsoO(keys));
5015  setsoO(&b, (sArrayt*)getsoO(values));
5016  return(zipSmallDict(self, &a, &b));
5017 }
5018 
5019 internal smallDictt* zipSmallJsonVArraySmallDict(smallDictt *self, smallJsont *keys, char** values) {
5020 
5021  if (!keys || !values) {
5022  return(NULL);
5023  }
5024 
5025  if (checkObjectTypes && !isOSmallJson(keys)) {
5026  return(NULL);
5027  }
5028 
5029  const char *type = getTopTypeO(keys);
5030 
5031  if (!eqS(type,"array")) {
5032  return(NULL);
5033  }
5034 
5035  createSmallArray(a);
5036  if (!a.f) {
5037  return(NULL);
5038  }
5039  setsoO(&a, (sArrayt*)getsoO(keys));
5040  return(zipVArraySmallDict(self, &a, values));
5041 }
5042 
5043 internal smallDictt* zipSmallJsonVCArraySmallDict(smallDictt *self, smallJsont *keys, const char** values) {
5044 
5045  if (!keys || !values) {
5046  return(NULL);
5047  }
5048 
5049  if (checkObjectTypes && !isOSmallJson(keys)) {
5050  return(NULL);
5051  }
5052 
5053  const char *type = getTopTypeO(keys);
5054 
5055  if (!eqS(type,"array")) {
5056  return(NULL);
5057  }
5058 
5059  createSmallArray(a);
5060  if (!a.f) {
5061  return(NULL);
5062  }
5063  setsoO(&a, (sArrayt*)getsoO(keys));
5064  return(zipVCArraySmallDict(self, &a, values));
5065 }
5066 
5067 internal smallDictt* zipArraySmallDict(smallDictt *self, char** keys, smallArrayt *values) {
5068  size_t len;
5069  uint32_t count;
5070 
5071  if (!keys || !values) {
5072  return(NULL);
5073  }
5074 
5075  if (checkObjectTypes && !isOSmallArray(values)) {
5076  return(NULL);
5077  }
5078 
5079  if (!listLengthS(keys) || !values->f->len(values)) {
5080  return(self);
5081  }
5082 
5083  len = MIN(listLengthS(keys), values->f->len(values));
5084 
5085  count = 0;
5086 
5087  forEachS(keys, k) {
5088  sDictSetTiny(&(self->d), k, sArrayGetTiny(values->a, count));
5089  count++;
5090  if (count == len) {
5091  break;
5092  }
5093  }
5094 
5095  //if keys->f->len(keys) != values->f->len(values)
5096  // return 0
5097  //else
5098  // return 1
5099  return(self);
5100 }
5101 
5102 internal smallDictt* zipCArraySmallDict(smallDictt *self, const char** keys, smallArrayt *values) {
5103  size_t len;
5104  uint32_t count;
5105 
5106  if (!keys || !values) {
5107  return(NULL);
5108  }
5109 
5110  if (checkObjectTypes && !isOSmallArray(values)) {
5111  return(NULL);
5112  }
5113 
5114  if (!listLengthCS(keys) || !values->f->len(values)) {
5115  return(self);
5116  }
5117 
5118  len = MIN(listLengthCS(keys), values->f->len(values));
5119 
5120  count = 0;
5121 
5122  forEachCS(keys, k) {
5123  sDictSetTiny(&(self->d), k, sArrayGetTiny(values->a, count));
5124  count++;
5125  if (count == len) {
5126  break;
5127  }
5128  }
5129 
5130  //if keys->f->len(keys) != values->f->len(values)
5131  // return 0
5132  //else
5133  // return 1
5134  return(self);
5135 }
5136 
5137 internal smallDictt* zipArraySmallJsonSmallDict(smallDictt *self, char** keys, smallJsont *values) {
5138 
5139  if (!keys || !values) {
5140  return(NULL);
5141  }
5142 
5143  if (checkObjectTypes && !isOSmallJson(values)) {
5144  return(NULL);
5145  }
5146 
5147  const char *type = getTopTypeO(values);
5148 
5149  if (!eqS(type,"array")) {
5150  return(NULL);
5151  }
5152 
5153  createSmallArray(a);
5154  if (!a.f) {
5155  return(NULL);
5156  }
5157  setsoO(&a, (sArrayt*)getsoO(values));
5158  return(zipArraySmallDict(self, keys, &a));
5159 }
5160 
5161 internal smallDictt* zipCArraySmallJsonSmallDict(smallDictt *self, const char** keys, smallJsont *values) {
5162 
5163  if (!keys || !values) {
5164  return(NULL);
5165  }
5166 
5167  if (checkObjectTypes && !isOSmallJson(values)) {
5168  return(NULL);
5169  }
5170 
5171  const char *type = getTopTypeO(values);
5172 
5173  if (!eqS(type,"array")) {
5174  return(NULL);
5175  }
5176 
5177  createSmallArray(a);
5178  if (!a.f) {
5179  return(NULL);
5180  }
5181  setsoO(&a, (sArrayt*)getsoO(values));
5182  return(zipCArraySmallDict(self, keys, &a));
5183 }
5184 
5185 internal smallDictt* zipArrayArraySmallDict(smallDictt *self, char** keys, char** values) {
5186  size_t len;
5187  size_t count;
5188 
5189  if (!keys || !values) {
5190  return(NULL);
5191  }
5192 
5193  if (!listLengthS(keys) || !listLengthS(values)) {
5194  return(self);
5195  }
5196 
5197  len = MIN(listLengthS(keys), listLengthS(values));
5198 
5199  count = 0;
5200 
5201  smallt *e;
5202  forEachS(keys, k) {
5203  e = (smallt *) allocSStringTiny(values[count]);
5204  if (!e) {
5205  return(NULL);
5206  }
5207  sDictSetTiny(&(self->d), k, e);
5208  count++;
5209  if (count == len) {
5210  break;
5211  }
5212  }
5213 
5214  //if keys->f->len(keys) != values->f->len(values)
5215  // return 0
5216  //else
5217  // return 1
5218  return(self);
5219 }
5220 
5221 internal smallDictt* zipCArrayArraySmallDict(smallDictt *self, const char** keys, char** values) {
5222  size_t len;
5223  size_t count;
5224 
5225  if (!keys || !values) {
5226  return(NULL);
5227  }
5228 
5229  if (!listLengthCS(keys) || !listLengthS(values)) {
5230  return(self);
5231  }
5232 
5233  len = MIN(listLengthCS(keys), listLengthS(values));
5234 
5235  count = 0;
5236 
5237  smallt *e;
5238  forEachCS(keys, k) {
5239  e = (smallt *) allocSStringTiny(values[count]);
5240  if (!e) {
5241  return(NULL);
5242  }
5243  sDictSetTiny(&(self->d), k, e);
5244  count++;
5245  if (count == len) {
5246  break;
5247  }
5248  }
5249 
5250  //if keys->f->len(keys) != values->f->len(values)
5251  // return 0
5252  //else
5253  // return 1
5254  return(self);
5255 }
5256 
5257 internal smallDictt* zipArrayCArraySmallDict(smallDictt *self, char** keys, const char** values) {
5258  size_t len;
5259  size_t count;
5260 
5261  if (!keys || !values) {
5262  return(NULL);
5263  }
5264 
5265  if (!listLengthS(keys) || !listLengthCS(values)) {
5266  return(self);
5267  }
5268 
5269  len = MIN(listLengthS(keys), listLengthCS(values));
5270 
5271  count = 0;
5272 
5273  smallt *e;
5274  forEachS(keys, k) {
5275  e = (smallt *) allocSStringTiny(values[count]);
5276  if (!e) {
5277  return(NULL);
5278  }
5279  sDictSetTiny(&(self->d), k, e);
5280  count++;
5281  if (count == len) {
5282  break;
5283  }
5284  }
5285 
5286  //if keys->f->len(keys) != values->f->len(values)
5287  // return 0
5288  //else
5289  // return 1
5290  return(self);
5291 }
5292 
5293 internal smallDictt* zipCArrayCArraySmallDict(smallDictt *self, const char** keys, const char** values) {
5294  size_t len;
5295  size_t count;
5296 
5297  if (!keys || !values) {
5298  return(NULL);
5299  }
5300 
5301  if (!listLengthCS(keys) || !listLengthCS(values)) {
5302  return(self);
5303  }
5304 
5305  len = MIN(listLengthCS(keys), listLengthCS(values));
5306 
5307  count = 0;
5308 
5309  smallt *e;
5310  forEachCS(keys, k) {
5311  e = (smallt *) allocSStringTiny(values[count]);
5312  if (!e) {
5313  return(NULL);
5314  }
5315  sDictSetTiny(&(self->d), k, e);
5316  count++;
5317  if (count == len) {
5318  break;
5319  }
5320  }
5321 
5322  //if keys->f->len(keys) != values->f->len(values)
5323  // return 0
5324  //else
5325  // return 1
5326  return(self);
5327 }
5328 
5329 internal smallDictt* zipVArraySmallDict(smallDictt *self, smallArrayt *keys, char** values) {
5330  size_t len;
5331  size_t count;
5332 
5333  if (!keys || !values) {
5334  return(NULL);
5335  }
5336 
5337  if (checkObjectTypes && !isOSmallArray(keys)) {
5338  return(NULL);
5339  }
5340 
5341  if (!keys->f->len(keys) || !listLengthS(values)) {
5342  return(self);
5343  }
5344 
5345  len = MIN(keys->f->len(keys), listLengthS(values));
5346 
5347  count = 0;
5348 
5349  smallt *e;
5350  forEachSmallArray(keys, K) {
5351  if (!isOSmallString(K)) {
5352  finishO(K);
5353  return(NULL);
5354  }
5355  e = (smallt *) allocSStringTiny(values[count]);
5356  if (!e) {
5357  return(NULL);
5358  }
5359  sDictSetTiny(&(self->d), ssGet(K), e);
5360  finishO(K);
5361  count++;
5362  if (count == len) {
5363  break;
5364  }
5365  }
5366 
5367  //if keys->f->len(keys) != values->f->len(values)
5368  // return 0
5369  //else
5370  // return 1
5371  return(self);
5372 }
5373 
5374 internal smallDictt* zipVCArraySmallDict(smallDictt *self, smallArrayt *keys, const char** values) {
5375  size_t len;
5376  size_t count;
5377 
5378  if (!keys || !values) {
5379  return(NULL);
5380  }
5381 
5382  if (checkObjectTypes && !isOSmallArray(keys)) {
5383  return(NULL);
5384  }
5385 
5386  if (!keys->f->len(keys) || !listLengthCS(values)) {
5387  return(self);
5388  }
5389 
5390  len = MIN(keys->f->len(keys), listLengthCS(values));
5391 
5392  count = 0;
5393 
5394  smallt *e;
5395  forEachSmallArray(keys, K) {
5396  if (!isOSmallString(K)) {
5397  finishO(K);
5398  return(NULL);
5399  }
5400  e = (smallt *) allocSStringTiny(values[count]);
5401  if (!e) {
5402  return(NULL);
5403  }
5404  sDictSetTiny(&(self->d), ssGet(K), e);
5405  finishO(K);
5406  count++;
5407  if (count == len) {
5408  break;
5409  }
5410  }
5411 
5412  //if keys->f->len(keys) != values->f->len(values)
5413  // return 0
5414  //else
5415  // return 1
5416  return(self);
5417 }
5418 
5419 internal smallDictt* fromArraySmallDict(smallDictt *self, smallArrayt *items) {
5420 
5421  if (!items) {
5422  return(NULL);
5423  }
5424 
5425  if (checkObjectTypes && !isOSmallArray(items)) {
5426  return(NULL);
5427  }
5428 
5429  enumerateSmallArray(items, E, i) {
5430  if (!isOType(E, "smallArray")) {
5431  goto cont;
5432  }
5433  cast(smallArrayt*, a, E);
5434  if (lenO(a) != 2) {
5435  goto cont;
5436  }
5437  smallStringt *s = a->f->getAtSmallString(a, 0);
5438  if (!isOType(s, "smallString")) {
5439  finishO(s);
5440  goto cont;
5441  }
5442  setNFreeSmallDict(self, ssGet(s), a->f->get(a, 1));
5443  finishO(s);
5444  removeElemO(a, 1);
5445  delElemO(items, (int64_t)i);
5446  cont:
5447  finishO(E);
5448  }
5449  return(self);
5450 }
5451 
5452 internal smallArrayt* toArraySmallDict(smallDictt *self) {
5453 
5454  if (!lenSmallDict(self)) {
5455  return(NULL);
5456  }
5457 
5458  createAllocateSmallArray(r);
5459  if (!r) {
5460  return(NULL);
5461  }
5462 
5463  forEachSDict(self->d, e) {
5464  if (e->key) {
5465  createAllocateSmallArray(a);
5466  if (!a) {
5467  terminateO(r);
5468  return(NULL);
5469  }
5470  a->f->pushS(a, e->key);
5471  pushNFreeO(a, toBaset(e->data));
5472  r->f->pushNFreeArray(r, a);
5473  }
5474  }
5475  return(r);
5476 }
5477 
5478 internal bool writeFileSmallDict(smallDictt *self, const char *filePath) {
5479 
5480  if (!filePath || isBlankS(filePath)) {
5481  return(false);
5482  }
5483  char *s = toStringSmallDict(self);
5484  bool r = writeFileS(filePath, s);
5485  free(s);
5486  return(r);
5487 }
5488 
5489 internal bool writeFileSmallJsonSmallDict(smallDictt *self, smallJsont *filePath) {
5490 
5491  if (!filePath) {
5492  return(false);
5493  }
5494 
5495  if (checkObjectTypes && !isOSmallJson(filePath)) {
5496  return(false);
5497  }
5498 
5499  const char *type = getTopTypeO(filePath);
5500 
5501  if (!eqS(type,"string")) {
5502  return(false);
5503  }
5504 
5505  return(writeFileSmallDict(self, getTopSO(filePath)));
5506 }
5507 
5508 internal bool writeFileSmallStringSmallDict(smallDictt *self, smallStringt *filePath) {
5509 
5510  if (!filePath) {
5511  return(false);
5512  }
5513 
5514  if (checkObjectTypes && !isOSmallString(filePath)) {
5515  return(false);
5516  }
5517 
5518  return(writeFileSmallDict(self, ssGet(filePath)));
5519 }
5520 
5521 internal bool writeStreamSmallDict(smallDictt *self, FILE *fp) {
5522 
5523  if (!fp) {
5524  return(false);
5525  }
5526  char *s = toStringSmallDict(self);
5527  bool r = writeStreamS(fp, s);
5528  free(s);
5529  return(r);
5530 }
5531 
5532 internal bool appendFileSmallDict(smallDictt *self, const char *filePath) {
5533 
5534  if (!filePath || isBlankS(filePath)) {
5535  return(false);
5536  }
5537  char *s = toStringSmallDict(self);
5538  bool r = appendFileS(filePath, s);
5539  free(s);
5540  return(r);
5541 }
5542 
5543 internal bool appendFileSmallStringSmallDict(smallDictt *self, smallStringt *filePath) {
5544 
5545  if (!filePath) {
5546  return(false);
5547  }
5548 
5549  if (checkObjectTypes && !isOSmallString(filePath)) {
5550  return(false);
5551  }
5552 
5553  return(appendFileSmallDict(self, ssGet(filePath)));
5554 }
5555 
5556 internal void logSmallDict(smallDictt *self) {
5557 
5558  if (!lenSmallDict(self)) {
5559  return;
5560  }
5561 
5562  forEachSDict(self->d, e) {
5563  if (e->key) {
5564  char *s = sToString(e->data);
5565  printf("%s: %s", e->key, s);
5566  printf("\n");
5567  free(s);
5568 }
5569  }
5570  }
5571 
5572 
5573 internal const char* typeStringSmallDict(smallDictt *self, const char *key) {
5574 
5575  if (!self->d) {
5576  return(NULL);
5577  }
5578 
5579  smallt *o = sDictGet(self->d, key);
5580 
5581  if (!o) {
5582  return(NULL);
5583  }
5584 
5585  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5586  return(NULL);
5587  }
5588  return(SMALL_TYPE_NAMES[(size_t)o->type]);
5589 }
5590 
5591 internal smallStringt* typeSmallStringSmallDict(smallDictt *self, const char *key) {
5592 
5593  const char *r = typeStringSmallDict(self, key);
5594  if (!r) {
5595  return(NULL);
5596  }
5597  return(allocSmallString(r));
5598 }
5599 
5600 internal const char* typeStringKCharSmallDict(smallDictt *self, char key) {
5601 
5602  charToS(s, key);
5603  return(typeStringSmallDict(self, s));
5604 }
5605 
5606 internal smallStringt* typeSmallStringKCharSmallDict(smallDictt *self, char key) {
5607 
5608  charToS(s, key);
5609  return(typeSmallStringSmallDict(self, s));
5610 }
5611 
5612 
5613 internal char typeSmallDict(smallDictt *self, const char *key) {
5614 
5615  if (!self->d) {
5616  return(0);
5617  }
5618 
5619  smallt *o = sDictGet(self->d, key);
5620 
5621  if (!o) {
5622  return(0);
5623  }
5624 
5625  return(o->type);
5626 }
5627 
5628 internal char typeKCharSmallDict(smallDictt *self, char key) {
5629 
5630  charToS(s, key);
5631  return(typeSmallDict(self, s));
5632 }
5633 
5634 
5635 internal smallDictt* typeStringsSmallDict(smallDictt *self) {
5636 
5637  if (!self->d) {
5638  return(NULL);
5639  }
5640 
5641  createAllocateSmallDict(r);
5642  if (!r) {
5643  return(NULL);
5644  }
5645 
5646  forEachSDict(self->d, e) {
5647  if (e->key) {
5648  if ((size_t)e->data->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5649  terminateO(r);
5650  return(NULL);
5651  }
5652  smallt *s = (smallt *)allocSStringTiny(SMALL_TYPE_NAMES[(size_t)e->data->type]);
5653  if (!s) {
5654  terminateO(r);
5655  return(NULL);
5656  }
5657  sDictPushTiny(&(r->d), e->key, s);
5658  }
5659  }
5660 
5661  return(r);
5662 }
5663 
5664 
5665 internal bool isETypeSmallDict(smallDictt *self, const char *key, const char *type) {
5666 
5667  if (!self->d or !type) {
5668  return(false);
5669  }
5670 
5671  smallt *o = sDictGet(self->d, key);
5672 
5673  if (!o) {
5674  return(false);
5675  }
5676 
5677  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5678  return(false);
5679  }
5680  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], type));
5681 }
5682 
5683 
5684 internal bool isEUndefinedSmallDict(smallDictt *self, const char *key) {
5685 
5686  if (!self->d) {
5687  return(false);
5688  }
5689 
5690  smallt *o = sDictGet(self->d, key);
5691 
5692  if (!o) {
5693  return(false);
5694  }
5695 
5696  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5697  return(false);
5698  }
5699  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "undefined"));
5700 }
5701 
5702 
5703 internal bool isEBoolSmallDict(smallDictt *self, const char *key) {
5704 
5705  if (!self->d) {
5706  return(false);
5707  }
5708 
5709  smallt *o = sDictGet(self->d, key);
5710 
5711  if (!o) {
5712  return(false);
5713  }
5714 
5715  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5716  return(false);
5717  }
5718  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "bool"));
5719 }
5720 
5721 
5722 internal bool isEContainerSmallDict(smallDictt *self, const char *key) {
5723 
5724  if (!self->d) {
5725  return(false);
5726  }
5727 
5728  smallt *o = sDictGet(self->d, key);
5729 
5730  if (!o) {
5731  return(false);
5732  }
5733 
5734  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5735  return(false);
5736  }
5737  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "container"));
5738 }
5739 
5740 
5741 internal bool isEDictSmallDict(smallDictt *self, const char *key) {
5742 
5743  if (!self->d) {
5744  return(false);
5745  }
5746 
5747  smallt *o = sDictGet(self->d, key);
5748 
5749  if (!o) {
5750  return(false);
5751  }
5752 
5753  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5754  return(false);
5755  }
5756  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "dict"));
5757 }
5758 
5759 
5760 internal bool isEDoubleSmallDict(smallDictt *self, const char *key) {
5761 
5762  if (!self->d) {
5763  return(false);
5764  }
5765 
5766  smallt *o = sDictGet(self->d, key);
5767 
5768  if (!o) {
5769  return(false);
5770  }
5771 
5772  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5773  return(false);
5774  }
5775  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "double"));
5776 }
5777 
5778 
5779 internal bool isEIntSmallDict(smallDictt *self, const char *key) {
5780 
5781  if (!self->d) {
5782  return(false);
5783  }
5784 
5785  smallt *o = sDictGet(self->d, key);
5786 
5787  if (!o) {
5788  return(false);
5789  }
5790 
5791  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5792  return(false);
5793  }
5794  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "int"));
5795 }
5796 
5797 
5798 internal bool isEStringSmallDict(smallDictt *self, const char *key) {
5799 
5800  if (!self->d) {
5801  return(false);
5802  }
5803 
5804  smallt *o = sDictGet(self->d, key);
5805 
5806  if (!o) {
5807  return(false);
5808  }
5809 
5810  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5811  return(false);
5812  }
5813  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "string"));
5814 }
5815 
5816 
5817 internal bool isEFaststringSmallDict(smallDictt *self, const char *key) {
5818 
5819  if (!self->d) {
5820  return(false);
5821  }
5822 
5823  smallt *o = sDictGet(self->d, key);
5824 
5825  if (!o) {
5826  return(false);
5827  }
5828 
5829  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5830  return(false);
5831  }
5832  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "faststring"));
5833 }
5834 
5835 
5836 internal bool isEArraySmallDict(smallDictt *self, const char *key) {
5837 
5838  if (!self->d) {
5839  return(false);
5840  }
5841 
5842  smallt *o = sDictGet(self->d, key);
5843 
5844  if (!o) {
5845  return(false);
5846  }
5847 
5848  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5849  return(false);
5850  }
5851  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "array"));
5852 }
5853 
5854 
5855 internal bool isEBytesSmallDict(smallDictt *self, const char *key) {
5856 
5857  if (!self->d) {
5858  return(false);
5859  }
5860 
5861  smallt *o = sDictGet(self->d, key);
5862 
5863  if (!o) {
5864  return(false);
5865  }
5866 
5867  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5868  return(false);
5869  }
5870  return(eqS(SMALL_TYPE_NAMES[(size_t)o->type], "bytes"));
5871 }
5872 
5873 internal bool areAllETypeSmallDict(smallDictt *self, const char *type) {
5874 
5875  if (!self->d or !type) {
5876  return(false);
5877  }
5878 
5879  size_t len = lenSmallDict(self);
5880 
5881  if (!len) {
5882  return(false);
5883  }
5884 
5885  bool r = true;
5886  forEachSDict(self->d, e) {
5887  if (e->key) {
5888  smallt *o = sDictGetTiny(self->d, e->key);
5889 
5890  if (!o) {
5891  r = false;
5892  break;
5893  }
5894  if ((size_t)o->type >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
5895  r = false;
5896  break;
5897  }
5898  if (!eqS(SMALL_TYPE_NAMES[(size_t)o->type], type)) {
5899  r = false;
5900  break;
5901  }
5902  }
5903  }
5904 
5905  return(r);
5906 }
5907 
5908 
5909 internal bool areAllEUndefinedSmallDict(smallDictt *self) {
5910 
5911  return(areAllETypeSmallDict(self, "undefined"));
5912 }
5913 
5914 
5915 internal bool areAllEBoolSmallDict(smallDictt *self) {
5916 
5917  return(areAllETypeSmallDict(self, "bool"));
5918 }
5919 
5920 
5921 internal bool areAllEContainerSmallDict(smallDictt *self) {
5922 
5923  return(areAllETypeSmallDict(self, "container"));
5924 }
5925 
5926 
5927 internal bool areAllEDictSmallDict(smallDictt *self) {
5928 
5929  return(areAllETypeSmallDict(self, "dict"));
5930 }
5931 
5932 
5933 internal bool areAllEDoubleSmallDict(smallDictt *self) {
5934 
5935  return(areAllETypeSmallDict(self, "double"));
5936 }
5937 
5938 
5939 internal bool areAllEIntSmallDict(smallDictt *self) {
5940 
5941  return(areAllETypeSmallDict(self, "int"));
5942 }
5943 
5944 
5945 internal bool areAllEStringSmallDict(smallDictt *self) {
5946 
5947  return(areAllETypeSmallDict(self, "string"));
5948 }
5949 
5950 
5951 internal bool areAllEFaststringSmallDict(smallDictt *self) {
5952 
5953  return(areAllETypeSmallDict(self, "faststring"));
5954 }
5955 
5956 
5957 internal bool areAllEArraySmallDict(smallDictt *self) {
5958 
5959  return(areAllETypeSmallDict(self, "array"));
5960 }
5961 
5962 
5963 internal bool areAllEBytesSmallDict(smallDictt *self) {
5964 
5965  return(areAllETypeSmallDict(self, "bytes"));
5966 }
5967 
5968 
5969 smallDictt* allocSmallDictG(smallDictt *self UNUSED) {
5970 
5971  return(allocSmallDict());
5972 }
5973 
5974 smallDictt* duplicateSmallDictG (smallDictt *self) {
5975 
5976  return(self->f->duplicate(self));
5977 }
5978 
5979 void freeSmallDictG (smallDictt *self) {self->f->free(self);}
5980 
5981 smallDictt* setSmallDictG (smallDictt *self, const char *key, baset *value) {
5982 
5983  return(self->f->set(self, key, value));
5984 }
5985 
5986 
5987 baset* getSmallDictG (smallDictt *self, baset* retType UNUSED, const char *key) {
5988 
5989  return(self->f->get(self,key));
5990 }
5991 
5992 undefinedt* getUndefinedSmallDictG (smallDictt *self, undefinedt* retType UNUSED, const char *key) {
5993 
5994  return(self->f->getUndefined(self,key));
5995 }
5996 
5997 bool getBoolSmallDictG (smallDictt *self, bool retType UNUSED, const char *key) {
5998 
5999  return(self->f->getBool(self,key));
6000 }
6001 
6002 bool* getBoolPSmallDictG (smallDictt *self, bool* retType UNUSED, const char *key) {
6003 
6004  return(self->f->getBoolP(self,key));
6005 }
6006 
6007 double getDoubleSmallDictG (smallDictt *self, double retType UNUSED, const char *key) {
6008 
6009  return(self->f->getDouble(self,key));
6010 }
6011 
6012 double* getDoublePSmallDictG (smallDictt *self, double* retType UNUSED, const char *key) {
6013 
6014  return(self->f->getDoubleP(self,key));
6015 }
6016 
6017 int64_t getIntSmallDictG (smallDictt *self, int64_t retType UNUSED, const char *key) {
6018 
6019  return(self->f->getInt(self,key));
6020 }
6021 
6022 int64_t* getIntPSmallDictG (smallDictt *self, int64_t* retType UNUSED, const char *key) {
6023 
6024  return(self->f->getIntP(self,key));
6025 }
6026 
6027 int32_t getInt32SmallDictG (smallDictt *self, int32_t retType UNUSED, const char *key) {
6028 
6029  return(self->f->getInt32(self,key));
6030 }
6031 
6032 int32_t* getInt32PSmallDictG (smallDictt *self, int32_t* retType UNUSED, const char *key) {
6033 
6034  return(self->f->getInt32P(self,key));
6035 }
6036 
6037 uint64_t getUintSmallDictG (smallDictt *self, uint64_t retType UNUSED, const char *key) {
6038 
6039  return(self->f->getUint(self,key));
6040 }
6041 
6042 uint64_t* getUintPSmallDictG (smallDictt *self, uint64_t* retType UNUSED, const char *key) {
6043 
6044  return(self->f->getUintP(self,key));
6045 }
6046 
6047 uint32_t getUint32SmallDictG (smallDictt *self, uint32_t retType UNUSED, const char *key) {
6048 
6049  return(self->f->getUint32(self,key));
6050 }
6051 
6052 uint32_t* getUint32PSmallDictG (smallDictt *self, uint32_t* retType UNUSED, const char *key) {
6053 
6054  return(self->f->getUint32P(self,key));
6055 }
6056 
6057 char* getSSmallDictG (smallDictt *self, char* retType UNUSED, const char *key) {
6058 
6059  return(self->f->getS(self,key));
6060 }
6061 
6062 smallDictt* getDictSmallDictG (smallDictt *self, smallDictt* retType UNUSED, const char *key) {
6063 
6064  return(self->f->getDict(self,key));
6065 }
6066 
6067 smallArrayt* getArraySmallDictG (smallDictt *self, smallArrayt* retType UNUSED, const char *key) {
6068 
6069  return(self->f->getArray(self,key));
6070 }
6071 
6072 smallBoolt* getSmallBoolSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, const char *key) {
6073 
6074  return(self->f->getSmallBool(self,key));
6075 }
6076 
6077 smallBytest* getSmallBytesSmallDictG (smallDictt *self, smallBytest* retType UNUSED, const char *key) {
6078 
6079  return(self->f->getSmallBytes(self,key));
6080 }
6081 
6082 smallDoublet* getSmallDoubleSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, const char *key) {
6083 
6084  return(self->f->getSmallDouble(self,key));
6085 }
6086 
6087 smallIntt* getSmallIntSmallDictG (smallDictt *self, smallIntt* retType UNUSED, const char *key) {
6088 
6089  return(self->f->getSmallInt(self,key));
6090 }
6091 
6092 smallJsont* getSmallJsonSmallDictG(smallDictt *self, smallJsont* retType UNUSED, const char *key) {
6093 
6094  return(self->f->getSmallJson(self,key));
6095 }
6096 
6097 smallStringt* getSmallStringSmallDictG (smallDictt *self, smallStringt* retType UNUSED, const char *key) {
6098 
6099  return(self->f->getSmallString(self,key));
6100 }
6101 
6102 void* getVoidSmallDictG (smallDictt *self, void* retType UNUSED, const char *key) {
6103 
6104  return(self->f->getVoid(self,key));
6105 }
6106 
6107 smallContainert* getSmallContainerSmallDictG(smallDictt *self, smallContainert* retType UNUSED, const char *key) {
6108 
6109  return(self->f->getSmallContainer(self,key));
6110 }
6111 
6112 baset* getKCharSmallDictG (smallDictt *self, baset* retType UNUSED, char key) {
6113 
6114  return(self->f->getKChar(self, key));
6115 }
6116 
6117 undefinedt* getUndefinedKCharSmallDictG (smallDictt *self, undefinedt* retType UNUSED, char key) {
6118 
6119  return(self->f->getUndefinedKChar(self, key));
6120 }
6121 
6122 bool getBoolKCharSmallDictG (smallDictt *self, bool retType UNUSED, char key) {
6123 
6124  return(self->f->getBoolKChar(self, key));
6125 }
6126 
6127 bool* getBoolPKCharSmallDictG (smallDictt *self, bool* retType UNUSED, char key) {
6128 
6129  return(self->f->getBoolPKChar(self, key));
6130 }
6131 
6132 double getDoubleKCharSmallDictG (smallDictt *self, double retType UNUSED, char key) {
6133 
6134  return(self->f->getDoubleKChar(self, key));
6135 }
6136 
6137 double* getDoublePKCharSmallDictG (smallDictt *self, double* retType UNUSED, char key) {
6138 
6139  return(self->f->getDoublePKChar(self, key));
6140 }
6141 
6142 int64_t getIntKCharSmallDictG (smallDictt *self, int64_t retType UNUSED, char key) {
6143 
6144  return(self->f->getIntKChar(self, key));
6145 }
6146 
6147 int64_t* getIntPKCharSmallDictG (smallDictt *self, int64_t* retType UNUSED, char key) {
6148 
6149  return(self->f->getIntPKChar(self, key));
6150 }
6151 
6152 int32_t getInt32KCharSmallDictG (smallDictt *self, int32_t retType UNUSED, char key) {
6153 
6154  return(self->f->getInt32KChar(self, key));
6155 }
6156 
6157 int32_t* getInt32PKCharSmallDictG (smallDictt *self, int32_t* retType UNUSED, char key) {
6158 
6159  return(self->f->getInt32PKChar(self, key));
6160 }
6161 
6162 uint64_t getUintKCharSmallDictG (smallDictt *self, uint64_t retType UNUSED, char key) {
6163 
6164  return(self->f->getUintKChar(self, key));
6165 }
6166 
6167 uint64_t* getUintPKCharSmallDictG (smallDictt *self, uint64_t* retType UNUSED, char key) {
6168 
6169  return(self->f->getUintPKChar(self, key));
6170 }
6171 
6172 uint32_t getUint32KCharSmallDictG (smallDictt *self, uint32_t retType UNUSED, char key) {
6173 
6174  return(self->f->getUint32KChar(self, key));
6175 }
6176 
6177 uint32_t* getUint32PKCharSmallDictG (smallDictt *self, uint32_t* retType UNUSED, char key) {
6178 
6179  return(self->f->getUint32PKChar(self, key));
6180 }
6181 
6182 char* getSKCharSmallDictG (smallDictt *self, char* retType UNUSED, char key) {
6183 
6184  return(self->f->getSKChar(self, key));
6185 }
6186 
6187 smallDictt* getDictKCharSmallDictG (smallDictt *self, smallDictt* retType UNUSED, char key) {
6188 
6189  return(self->f->getDictKChar(self, key));
6190 }
6191 
6192 smallArrayt* getArrayKCharSmallDictG (smallDictt *self, smallArrayt* retType UNUSED, char key) {
6193 
6194  return(self->f->getArrayKChar(self, key));
6195 }
6196 
6197 smallBoolt* getSmallBoolKCharSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, char key) {
6198 
6199  return(self->f->getSmallBoolKChar(self, key));
6200 }
6201 
6202 smallBytest* getSmallBytesKCharSmallDictG (smallDictt *self, smallBytest* retType UNUSED, char key) {
6203 
6204  return(self->f->getSmallBytesKChar(self, key));
6205 }
6206 
6207 smallDoublet* getSmallDoubleKCharSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, char key) {
6208 
6209  return(self->f->getSmallDoubleKChar(self, key));
6210 }
6211 
6212 smallIntt* getSmallIntKCharSmallDictG (smallDictt *self, smallIntt* retType UNUSED, char key) {
6213 
6214  return(self->f->getSmallIntKChar(self, key));
6215 }
6216 
6217 smallJsont* getSmallJsonKCharSmallDictG(smallDictt *self, smallJsont* retType UNUSED, char key) {
6218 
6219  return(self->f->getSmallJsonKChar(self, key));
6220 }
6221 
6222 smallStringt* getSmallStringKCharSmallDictG (smallDictt *self, smallStringt* retType UNUSED, char key) {
6223 
6224  return(self->f->getSmallStringKChar(self, key));
6225 }
6226 
6227 void* getVoidKCharSmallDictG (smallDictt *self, void* retType UNUSED, char key) {
6228 
6229  return(self->f->getVoidKChar(self, key));
6230 }
6231 
6232 smallContainert* getSmallContainerKCharSmallDictG(smallDictt *self, smallContainert* retType UNUSED, char key) {
6233 
6234  return(self->f->getSmallContainerKChar(self, key));
6235 }
6236 
6237 
6238 baset* getNDupSmallDictG (smallDictt *self, baset* retType UNUSED, const char *key) {
6239 
6240  return(self->f->getNDup(self,key));
6241 }
6242 
6243 undefinedt* getNDupUndefinedSmallDictG (smallDictt *self, undefinedt* retType UNUSED, const char *key) {
6244 
6245  return(self->f->getNDupUndefined(self,key));
6246 }
6247 
6248 bool getNDupBoolSmallDictG (smallDictt *self, bool retType UNUSED, const char *key) {
6249 
6250  return(self->f->getNDupBool(self,key));
6251 }
6252 
6253 double getNDupDoubleSmallDictG (smallDictt *self, double retType UNUSED, const char *key) {
6254 
6255  return(self->f->getNDupDouble(self,key));
6256 }
6257 
6258 int64_t getNDupIntSmallDictG (smallDictt *self, int64_t retType UNUSED, const char *key) {
6259 
6260  return(self->f->getNDupInt(self,key));
6261 }
6262 
6263 int32_t getNDupInt32SmallDictG (smallDictt *self, int32_t retType UNUSED, const char *key) {
6264 
6265  return(self->f->getNDupInt32(self,key));
6266 }
6267 
6268 uint64_t getNDupUintSmallDictG (smallDictt *self, uint64_t retType UNUSED, const char *key) {
6269 
6270  return(self->f->getNDupUint(self,key));
6271 }
6272 
6273 uint32_t getNDupUint32SmallDictG (smallDictt *self, uint32_t retType UNUSED, const char *key) {
6274 
6275  return(self->f->getNDupUint32(self,key));
6276 }
6277 
6278 char* getNDupSSmallDictG (smallDictt *self, char* retType UNUSED, const char *key) {
6279 
6280  return(self->f->getNDupS(self,key));
6281 }
6282 
6283 smallDictt* getNDupDictSmallDictG (smallDictt *self, smallDictt* retType UNUSED, const char *key) {
6284 
6285  return(self->f->getNDupDict(self,key));
6286 }
6287 
6288 smallArrayt* getNDupArraySmallDictG (smallDictt *self, smallArrayt* retType UNUSED, const char *key) {
6289 
6290  return(self->f->getNDupArray(self,key));
6291 }
6292 
6293 smallBoolt* getNDupSmallBoolSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, const char *key) {
6294 
6295  return(self->f->getNDupSmallBool(self,key));
6296 }
6297 
6298 smallBytest* getNDupSmallBytesSmallDictG (smallDictt *self, smallBytest* retType UNUSED, const char *key) {
6299 
6300  return(self->f->getNDupSmallBytes(self,key));
6301 }
6302 
6303 smallDoublet* getNDupSmallDoubleSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, const char *key) {
6304 
6305  return(self->f->getNDupSmallDouble(self,key));
6306 }
6307 
6308 smallIntt* getNDupSmallIntSmallDictG (smallDictt *self, smallIntt* retType UNUSED, const char *key) {
6309 
6310  return(self->f->getNDupSmallInt(self,key));
6311 }
6312 
6313 smallJsont* getNDupSmallJsonSmallDictG (smallDictt *self, smallJsont* retType UNUSED, const char *key) {
6314 
6315  return(self->f->getNDupSmallJson(self,key));
6316 }
6317 
6318 smallStringt* getNDupSmallStringSmallDictG (smallDictt *self, smallStringt* retType UNUSED, const char *key) {
6319 
6320  return(self->f->getNDupSmallString(self,key));
6321 }
6322 
6323 void* getNDupVoidSmallDictG (smallDictt *self, void* retType UNUSED, const char *key) {
6324 
6325  return(self->f->getNDupVoid(self,key));
6326 }
6327 
6328 smallContainert* getNDupSmallContainerSmallDictG(smallDictt *self, smallContainert* retType UNUSED, const char *key) {
6329 
6330  return(self->f->getNDupSmallContainer(self,key));
6331 }
6332 
6333 baset* getNDupKCharSmallDictG (smallDictt *self, baset* retType UNUSED, char key) {
6334 
6335  return(self->f->getNDupKChar(self, key));
6336 }
6337 
6338 undefinedt* getNDupUndefinedKCharSmallDictG (smallDictt *self, undefinedt* retType UNUSED, char key) {
6339 
6340  return(self->f->getNDupUndefinedKChar(self, key));
6341 }
6342 
6343 bool getNDupBoolKCharSmallDictG (smallDictt *self, bool retType UNUSED, char key) {
6344 
6345  return(self->f->getNDupBoolKChar(self, key));
6346 }
6347 
6348 double getNDupDoubleKCharSmallDictG (smallDictt *self, double retType UNUSED, char key) {
6349 
6350  return(self->f->getNDupDoubleKChar(self, key));
6351 }
6352 
6353 int64_t getNDupIntKCharSmallDictG (smallDictt *self, int64_t retType UNUSED, char key) {
6354 
6355  return(self->f->getNDupIntKChar(self, key));
6356 }
6357 
6358 int32_t getNDupInt32KCharSmallDictG (smallDictt *self, int32_t retType UNUSED, char key) {
6359 
6360  return(self->f->getNDupInt32KChar(self, key));
6361 }
6362 
6363 uint64_t getNDupUintKCharSmallDictG (smallDictt *self, uint64_t retType UNUSED, char key) {
6364 
6365  return(self->f->getNDupUintKChar(self, key));
6366 }
6367 
6368 uint32_t getNDupUint32KCharSmallDictG (smallDictt *self, uint32_t retType UNUSED, char key) {
6369 
6370  return(self->f->getNDupUint32KChar(self, key));
6371 }
6372 
6373 char* getNDupSKCharSmallDictG (smallDictt *self, char* retType UNUSED, char key) {
6374 
6375  return(self->f->getNDupSKChar(self, key));
6376 }
6377 
6378 smallDictt* getNDupDictKCharSmallDictG (smallDictt *self, smallDictt* retType UNUSED, char key) {
6379 
6380  return(self->f->getNDupDictKChar(self, key));
6381 }
6382 
6383 smallArrayt* getNDupArrayKCharSmallDictG (smallDictt *self, smallArrayt* retType UNUSED, char key) {
6384 
6385  return(self->f->getNDupArrayKChar(self, key));
6386 }
6387 
6388 smallBoolt* getNDupSmallBoolKCharSmallDictG (smallDictt *self, smallBoolt* retType UNUSED, char key) {
6389 
6390  return(self->f->getNDupSmallBoolKChar(self, key));
6391 }
6392 
6393 smallBytest* getNDupSmallBytesKCharSmallDictG (smallDictt *self, smallBytest* retType UNUSED, char key) {
6394 
6395  return(self->f->getNDupSmallBytesKChar(self, key));
6396 }
6397 
6398 smallDoublet* getNDupSmallDoubleKCharSmallDictG (smallDictt *self, smallDoublet* retType UNUSED, char key) {
6399 
6400  return(self->f->getNDupSmallDoubleKChar(self, key));
6401 }
6402 
6403 smallIntt* getNDupSmallIntKCharSmallDictG (smallDictt *self, smallIntt* retType UNUSED, char key) {
6404 
6405  return(self->f->getNDupSmallIntKChar(self, key));
6406 }
6407 
6408 smallJsont* getNDupSmallJsonKCharSmallDictG (smallDictt *self, smallJsont* retType UNUSED, char key) {
6409 
6410  return(self->f->getNDupSmallJsonKChar(self, key));
6411 }
6412 
6413 smallStringt* getNDupSmallStringKCharSmallDictG (smallDictt *self, smallStringt* retType UNUSED, char key) {
6414 
6415  return(self->f->getNDupSmallStringKChar(self, key));
6416 }
6417 
6418 void* getNDupVoidKCharSmallDictG (smallDictt *self, void* retType UNUSED, char key) {
6419 
6420  return(self->f->getNDupVoidKChar(self, key));
6421 }
6422 
6423 smallContainert* getNDupSmallContainerKCharSmallDictG(smallDictt *self, smallContainert* retType UNUSED, char key) {
6424 
6425  return(self->f->getNDupSmallContainerKChar(self, key));
6426 }
6427 
6428 
6429 smallDictt* setUndefinedSmallDictG(smallDictt *self, const char *key, void *value UNUSED) {
6430 
6431  return(self->f->setUndefined(self,key));
6432 }
6433 
6434 smallDictt* setBoolSmallDictG (smallDictt *self, const char *key, bool value) {
6435 
6436  return(self->f->setBool(self,key,value));
6437 }
6438 
6439 smallDictt* setDoubleSmallDictG (smallDictt *self, const char *key, double value) {
6440 
6441  return(self->f->setDouble(self,key,value));
6442 }
6443 
6444 smallDictt* setIntSmallDictG (smallDictt *self, const char *key, int64_t value) {
6445 
6446  return(self->f->setInt(self,key,value));
6447 }
6448 
6449 smallDictt* setSSmallDictG (smallDictt *self, const char *key, const char *string) {
6450 
6451  return(self->f->setS(self,key,string));
6452 }
6453 
6454 smallDictt* setCharSmallDictG (smallDictt *self, const char *key, char c) {
6455 
6456  return(self->f->setChar(self,key,c));
6457 }
6458 
6459 smallDictt* setDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict) {
6460 
6461  return(self->f->setDict(self,key,dict));
6462 }
6463 
6464 smallDictt* setArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array) {
6465 
6466  return(self->f->setArray(self,key,array));
6467 }
6468 
6469 smallDictt* setArraycSmallDictG (smallDictt *self, const char *key, char **array) {
6470 
6471  return(self->f->setArrayc(self,key,array));
6472 }
6473 
6474 smallDictt* setCArraycSmallDictG (smallDictt *self, const char *key, const char **array) {
6475 
6476  return(self->f->setCArrayc(self,key,array));
6477 }
6478 
6479 smallDictt* setVoidSmallDictG (smallDictt *self, const char *key, void *value) {
6480  smallDictt *r = NULL;
6481 
6482  if (key && value) {
6483  smallContainert *c = allocSmallContainer(value);
6484  if (!c) {
6485  return(NULL);
6486  }
6487  r = self->f->setNFreeSmallContainer(self, key, c);;
6488  return(r);
6489  }
6490  r = self->f->setUndefined(self,key);;
6491  return(r);
6492 }
6493 
6494 smallDictt* setSmallBoolSmallDictG (smallDictt *self, const char *key, smallBoolt *value) {
6495 
6496  return(self->f->setSmallBool(self,key,value));
6497 }
6498 
6499 smallDictt* setSmallBytesSmallDictG (smallDictt *self, const char *key, smallBytest *value) {
6500 
6501  return(self->f->setSmallBytes(self,key,value));
6502 }
6503 
6504 smallDictt* setSmallDoubleSmallDictG (smallDictt *self, const char *key, smallDoublet *value) {
6505 
6506  return(self->f->setSmallDouble(self,key,value));
6507 }
6508 
6509 smallDictt* setSmallIntSmallDictG (smallDictt *self, const char *key, smallIntt *value) {
6510 
6511  return(self->f->setSmallInt(self,key,value));
6512 }
6513 
6514 smallDictt* setSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *value) {
6515 
6516  return(self->f->setSmallJson(self,key,value));
6517 }
6518 
6519 smallDictt* setSmallStringSmallDictG (smallDictt *self, const char *key, smallStringt *string) {
6520 
6521  return(self->f->setSmallString(self,key,string));
6522 }
6523 
6524 smallDictt* setSmallContainerSmallDictG(smallDictt *self, const char *key, smallContainert *container) {
6525 
6526  return(self->f->setSmallContainer(self,key,container));
6527 }
6528 
6529 smallDictt* setKCharSmallDictG (smallDictt *self, char key, baset *value) {
6530 
6531  return(self->f->setKChar(self, key, value));
6532 }
6533 
6534 smallDictt* setUndefinedKCharSmallDictG(smallDictt *self, char key, undefinedt *value UNUSED) {
6535 
6536  return(self->f->setUndefinedKChar(self, key));
6537 }
6538 
6539 smallDictt* setBoolKCharSmallDictG (smallDictt *self, char key, bool value) {
6540 
6541  return(self->f->setBoolKChar(self, key, value));
6542 }
6543 
6544 smallDictt* setDoubleKCharSmallDictG (smallDictt *self, char key, double value) {
6545 
6546  return(self->f->setDoubleKChar(self, key, value));
6547 }
6548 
6549 smallDictt* setIntKCharSmallDictG (smallDictt *self, char key, int64_t value) {
6550 
6551  return(self->f->setIntKChar(self, key, value));
6552 }
6553 
6554 smallDictt* setSKCharSmallDictG (smallDictt *self, char key, const char *string) {
6555 
6556  return(self->f->setSKChar(self, key, string));
6557 }
6558 
6559 smallDictt* setCharKCharSmallDictG (smallDictt *self, char key, char c) {
6560 
6561  return(self->f->setCharKChar(self, key, c));
6562 }
6563 
6564 smallDictt* setDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict) {
6565 
6566  return(self->f->setDictKChar(self, key, dict));
6567 }
6568 
6569 smallDictt* setArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array) {
6570 
6571  return(self->f->setArrayKChar(self, key, array));
6572 }
6573 
6574 smallDictt* setArraycKCharSmallDictG (smallDictt *self, char key, char **array) {
6575 
6576  return(self->f->setArraycKChar(self, key, array));
6577 }
6578 
6579 smallDictt* setCArraycKCharSmallDictG (smallDictt *self, char key, const char **array) {
6580 
6581  return(self->f->setCArraycKChar(self, key, array));
6582 }
6583 
6584 smallDictt* setVoidKCharSmallDictG (smallDictt *self, char key, void *value) {
6585 
6586  charToS(s, key);
6587  return(setVoidSmallDictG(self, s, value));
6588 }
6589 
6590 smallDictt* setSmallBoolKCharSmallDictG (smallDictt *self, char key, smallBoolt *value) {
6591 
6592  return(self->f->setSmallBoolKChar(self, key, value));
6593 }
6594 
6595 smallDictt* setSmallBytesKCharSmallDictG (smallDictt *self, char key, smallBytest *value) {
6596 
6597  return(self->f->setSmallBytesKChar(self, key, value));
6598 }
6599 
6600 smallDictt* setSmallDoubleKCharSmallDictG (smallDictt *self, char key, smallDoublet *value) {
6601 
6602  return(self->f->setSmallDoubleKChar(self, key, value));
6603 }
6604 
6605 smallDictt* setSmallIntKCharSmallDictG (smallDictt *self, char key, smallIntt *value) {
6606 
6607  return(self->f->setSmallIntKChar(self, key, value));
6608 }
6609 
6610 smallDictt* setSmallJsonKCharSmallDictG (smallDictt *self, char key, smallJsont *value) {
6611 
6612  return(self->f->setSmallJsonKChar(self, key, value));
6613 }
6614 
6615 smallDictt* setSmallStringKCharSmallDictG (smallDictt *self, char key, smallStringt *string) {
6616 
6617  return(self->f->setSmallStringKChar(self, key, string));
6618 }
6619 
6620 smallDictt* setSmallContainerKCharSmallDictG(smallDictt *self, char key, smallContainert *container) {
6621 
6622  return(self->f->setSmallContainerKChar(self, key, container));
6623 }
6624 
6625 smallDictt* setNFreeSmallDictG (smallDictt *self, const char *key, baset *value) {
6626 
6627  return(self->f->setNFree(self,key,value));
6628 }
6629 
6630 smallDictt* setNFreeUndefinedSmallDictG(smallDictt *self, const char *key, undefinedt *value) {
6631 
6632  return(self->f->setNFreeUndefined(self,key,value));
6633 }
6634 
6635 smallDictt* setNFreeSSmallDictG (smallDictt *self, const char *key, char *string) {
6636 
6637  return(self->f->setNFreeS(self,key,string));
6638 }
6639 
6640 smallDictt* setNFreeDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict) {
6641 
6642  return(self->f->setNFreeDict(self,key,dict));
6643 }
6644 
6645 smallDictt* setNFreeArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array) {
6646 
6647  return(self->f->setNFreeArray(self,key,array));
6648 }
6649 
6650 smallDictt* setNFreeArraycSmallDictG (smallDictt *self, const char *key, char **array) {
6651 
6652  return(self->f->setNFreeArrayc(self,key,array));
6653 }
6654 
6655 smallDictt* setNFreeSmallBoolSmallDictG (smallDictt *self, const char *key, smallBoolt *value) {
6656 
6657  return(self->f->setNFreeSmallBool(self,key,value));
6658 }
6659 
6660 smallDictt* setNFreeSmallBytesSmallDictG (smallDictt *self, const char *key, smallBytest *value) {
6661 
6662  return(self->f->setNFreeSmallBytes(self,key,value));
6663 }
6664 
6665 smallDictt* setNFreeSmallDoubleSmallDictG (smallDictt *self, const char *key, smallDoublet *value) {
6666 
6667  return(self->f->setNFreeSmallDouble(self,key,value));
6668 }
6669 
6670 smallDictt* setNFreeSmallIntSmallDictG (smallDictt *self, const char *key, smallIntt *value) {
6671 
6672  return(self->f->setNFreeSmallInt(self,key,value));
6673 }
6674 
6675 smallDictt* setNFreeSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *value) {
6676 
6677  return(self->f->setNFreeSmallJson(self,key,value));
6678 }
6679 
6680 smallDictt* setNFreeSmallStringSmallDictG (smallDictt *self, const char *key, smallStringt *string) {
6681 
6682  return(self->f->setNFreeSmallString(self,key,string));
6683 }
6684 
6685 smallDictt* setNFreeSmallContainerSmallDictG(smallDictt *self, const char *key, smallContainert *container) {
6686 
6687  return(self->f->setNFreeSmallContainer(self,key,container));
6688 }
6689 
6690 smallDictt* setNFreeKCharSmallDictG (smallDictt *self, char key, baset *value) {
6691 
6692  return(self->f->setNFreeKChar(self, key, value));
6693 }
6694 
6695 smallDictt* setNFreeUndefinedKCharSmallDictG(smallDictt *self, char key, undefinedt *u) {
6696 
6697  return(self->f->setNFreeUndefinedKChar(self, key, u));
6698 }
6699 
6700 smallDictt* setNFreeSKCharSmallDictG (smallDictt *self, char key, char *string) {
6701 
6702  return(self->f->setNFreeSKChar(self, key, string));
6703 }
6704 
6705 smallDictt* setNFreeDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict) {
6706 
6707  return(self->f->setNFreeDictKChar(self, key, dict));
6708 }
6709 
6710 smallDictt* setNFreeArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array) {
6711 
6712  return(self->f->setNFreeArrayKChar(self, key, array));
6713 }
6714 
6715 smallDictt* setNFreeArraycKCharSmallDictG (smallDictt *self, char key, char **array) {
6716 
6717  return(self->f->setNFreeArraycKChar(self, key, array));
6718 }
6719 
6720 smallDictt* setNFreeSmallBoolKCharSmallDictG (smallDictt *self, char key, smallBoolt *value) {
6721 
6722  return(self->f->setNFreeSmallBoolKChar(self, key, value));
6723 }
6724 
6725 smallDictt* setNFreeSmallBytesKCharSmallDictG (smallDictt *self, char key, smallBytest *value) {
6726 
6727  return(self->f->setNFreeSmallBytesKChar(self, key, value));
6728 }
6729 
6730 smallDictt* setNFreeSmallDoubleKCharSmallDictG (smallDictt *self, char key, smallDoublet *value) {
6731 
6732  return(self->f->setNFreeSmallDoubleKChar(self, key, value));
6733 }
6734 
6735 smallDictt* setNFreeSmallIntKCharSmallDictG (smallDictt *self, char key, smallIntt *value) {
6736 
6737  return(self->f->setNFreeSmallIntKChar(self, key, value));
6738 }
6739 
6740 smallDictt* setNFreeSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *value) {
6741 
6742  return(self->f->setNFreeSmallJsonKChar(self, key, value));
6743 }
6744 
6745 smallDictt* setNFreeSmallStringKCharSmallDictG (smallDictt *self, char key, smallStringt *string) {
6746 
6747  return(self->f->setNFreeSmallStringKChar(self, key, string));
6748 }
6749 
6750 smallDictt* setNFreeSmallContainerKCharSmallDictG(smallDictt *self, char key, smallContainert *container) {
6751 
6752  return(self->f->setNFreeSmallContainerKChar(self, key, container));
6753 }
6754 
6755 
6756 smallDictt* setPDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict) {
6757 
6758  return(self->f->setPDict(self,key,dict));
6759 }
6760 
6761 smallDictt* setPArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array) {
6762 
6763  return(self->f->setPArray(self,key,array));
6764 }
6765 
6766 smallDictt* setPSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *json) {
6767 
6768  return(self->f->setPSmallJson(self,key,json));
6769 }
6770 
6771 smallDictt* setPSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string) {
6772 
6773  return(self->f->setPSmallString(self,key,string));
6774 }
6775 
6776 smallDictt* setNFreePDictSmallDictG (smallDictt *self, const char *key, smallDictt *dict) {
6777 
6778  return(self->f->setNFreePDict(self,key,dict));
6779 }
6780 
6781 smallDictt* setNFreePArraySmallDictG (smallDictt *self, const char *key, smallArrayt *array) {
6782 
6783  return(self->f->setNFreePArray(self,key,array));
6784 }
6785 
6786 smallDictt* setNFreePSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *json) {
6787 
6788  return(self->f->setNFreePSmallJson(self,key,json));
6789 }
6790 
6791 smallDictt* setNFreePSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string) {
6792 
6793  return(self->f->setNFreePSmallString(self,key,string));
6794 }
6795 
6796 smallDictt* setPArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array) {
6797 
6798  return(self->f->setPArrayKChar(self, key, array));
6799 }
6800 
6801 smallDictt* setPDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict) {
6802 
6803  return(self->f->setPDictKChar(self, key, dict));
6804 }
6805 
6806 smallDictt* setPSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *json) {
6807 
6808  return(self->f->setPSmallJsonKChar(self, key, json));
6809 }
6810 
6811 smallDictt* setPSmallStringKCharSmallDictG (smallDictt *self, char key, smallStringt *string) {
6812 
6813  return(self->f->setPSmallStringKChar(self, key, string));
6814 }
6815 
6816 smallDictt* setNFreePArrayKCharSmallDictG (smallDictt *self, char key, smallArrayt *array) {
6817 
6818  return(self->f->setNFreePArrayKChar(self, key, array));
6819 }
6820 
6821 smallDictt* setNFreePDictKCharSmallDictG (smallDictt *self, char key, smallDictt *dict) {
6822 
6823  return(self->f->setNFreePDictKChar(self, key, dict));
6824 }
6825 
6826 smallDictt* setNFreePSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *json) {
6827 
6828  return(self->f->setNFreePSmallJsonKChar(self, key, json));
6829 }
6830 
6831 smallDictt* setNFreePSmallStringKCharSmallDictG(smallDictt *self, char key, smallStringt *string) {
6832 
6833  return(self->f->setNFreePSmallStringKChar(self, key, string));
6834 }
6835 
6836 
6837 smallDictt* mergeSmallDictG (smallDictt *self, smallDictt *smallDict) {
6838 
6839  return(self->f->merge(self,smallDict));
6840 }
6841 
6842 smallDictt* mergeSmallJsonSmallDictG(smallDictt *self, smallJsont *json) {
6843 
6844  return(self->f->mergeSmallJson(self,json));
6845 }
6846 
6847 smallDictt* mergeNSmashSmallDictG (smallDictt *self, smallDictt *smallDict) {
6848 
6849  return(self->f->mergeNSmash(self,smallDict));
6850 }
6851 
6852 smallDictt* mergeNSmashSmallJsonSmallDictG(smallDictt *self, smallJsont *json) {
6853 
6854  return(self->f->mergeNSmashSmallJson(self,json));
6855 }
6856 
6857 bool equalSmallDictBaseG(smallDictt* self, baset* p2) {
6858 
6859  return(self->f->equalBase(self, p2));
6860 }
6861 
6862 bool equalSmallDictSmallJsonG (smallDictt* self, smallJsont* p2) {
6863 
6864  return(self->f->equalSmallJson(self, p2));
6865 }
6866 
6867 bool equalSmallDictG(smallDictt* self, smallDictt* p2) {
6868 
6869  return(self->f->equal(self, p2));
6870 }
6871 
6872 bool icEqualSmallDictBaseG(smallDictt* self, baset* p2) {
6873 
6874  return(self->f->icEqualBase(self, p2));
6875 }
6876 
6877 bool icEqualSmallDictSmallJsonG(smallDictt* self, smallJsont* p2) {
6878 
6879  return(self->f->icEqualSmallJson(self, p2));
6880 }
6881 
6882 bool icEqualSmallDictG(smallDictt* self, smallDictt* p2) {
6883 
6884  return(self->f->icEqual(self, p2));
6885 }
6886 
6887 double getNumSmallDictG(smallDictt *self, const char *key) {
6888 
6889  return(self->f->getNum(self, key));
6890 }
6891 
6892 baset* cropElemSmallDictG (smallDictt *self, const char* key) {
6893 
6894  return(self->f->cropElem(self, key));
6895 }
6896 
6897 undefinedt* cropElemUndefinedSmallDictG (smallDictt *self, const char* key) {
6898 
6899  return(self->f->cropElemUndefined(self, key));
6900 }
6901 
6902 bool cropElemBoolSmallDictG (smallDictt *self, const char* key) {
6903 
6904  return(self->f->cropElemBool(self, key));
6905 }
6906 
6907 double cropElemDoubleSmallDictG (smallDictt *self, const char* key) {
6908 
6909  return(self->f->cropElemDouble(self, key));
6910 }
6911 
6912 int64_t cropElemIntSmallDictG (smallDictt *self, const char* key) {
6913 
6914  return(self->f->cropElemInt(self, key));
6915 }
6916 
6917 int32_t cropElemInt32SmallDictG (smallDictt *self, const char* key) {
6918 
6919  return(self->f->cropElemInt32(self, key));
6920 }
6921 
6922 uint64_t cropElemUintSmallDictG (smallDictt *self, const char* key) {
6923 
6924  return(self->f->cropElemUint(self, key));
6925 }
6926 
6927 uint32_t cropElemUint32SmallDictG (smallDictt *self, const char* key) {
6928 
6929  return(self->f->cropElemUint32(self, key));
6930 }
6931 
6932 char* cropElemSSmallDictG (smallDictt *self, const char* key) {
6933 
6934  return(self->f->cropElemS(self, key));
6935 }
6936 
6937 smallDictt* cropElemDictSmallDictG (smallDictt *self, const char* key) {
6938 
6939  return(self->f->cropElemDict(self, key));
6940 }
6941 
6942 smallArrayt* cropElemArraySmallDictG (smallDictt *self, const char* key) {
6943 
6944  return(self->f->cropElemArray(self, key));
6945 }
6946 
6947 smallBoolt* cropElemSmallBoolSmallDictG (smallDictt *self, const char* key) {
6948 
6949  return(self->f->cropElemSmallBool(self, key));
6950 }
6951 
6952 smallBytest* cropElemSmallBytesSmallDictG (smallDictt *self, const char* key) {
6953 
6954  return(self->f->cropElemSmallBytes(self, key));
6955 }
6956 
6957 smallDoublet* cropElemSmallDoubleSmallDictG (smallDictt *self, const char* key) {
6958 
6959  return(self->f->cropElemSmallDouble(self, key));
6960 }
6961 
6962 smallIntt* cropElemSmallIntSmallDictG (smallDictt *self, const char* key) {
6963 
6964  return(self->f->cropElemSmallInt(self, key));
6965 }
6966 
6967 smallJsont* cropElemSmallJsonSmallDictG (smallDictt *self, const char* key) {
6968 
6969  return(self->f->cropElemSmallJson(self, key));
6970 }
6971 
6972 smallStringt* cropElemSmallStringSmallDictG (smallDictt *self, const char* key) {
6973 
6974  return(self->f->cropElemSmallString(self, key));
6975 }
6976 
6977 void* cropElemVoidSmallDictG (smallDictt *self, const char* key) {
6978 
6979  return(self->f->cropElemVoid(self, key));
6980 }
6981 
6982 smallContainert* cropElemSmallContainerSmallDictG(smallDictt *self, const char* key) {
6983 
6984  return(self->f->cropElemSmallContainer(self, key));
6985 }
6986 
6987 smallDictt* delSmallDictG (smallDictt *self, const char *key, int unused UNUSED) {
6988 
6989  return(self->f->del(self,key));
6990 }
6991 
6992 smallDictt* delKCharSmallDictG (smallDictt *self, char key, int unused UNUSED) {
6993 
6994  return(self->f->delKChar(self, key));
6995 }
6996 
6997 smallDictt* delElemSmallDictG (smallDictt *self, const char *key) {
6998 
6999  return(self->f->del(self,key));
7000 }
7001 
7002 smallDictt* delElemKCharSmallDictG(smallDictt *self, char key) {
7003 
7004  return(self->f->delKChar(self, key));
7005 }
7006 
7007 smallDictt* removeSmallDictG (smallDictt *self, const char *key, int unused UNUSED) {
7008 
7009  return(self->f->remove(self,key));
7010 }
7011 
7012 smallDictt* removeKCharSmallDictG (smallDictt *self, char key, int unused UNUSED) {
7013 
7014  return(self->f->removeKChar(self, key));
7015 }
7016 
7017 smallDictt* removeElemSmallDictG (smallDictt *self, const char *key) {
7018 
7019  return(self->f->remove(self,key));
7020 }
7021 
7022 smallDictt* removeElemKCharSmallDictG(smallDictt *self, char key) {
7023 
7024  return(self->f->removeKChar(self, key));
7025 }
7026 
7027 bool hasSmallDictG (smallDictt *self, const char *key) {
7028 
7029  return(self->f->has(self, key));
7030 }
7031 
7032 bool hasKCharSmallDictG (smallDictt *self, char key) {
7033 
7034  return(self->f->hasKChar(self, key));
7035 }
7036 
7037 char* keyBySmallDictG(smallDictt *self, baset *value) {
7038 
7039  return(self->f->keyBy(self,value));
7040 }
7041 
7042 char* keyByUndefinedSmallDictG(smallDictt *self, undefinedt *u) {
7043 
7044  return(self->f->keyByUndefined(self,u));
7045 }
7046 
7047 char* keyByBoolSmallDictG(smallDictt *self, bool value) {
7048 
7049  return(self->f->keyByBool(self,value));
7050 }
7051 
7052 char* keyByDoubleSmallDictG(smallDictt *self, double value) {
7053 
7054  return(self->f->keyByDouble(self,value));
7055 }
7056 
7057 char* keyByIntSmallDictG(smallDictt *self, int64_t value) {
7058 
7059  return(self->f->keyByInt(self,value));
7060 }
7061 
7062 char* keyBySSmallDictG(smallDictt *self, const char *string) {
7063 
7064  return(self->f->keyByS(self,string));
7065 }
7066 
7067 char* keyByCharSmallDictG(smallDictt *self, char c) {
7068 
7069  return(self->f->keyByChar(self,c));
7070 }
7071 
7072 char* keyByDictSmallDictG(smallDictt *self, smallDictt *dict) {
7073 
7074  return(self->f->keyByDict(self,dict));
7075 }
7076 
7077 char* keyByArraySmallDictG(smallDictt *self, smallArrayt *array) {
7078 
7079  return(self->f->keyByArray(self,array));
7080 }
7081 
7082 char* keyByArraycSmallDictG(smallDictt *self, char **array) {
7083 
7084  return(self->f->keyByArrayc(self,array));
7085 }
7086 
7087 char* keyByCArraycSmallDictG(smallDictt *self, const char **array) {
7088 
7089  return(self->f->keyByCArrayc(self,array));
7090 }
7091 
7092 char* keyBySmallBoolSmallDictG(smallDictt *self, smallBoolt *value) {
7093 
7094  return(self->f->keyBySmallBool(self,value));
7095 }
7096 
7097 char* keyBySmallBytesSmallDictG(smallDictt *self, smallBytest *value) {
7098 
7099  return(self->f->keyBySmallBytes(self,value));
7100 }
7101 
7102 char* keyBySmallDoubleSmallDictG(smallDictt *self, smallDoublet *value) {
7103 
7104  return(self->f->keyBySmallDouble(self,value));
7105 }
7106 
7107 char* keyBySmallIntSmallDictG(smallDictt *self, smallIntt *value) {
7108 
7109  return(self->f->keyBySmallInt(self,value));
7110 }
7111 
7112 char* keyBySmallJsonSmallDictG(smallDictt *self, smallJsont *string) {
7113 
7114  return(self->f->keyBySmallJson(self,string));
7115 }
7116 
7117 char* keyBySmallStringSmallDictG(smallDictt *self, smallStringt *string) {
7118 
7119  return(self->f->keyBySmallString(self,string));
7120 }
7121 
7122 char* keyBySmallContainerSmallDictG(smallDictt *self, smallContainert *container) {
7123 
7124  return(self->f->keyBySmallContainer(self,container));
7125 }
7126 
7127 char* icKeyBySmallDictG(smallDictt *self, baset *value) {
7128 
7129  return(self->f->icKeyBy(self,value));
7130 }
7131 
7132 char* icKeyBySSmallDictG(smallDictt *self, const char *string) {
7133 
7134  return(self->f->icKeyByS(self,string));
7135 }
7136 
7137 char* icKeyByCharSmallDictG(smallDictt *self, char c) {
7138 
7139  return(self->f->icKeyByChar(self,c));
7140 }
7141 
7142 char* icKeyByDictSmallDictG(smallDictt *self, smallDictt *dict) {
7143 
7144  return(self->f->icKeyByDict(self,dict));
7145 }
7146 
7147 char* icKeyByArraySmallDictG(smallDictt *self, smallArrayt *array) {
7148 
7149  return(self->f->icKeyByArray(self,array));
7150 }
7151 
7152 char* icKeyByArraycSmallDictG(smallDictt *self, char **array) {
7153 
7154  return(self->f->icKeyByArrayc(self,array));
7155 }
7156 
7157 char* icKeyByCArraycSmallDictG(smallDictt *self, const char **array) {
7158 
7159  return(self->f->icKeyByCArrayc(self,array));
7160 }
7161 
7162 char* icKeyBySmallJsonSmallDictG(smallDictt *self, smallJsont *string) {
7163 
7164  return(self->f->icKeyBySmallJson(self,string));
7165 }
7166 
7167 char* icKeyBySmallStringSmallDictG(smallDictt *self, smallStringt *string) {
7168 
7169  return(self->f->icKeyBySmallString(self,string));
7170 }
7171 
7172 smallDictt* trimSmallDictG(smallDictt *self) {
7173 
7174  return(self->f->trim(self));
7175 }
7176 
7177 smallArrayt* keysSmallStringSmallDictG(smallDictt *self) {
7178 
7179  return(self->f->keysSmallString(self));
7180 }
7181 
7182 size_t lenSmallDictG (smallDictt *self) {
7183 
7184  return(self->f->len(self));
7185 }
7186 
7187 smallDictt* emptySmallDictG (smallDictt *self) {
7188 
7189  return(self->f->empty(self));
7190 }
7191 
7192 bool isEmptySmallDictG (smallDictt *self) {
7193 
7194  return(self->f->isEmpty(self));
7195 }
7196 
7197 smallDictt* zipSmallDictG (smallDictt *self, smallArrayt *keys, smallArrayt *values) {
7198 
7199  return(self->f->zip(self,keys,values));
7200 }
7201 
7202 smallDictt* zipSmallJsonSmallDictG(smallDictt *self, smallArrayt *keys, smallJsont *values) {
7203 
7204  return(self->f->zipSmallJson(self,keys,values));
7205 }
7206 
7207 smallDictt* zipSmallJsonSmallArraySmallDictG(smallDictt *self, smallJsont *keys, smallArrayt *values) {
7208 
7209  return(self->f->zipSmallJsonSmallArray(self,keys,values));
7210 }
7211 
7212 smallDictt* zipSmallJsonSmallJsonSmallDictG (smallDictt *self, smallJsont *keys, smallJsont *values) {
7213 
7214  return(self->f->zipSmallJsonSmallJson(self,keys,values));
7215 }
7216 
7217 smallDictt* zipSmallJsonVArraySmallDictG (smallDictt *self, smallJsont *keys, char **values) {
7218 
7219  return(self->f->zipSmallJsonVArray(self,keys,values));
7220 }
7221 
7222 smallDictt* zipSmallJsonVCArraySmallDictG (smallDictt *self, smallJsont *keys, const char **values) {
7223 
7224  return(self->f->zipSmallJsonVCArray(self,keys,values));
7225 }
7226 
7227 smallDictt* zipArraySmallDictG(smallDictt *self, char** keys, smallArrayt *values) {
7228 
7229  return(self->f->zipArray(self,keys,values));
7230 }
7231 
7232 smallDictt* zipArraySmallJsonSmallDictG (smallDictt *self, char** keys, smallJsont *values) {
7233 
7234  return(self->f->zipArraySmallJson(self,keys,values));
7235 }
7236 
7237 smallDictt* zipCArraySmallDictG(smallDictt *self, const char** keys, smallArrayt *values) {
7238 
7239  return(self->f->zipCArray(self,keys,values));
7240 }
7241 
7242 smallDictt* zipCArraySmallJsonSmallDictG (smallDictt *self, const char** keys, smallJsont *values) {
7243 
7244  return(self->f->zipCArraySmallJson(self,keys,values));
7245 }
7246 
7247 smallDictt* zipArrayArraySmallDictG(smallDictt *self, char** keys, char** values) {
7248 
7249  return(self->f->zipArrayArray(self,keys,values));
7250 }
7251 
7252 smallDictt* zipCArrayArraySmallDictG(smallDictt *self, const char** keys, char** values) {
7253 
7254  return(self->f->zipCArrayArray(self,keys,values));
7255 }
7256 
7257 smallDictt* zipArrayCArraySmallDictG(smallDictt *self, char** keys, const char** values) {
7258 
7259  return(self->f->zipArrayCArray(self,keys,values));
7260 }
7261 
7262 smallDictt* zipCArrayCArraySmallDictG(smallDictt *self, const char** keys, const char** values) {
7263 
7264  return(self->f->zipCArrayCArray(self,keys,values));
7265 }
7266 
7267 smallDictt* zipVArraySmallDictG (smallDictt *self, smallArrayt *keys, char** values) {
7268 
7269  return(self->f->zipVArray(self,keys,values));
7270 }
7271 
7272 smallDictt* zipVCArraySmallDictG (smallDictt *self, smallArrayt *keys, const char** values) {
7273 
7274  return(self->f->zipVCArray(self,keys,values));
7275 }
7276 
7277 smallDictt* fromArraySmallDictG (smallDictt *self, smallArrayt *items) {
7278 
7279  return(self->f->fromArray(self, items));
7280 }
7281 
7282 smallArrayt* toArraySmallDictG (smallDictt *self) {
7283 
7284  return(self->f->toArray(self));
7285 }
7286 
7287 bool writeFileSmallDictG (smallDictt *self, const char *filePath) {
7288 
7289  return(self->f->writeFile(self, filePath));
7290 }
7291 
7292 bool writeFileSmallJsonSmallDictG (smallDictt *self, smallJsont *filePath) {
7293 
7294  return(self->f->writeFileSmallJson(self, filePath));
7295 }
7296 
7297 bool writeFileSmallStringSmallDictG (smallDictt *self, smallStringt *filePath) {
7298 
7299  return(self->f->writeFileSmallString(self, filePath));
7300 }
7301 
7302 bool writeStreamSmallDictG (smallDictt *self, FILE *fp) {
7303 
7304  return(self->f->writeStream(self, fp));
7305 }
7306 
7307 bool appendFileSmallDictG (smallDictt *self, const char *filePath) {
7308 
7309  return(self->f->appendFile(self, filePath));
7310 }
7311 
7312 bool appendFileSmallStringSmallDictG (smallDictt *self, smallStringt *filePath) {
7313 
7314  return(self->f->appendFileSmallString(self, filePath));
7315 }
7316 
7317 void logSmallDictG(smallDictt *self) {
7318 
7319  self->f->log(self);
7320 }
7321 
7322 smallStringt* typeSmallStringSmallDictG(smallDictt *self, const char *key) {
7323 
7324  return(self->f->typeSmallString(self,key));
7325 }
7326 
7327 const char* typeStringKCharSmallDictG (smallDictt *self, char key) {
7328 
7329  return(self->f->typeStringKChar(self, key));
7330 }
7331 
7332 smallStringt* typeSmallStringKCharSmallDictG (smallDictt *self, char key) {
7333 
7334  return(self->f->typeSmallStringKChar(self, key));
7335 }
7336 
sEscapeTiny
char * sEscapeTiny(smallt *obj)
stringify a small object
Definition: libsheepySmall.c:901
forEachCS
#define forEachCS(list, element)
forEach for const char** lists
Definition: libsheepy.h:3001
cropElemUint32SmallDict
internal uint32_t cropElemUint32SmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3252
areAllEArraySmallDict
internal bool areAllEArraySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5957
getSmallBytesSmallDict
internal smallBytest * getSmallBytesSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2283
icKeyByArraycSmallDictG
char * icKeyByArraycSmallDictG(smallDictt *self, char **array)
Definition: libsheepyCSmallDict.c:7152
listFreeS
void listFreeS(char **list)
list Free String
Definition: libsheepy.c:50780
freeSmallDict
internal void freeSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1048
keyBySmallDictG
char * keyBySmallDictG(smallDictt *self, baset *value)
Definition: libsheepyCSmallDict.c:7037
getNDupArrayKCharSmallDict
internal smallArrayt * getNDupArrayKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2935
getSmallIntSmallDict
internal smallIntt * getSmallIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2319
getSmallDoubleSmallDict
internal smallDoublet * getSmallDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2301
finishSmallDict
internal void finishSmallDict(smallDictt **self)
Definition: libsheepyCSmallDict.c:1153
getNDupDictKCharSmallDict
internal smallDictt * getNDupDictKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2929
getIntSmallDictG
int64_t getIntSmallDictG(smallDictt *self, int64_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6017
setSmallBytesKCharSmallDict
internal smallDictt * setSmallBytesKCharSmallDict(smallDictt *self, char key, smallBytest *value)
Definition: libsheepyCSmallDict.c:1599
s
char * s
Definition: libsheepyObjectTest.c:27
charToS
#define charToS(dst, c)
Definition: libsheepy.h:1862
setUndefinedSmallDictG
smallDictt * setUndefinedSmallDictG(smallDictt *self, const char *key, void *value UNUSED)
Definition: libsheepyCSmallDict.c:6429
isEmptySmallDict
internal bool isEmptySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4691
so
smallt * so
Definition: libsheepyObjectTest.c:2264
cleanUpSmallDictFinishG
void cleanUpSmallDictFinishG(smallDictt **val)
Definition: libsheepyCSmallDict.c:1033
appendFileSmallStringSmallDict
internal bool appendFileSmallStringSmallDict(smallDictt *self, smallStringt *filePath)
Definition: libsheepyCSmallDict.c:5543
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
len
size_t len
Definition: libsheepyObjectTest.c:108
getSSmallDictG
char * getSSmallDictG(smallDictt *self, char *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6057
sDictSetP
void sDictSetP(sDictt **dict, const char *key, smallt *data)
dictionary set pointer
Definition: libsheepySmall.c:1386
setNFreePSmallJsonSmallDict
internal smallDictt * setNFreePSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *json)
Definition: libsheepyCSmallDict.c:1958
eqS
bool eqS(const char *string1, const char *string2)
string Equal compare string1 to string2
Definition: libsheepy.c:9067
areAllEStringSmallDict
internal bool areAllEStringSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5945
isEFaststringSmallDict
internal bool isEFaststringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5817
sDictGet
smallt * sDictGet(sDictt *dict, const char *key)
get object stored at key
Definition: libsheepySmall.c:1312
isBlankS
bool isBlankS(const char *string)
is Blank String
Definition: libsheepy.c:50246
getNDupDictSmallDict
internal smallDictt * getNDupDictSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2687
icKeyByCharSmallDictG
char * icKeyByCharSmallDictG(smallDictt *self, char c)
Definition: libsheepyCSmallDict.c:7137
setDoubleKCharSmallDict
internal smallDictt * setDoubleKCharSmallDict(smallDictt *self, char key, double value)
Definition: libsheepyCSmallDict.c:1545
getInt32KCharSmallDictG
int32_t getInt32KCharSmallDictG(smallDictt *self, int32_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6152
writeFileSmallDict
internal bool writeFileSmallDict(smallDictt *self, const char *filePath)
Definition: libsheepyCSmallDict.c:5478
hasSmallDictG
bool hasSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:7027
toStringSmallDict
internal char * toStringSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1060
getTopSO
#define getTopSO(self)
Definition: libsheepyObject.h:8850
icKeyBySmallJsonSmallDictG
char * icKeyBySmallJsonSmallDictG(smallDictt *self, smallJsont *string)
Definition: libsheepyCSmallDict.c:7162
icKeyByDictSmallDictG
char * icKeyByDictSmallDictG(smallDictt *self, smallDictt *dict)
Definition: libsheepyCSmallDict.c:7142
setCharSmallDict
internal smallDictt * setCharSmallDict(smallDictt *self, const char *key, char c)
Definition: libsheepyCSmallDict.c:1308
delKCharSmallDict
internal smallDictt * delKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:3620
icKeyBySSmallDict
internal char * icKeyBySSmallDict(smallDictt *self, const char *string)
Definition: libsheepyCSmallDict.c:4111
setNFreeSmallIntSmallDictG
smallDictt * setNFreeSmallIntSmallDictG(smallDictt *self, const char *key, smallIntt *value)
Definition: libsheepyCSmallDict.c:6670
getNDupIntSmallDict
internal int64_t getNDupIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2627
isEDictSmallDict
internal bool isEDictSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5741
sToString
char * sToString(smallt *obj)
stringify object
Definition: libsheepySmall.c:654
zipArrayArraySmallDict
internal smallDictt * zipArrayArraySmallDict(smallDictt *self, char **keys, char **values)
Definition: libsheepyCSmallDict.c:5185
values
smallArrayt * values
Definition: libsheepyObjectTest.c:119
cropElemIntSmallDictG
int64_t cropElemIntSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6912
MIN
#define MIN(a, b)
Definition: libsheepy.h:467
appendFileSmallDictG
bool appendFileSmallDictG(smallDictt *self, const char *filePath)
Definition: libsheepyCSmallDict.c:7307
setNFreeSmallDoubleSmallDict
internal smallDictt * setNFreeSmallDoubleSmallDict(smallDictt *self, const char *key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:1724
getVoidSmallDictG
void * getVoidSmallDictG(smallDictt *self, void *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6102
setDictKCharSmallDict
internal smallDictt * setDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:1569
getSmallContainerKCharSmallDict
internal smallContainert * getSmallContainerKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2560
setSSmallDictG
smallDictt * setSSmallDictG(smallDictt *self, const char *key, const char *string)
Definition: libsheepyCSmallDict.c:6449
setNFreePSmallStringKCharSmallDict
internal smallDictt * setNFreePSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:2039
setNFreeSmallBoolKCharSmallDictG
smallDictt * setNFreeSmallBoolKCharSmallDictG(smallDictt *self, char key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:6720
areAllEDoubleSmallDict
internal bool areAllEDoubleSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5933
typeSmallDict
internal char typeSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5613
cropElemDictSmallDictG
smallDictt * cropElemDictSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6937
free
free(s)
keyBySmallJsonSmallDict
internal char * keyBySmallJsonSmallDict(smallDictt *self, smallJsont *string)
Definition: libsheepyCSmallDict.c:3988
setNFreeArrayKCharSmallDictG
smallDictt * setNFreeArrayKCharSmallDictG(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6710
allocSStringTiny
sStringt * allocSStringTiny(const char *data)
allocate a small string
Definition: libsheepySmall.c:308
getBoolSmallDict
internal bool getBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2073
zipCArraySmallJsonSmallDict
internal smallDictt * zipCArraySmallJsonSmallDict(smallDictt *self, const char **keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:5161
getNDupSmallStringKCharSmallDict
internal smallStringt * getNDupSmallStringKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2971
ssGet
#define ssGet(obj)
get a pointer to the string in the smallString object
Definition: libsheepyObject.h:9808
setUndefinedSmallDict
internal smallDictt * setUndefinedSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:1237
getUint32KCharSmallDictG
uint32_t getUint32KCharSmallDictG(smallDictt *self, uint32_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6172
keyByDictSmallDict
internal char * keyByDictSmallDict(smallDictt *self, smallDictt *dict)
Definition: libsheepyCSmallDict.c:3787
delElemKCharSmallDictG
smallDictt * delElemKCharSmallDictG(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:7002
toStringListCSGF
char * toStringListCSGF(const char **object)
Definition: libsheepyObject.c:1294
getNDupSmallDictG
baset * getNDupSmallDictG(smallDictt *self, baset *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6238
allocSInt
sIntt * allocSInt(int64_t value)
allocate a small int
Definition: libsheepySmall.c:291
sc
sContainert * sc
Definition: libsheepyObjectTest.c:2283
keyByBoolSmallDictG
char * keyByBoolSmallDictG(smallDictt *self, bool value)
Definition: libsheepyCSmallDict.c:7047
areAllEFaststringSmallDict
internal bool areAllEFaststringSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5951
getNDupUndefinedSmallDictG
undefinedt * getNDupUndefinedSmallDictG(smallDictt *self, undefinedt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6243
setNFreePSmallJsonKCharSmallDict
internal smallDictt * setNFreePSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *json)
Definition: libsheepyCSmallDict.c:2033
setSmallStringSmallDictG
smallDictt * setSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6519
zipArraySmallDictG
smallDictt * zipArraySmallDictG(smallDictt *self, char **keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:7227
cropElemArraySmallDict
internal smallArrayt * cropElemArraySmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3348
typeSmallStringSmallDictG
smallStringt * typeSmallStringSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:7322
hasKCharSmallDict
internal bool hasKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:3666
keyBySmallJsonSmallDictG
char * keyBySmallJsonSmallDictG(smallDictt *self, smallJsont *string)
Definition: libsheepyCSmallDict.c:7112
enumerateSmallArray
#define enumerateSmallArray(array, element, index)
enumerate non NULL elements in list skip deleted elements
Definition: libsheepyCSmallArray.h:2444
getNDupInt32SmallDict
internal int32_t getNDupInt32SmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2639
setSSmallDict
internal smallDictt * setSSmallDict(smallDictt *self, const char *key, const char *string)
Definition: libsheepyCSmallDict.c:1293
setNFreePArraySmallDict
internal smallDictt * setNFreePArraySmallDict(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1939
mergeNSmashSmallDict
internal smallDictt * mergeNSmashSmallDict(smallDictt *self, smallDictt *smallDict)
Definition: libsheepyCSmallDict.c:4451
RST
#define RST
reset for color function
Definition: libsheepy.h:763
typeSmallStringSmallDict
internal smallStringt * typeSmallStringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5591
setNFreePSmallStringSmallDictG
smallDictt * setNFreePSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6791
zipSmallJsonVCArraySmallDict
internal smallDictt * zipSmallJsonVCArraySmallDict(smallDictt *self, smallJsont *keys, const char **values)
Definition: libsheepyCSmallDict.c:5043
getArrayKCharSmallDict
internal smallArrayt * getArrayKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2512
setNFreeSmallStringSmallDictG
smallDictt * setNFreeSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6680
equalSmallDictBase
internal bool equalSmallDictBase(smallDictt *self, baset *p2)
Definition: libsheepyCSmallDict.c:4509
zipCArrayArraySmallDictG
smallDictt * zipCArrayArraySmallDictG(smallDictt *self, const char **keys, char **values)
Definition: libsheepyCSmallDict.c:7252
setArraycSmallDictG
smallDictt * setArraycSmallDictG(smallDictt *self, const char *key, char **array)
Definition: libsheepyCSmallDict.c:6469
setSmallBoolKCharSmallDict
internal smallDictt * setSmallBoolKCharSmallDict(smallDictt *self, char key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:1593
zipSmallJsonSmallArraySmallDict
internal smallDictt * zipSmallJsonSmallArraySmallDict(smallDictt *self, smallJsont *keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:4952
escapeSmallDict
internal char * escapeSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1098
zipVCArraySmallDict
internal smallDictt * zipVCArraySmallDict(smallDictt *self, smallArrayt *keys, const char **values)
Definition: libsheepyCSmallDict.c:5374
setNFreeSmallJsonKCharSmallDictG
smallDictt * setNFreeSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *value)
Definition: libsheepyCSmallDict.c:6740
getNDupSmallBytesSmallDict
internal smallBytest * getNDupSmallBytesSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2741
mergeNSmashSmallJsonSmallDict
internal smallDictt * mergeNSmashSmallJsonSmallDict(smallDictt *self, smallJsont *json)
Definition: libsheepyCSmallDict.c:4461
setSmallBoolSmallDictG
smallDictt * setSmallBoolSmallDictG(smallDictt *self, const char *key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:6494
keyByArraycSmallDictG
char * keyByArraycSmallDictG(smallDictt *self, char **array)
Definition: libsheepyCSmallDict.c:7082
setArraySmallDict
internal smallDictt * setArraySmallDict(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1332
allocSmallContainer
smallContainert * allocSmallContainer(void *data)
Definition: libsheepyCSmallContainer.c:142
keyBySmallContainerSmallDictG
char * keyBySmallContainerSmallDictG(smallDictt *self, smallContainert *container)
Definition: libsheepyCSmallDict.c:7122
getDictSmallDictG
smallDictt * getDictSmallDictG(smallDictt *self, smallDictt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6062
setCharKCharSmallDict
internal smallDictt * setCharKCharSmallDict(smallDictt *self, char key, char c)
Definition: libsheepyCSmallDict.c:1563
u64
#define u64
Definition: libsheepy.h:448
getUintSmallDict
internal uint64_t getUintSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2169
setArraycKCharSmallDictG
smallDictt * setArraycKCharSmallDictG(smallDictt *self, char key, char **array)
Definition: libsheepyCSmallDict.c:6574
keyBySmallDoubleSmallDictG
char * keyBySmallDoubleSmallDictG(smallDictt *self, smallDoublet *value)
Definition: libsheepyCSmallDict.c:7102
cropElemSmallIntSmallDictG
smallIntt * cropElemSmallIntSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6962
smallArray::f
smallArrayFunctionst * f
Definition: libsheepyCSmallArray.h:1894
getNDupUint32SmallDictG
uint32_t getNDupUint32SmallDictG(smallDictt *self, uint32_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6273
setSmallDoubleKCharSmallDict
internal smallDictt * setSmallDoubleKCharSmallDict(smallDictt *self, char key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:1605
getSKCharSmallDictG
char * getSKCharSmallDictG(smallDictt *self, char *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6182
setIntKCharSmallDictG
smallDictt * setIntKCharSmallDictG(smallDictt *self, char key, int64_t value)
Definition: libsheepyCSmallDict.c:6549
getUintKCharSmallDictG
uint64_t getUintKCharSmallDictG(smallDictt *self, uint64_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6162
iterNextKeySmallDict
internal const char * iterNextKeySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4835
setBoolKCharSmallDict
internal smallDictt * setBoolKCharSmallDict(smallDictt *self, char key, bool value)
Definition: libsheepyCSmallDict.c:1539
isOSmallInt
#define isOSmallInt(obj)
test if obj type is smallInt
Definition: libsheepyObject.h:263
toArraySmallDictG
smallArrayt * toArraySmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7282
i
smallt * i
Definition: libsheepyObjectTest.c:344
trimSmallDictG
smallDictt * trimSmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7172
keyByCArraycSmallDict
internal char * keyByCArraycSmallDict(smallDictt *self, const char **array)
Definition: libsheepyCSmallDict.c:3873
setDoubleSmallDict
internal smallDictt * setDoubleSmallDict(smallDictt *self, const char *key, double value)
Definition: libsheepyCSmallDict.c:1265
mergeSmallJsonSmallDict
internal smallDictt * mergeSmallJsonSmallDict(smallDictt *self, smallJsont *json)
Definition: libsheepyCSmallDict.c:4422
icEqS
bool icEqS(const char *string1, const char *string2)
ignore case string Equal compare string1 to string2
Definition: libsheepy.c:9283
setNFreePArrayKCharSmallDict
internal smallDictt * setNFreePArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:2021
setSKCharSmallDictG
smallDictt * setSKCharSmallDictG(smallDictt *self, char key, const char *string)
Definition: libsheepyCSmallDict.c:6554
getBoolPKCharSmallDict
internal bool * getBoolPKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2434
keyBySSmallDict
internal char * keyBySSmallDict(smallDictt *self, const char *string)
Definition: libsheepyCSmallDict.c:3766
getVoidSmallDict
internal void * getVoidSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2381
cropElemArraySmallDictG
smallArrayt * cropElemArraySmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6942
getNumSmallDictG
double getNumSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6887
sArrayt
array
Definition: libsheepySmall.h:158
initiateSmallDict
void initiateSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:635
getNDupDictKCharSmallDictG
smallDictt * getNDupDictKCharSmallDictG(smallDictt *self, smallDictt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6378
cropElemSmallBoolSmallDict
internal smallBoolt * cropElemSmallBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3376
setNFreeArraySmallDictG
smallDictt * setNFreeArraySmallDictG(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6645
keyBySmallBoolSmallDictG
char * keyBySmallBoolSmallDictG(smallDictt *self, smallBoolt *value)
Definition: libsheepyCSmallDict.c:7092
setDictSmallDict
internal smallDictt * setDictSmallDict(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:1314
icKeyBySmallStringSmallDictG
char * icKeyBySmallStringSmallDictG(smallDictt *self, smallStringt *string)
Definition: libsheepyCSmallDict.c:7167
getsoSmallDict
internal sDictt * getsoSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1187
zipSmallJsonSmallJsonSmallDictG
smallDictt * zipSmallJsonSmallJsonSmallDictG(smallDictt *self, smallJsont *keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:7212
allocSmallDictG
smallDictt * allocSmallDictG(smallDictt *self UNUSED)
Definition: libsheepyCSmallDict.c:5969
writeFileSmallDictG
bool writeFileSmallDictG(smallDictt *self, const char *filePath)
Definition: libsheepyCSmallDict.c:7287
toArraySmallDict
internal smallArrayt * toArraySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5452
areAllEBoolSmallDict
internal bool areAllEBoolSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5915
setNFreeSmallBytesKCharSmallDict
internal smallDictt * setNFreeSmallBytesKCharSmallDict(smallDictt *self, char key, smallBytest *value)
Definition: libsheepyCSmallDict.c:1811
smallDictFunctionst::terminate
terminateSmallDictFt terminate
Definition: libsheepyCSmallDict.h:1057
setNFreeSmallDictG
smallDictt * setNFreeSmallDictG(smallDictt *self, const char *key, baset *value)
Definition: libsheepyCSmallDict.c:6625
areAllEUndefinedSmallDict
internal bool areAllEUndefinedSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5909
keyByArraySmallDictG
char * keyByArraySmallDictG(smallDictt *self, smallArrayt *array)
Definition: libsheepyCSmallDict.c:7077
setNFreePSmallJsonKCharSmallDictG
smallDictt * setNFreePSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *json)
Definition: libsheepyCSmallDict.c:6826
writeStreamS
int writeStreamS(FILE *fp, const char *string)
write string to file
Definition: libsheepy.c:4963
getNDupIntSmallDictG
int64_t getNDupIntSmallDictG(smallDictt *self, int64_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6258
cropElemSmallContainerSmallDict
internal smallContainert * cropElemSmallContainerSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3582
typeStringsSmallDict
internal smallDictt * typeStringsSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5635
setSmallStringKCharSmallDictG
smallDictt * setSmallStringKCharSmallDictG(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6615
keysSmallDict
internal char ** keysSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4350
lenO
#define lenO(self)
Definition: libsheepyObject.h:5156
fromArraySmallDictG
smallDictt * fromArraySmallDictG(smallDictt *self, smallArrayt *items)
Definition: libsheepyCSmallDict.c:7277
smallt
base class for the small objects all small objects have a type
Definition: libsheepySmall.h:67
typeKCharSmallDict
internal char typeKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:5628
base::f
baseFunctionst * f
Definition: libsheepyObject.h:9599
d
smallDictt * d
Definition: libsheepyObjectTest.c:2328
getArraySmallDictG
smallArrayt * getArraySmallDictG(smallDictt *self, smallArrayt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6067
zipCArrayCArraySmallDictG
smallDictt * zipCArrayCArraySmallDictG(smallDictt *self, const char **keys, const char **values)
Definition: libsheepyCSmallDict.c:7262
cropElemDoubleSmallDict
internal double cropElemDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3116
setPArrayKCharSmallDict
internal smallDictt * setPArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1997
mergeNSmashSmallJsonSmallDictG
smallDictt * mergeNSmashSmallJsonSmallDictG(smallDictt *self, smallJsont *json)
Definition: libsheepyCSmallDict.c:6852
keyByUndefinedSmallDict
internal char * keyByUndefinedSmallDict(smallDictt *self, undefinedt *u)
Definition: libsheepyCSmallDict.c:3698
areAllEDictSmallDict
internal bool areAllEDictSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5927
keyByCArraycSmallDictG
char * keyByCArraycSmallDictG(smallDictt *self, const char **array)
Definition: libsheepyCSmallDict.c:7087
getInt32SmallDict
internal int32_t getInt32SmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2145
icKeyBySmallJsonSmallDict
internal char * icKeyBySmallJsonSmallDict(smallDictt *self, smallJsont *string)
Definition: libsheepyCSmallDict.c:4244
getArraySmallDict
internal smallArrayt * getArraySmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2247
createAllocateSmallDict
#define createAllocateSmallDict(obj)
Definition: libsheepyCSmallDict.h:1087
data
char data[7]
Definition: libsheepy.c:19690
allocSBytes
sBytest * allocSBytes(void)
allocate a small bytes object
Definition: libsheepySmall.c:359
emptySmallDict
internal smallDictt * emptySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4685
forEachCCharP
#define forEachCCharP(list, element)
forEach for const char** lists
Definition: libsheepy.h:2985
getSmallIntSmallDictG
smallIntt * getSmallIntSmallDictG(smallDictt *self, smallIntt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6087
setBoolSmallDictG
smallDictt * setBoolSmallDictG(smallDictt *self, const char *key, bool value)
Definition: libsheepyCSmallDict.c:6434
setKCharSmallDictG
smallDictt * setKCharSmallDictG(smallDictt *self, char key, baset *value)
Definition: libsheepyCSmallDict.c:6529
setNFreeArrayKCharSmallDict
internal smallDictt * setNFreeArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1793
b
baset * b
Definition: libsheepyObjectTest.c:402
setIntSmallDictG
smallDictt * setIntSmallDictG(smallDictt *self, const char *key, int64_t value)
Definition: libsheepyCSmallDict.c:6444
setCharKCharSmallDictG
smallDictt * setCharKCharSmallDictG(smallDictt *self, char key, char c)
Definition: libsheepyCSmallDict.c:6559
delSmallDict
internal smallDictt * delSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3610
setNFreeSmallContainerSmallDictG
smallDictt * setNFreeSmallContainerSmallDictG(smallDictt *self, const char *key, smallContainert *container)
Definition: libsheepyCSmallDict.c:6685
getInt32PSmallDictG
int32_t * getInt32PSmallDictG(smallDictt *self, int32_t *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6032
mirrorSmallDict
internal smallDictt * mirrorSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1198
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
forEachS
#define forEachS(list, element)
forEach - loop macro on list indexes to access the element in the loop, use element ;size_t UNIQVAR n...
Definition: libsheepy.h:2994
forEachSmallArray
#define forEachSmallArray(array, element)
forEach - loop macro on list non NULL elements skip deleted elements
Definition: libsheepyCSmallArray.h:2424
sBytest
small bytes
Definition: libsheepySmall.h:181
getUintPKCharSmallDictG
uint64_t * getUintPKCharSmallDictG(smallDictt *self, uint64_t *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6167
icKeyByDictSmallDict
internal char * icKeyByDictSmallDict(smallDictt *self, smallDictt *dict)
Definition: libsheepyCSmallDict.c:4132
getNDupSmallJsonKCharSmallDict
internal smallJsont * getNDupSmallJsonKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2965
getNDupSmallJsonKCharSmallDictG
smallJsont * getNDupSmallJsonKCharSmallDictG(smallDictt *self, smallJsont *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6408
getSmallStringSmallDict
internal smallStringt * getSmallStringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2363
setSmallDoubleSmallDict
internal smallDictt * setSmallDoubleSmallDict(smallDictt *self, const char *key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:1437
cropElemSmallBytesSmallDict
internal smallBytest * cropElemSmallBytesSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3404
setNFreeSmallIntKCharSmallDict
internal smallDictt * setNFreeSmallIntKCharSmallDict(smallDictt *self, char key, smallIntt *value)
Definition: libsheepyCSmallDict.c:1823
setArraycKCharSmallDict
internal smallDictt * setArraycKCharSmallDict(smallDictt *self, char key, char **array)
Definition: libsheepyCSmallDict.c:1581
icKeyByCArraycSmallDictG
char * icKeyByCArraycSmallDictG(smallDictt *self, const char **array)
Definition: libsheepyCSmallDict.c:7157
isEUndefinedSmallDict
internal bool isEUndefinedSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5684
sStringGetTiny
char * sStringGetTiny(sStringt *string)
get string in a small string object
Definition: libsheepySmall.c:1538
cropElemUndefinedSmallDict
internal undefinedt * cropElemUndefinedSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3056
typeSmallStringKCharSmallDictG
smallStringt * typeSmallStringKCharSmallDictG(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:7332
cropElemBoolSmallDict
internal bool cropElemBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3082
getNumSmallDict
internal double getNumSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2990
smallBool::value
sBoolt * value
bool value
Definition: libsheepyCSmallBool.h:229
getDoubleKCharSmallDict
internal double getDoubleKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2440
getNDupDoubleSmallDict
internal double getNDupDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2615
setSmallStringSmallDict
internal smallDictt * setSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:1492
setNFreePDictKCharSmallDict
internal smallDictt * setNFreePDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:2027
iterKeySmallDict
internal const char * iterKeySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4879
setNFreeArraycSmallDictG
smallDictt * setNFreeArraycSmallDictG(smallDictt *self, const char *key, char **array)
Definition: libsheepyCSmallDict.c:6650
removeKCharSmallDict
internal smallDictt * removeKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:3641
getNDupUndefinedSmallDict
internal undefinedt * getNDupUndefinedSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2585
getBoolPSmallDictG
bool * getBoolPSmallDictG(smallDictt *self, bool *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6002
icKeyByArraySmallDictG
char * icKeyByArraySmallDictG(smallDictt *self, smallArrayt *array)
Definition: libsheepyCSmallDict.c:7147
mergeNSmashSmallDictG
smallDictt * mergeNSmashSmallDictG(smallDictt *self, smallDictt *smallDict)
Definition: libsheepyCSmallDict.c:6847
cropElemSmallStringSmallDictG
smallStringt * cropElemSmallStringSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6972
setPSmallJsonKCharSmallDict
internal smallDictt * setPSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *json)
Definition: libsheepyCSmallDict.c:2009
getTopTypeO
#define getTopTypeO(self)
Definition: libsheepyObject.h:8709
getVoidKCharSmallDict
internal void * getVoidKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2554
getNDupSmallBoolSmallDict
internal smallBoolt * getNDupSmallBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2723
areAllETypeSmallDict
internal bool areAllETypeSmallDict(smallDictt *self, const char *type)
Definition: libsheepyCSmallDict.c:5873
setSmallBytesKCharSmallDictG
smallDictt * setSmallBytesKCharSmallDictG(smallDictt *self, char key, smallBytest *value)
Definition: libsheepyCSmallDict.c:6595
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
sIntt
small int
Definition: libsheepySmall.h:128
resetSmallDict
internal void resetSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1174
isOType
#define isOType(obj, className)
test obj type
Definition: libsheepyObject.h:221
zipSmallDict
internal smallDictt * zipSmallDict(smallDictt *self, smallArrayt *keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:4884
icEqualSmallDictSmallJson
internal bool icEqualSmallDictSmallJson(smallDictt *self, smallJsont *p2)
Definition: libsheepyCSmallDict.c:4600
smallString::f
smallStringFunctionst * f
Definition: libsheepyCSmallString.h:1265
setKCharSmallDict
internal smallDictt * setKCharSmallDict(smallDictt *self, char key, baset *value)
Definition: libsheepyCSmallDict.c:1527
setSmallContainerSmallDict
internal smallDictt * setSmallContainerSmallDict(smallDictt *self, const char *key, smallContainert *container)
Definition: libsheepyCSmallDict.c:1510
isOSmallContainer
#define isOSmallContainer(obj)
test if obj type is smallContainer
Definition: libsheepyObject.h:245
cropElemSmallContainerSmallDictG
smallContainert * cropElemSmallContainerSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6982
zipSmallJsonVArraySmallDictG
smallDictt * zipSmallJsonVArraySmallDictG(smallDictt *self, smallJsont *keys, char **values)
Definition: libsheepyCSmallDict.c:7217
array
char * array[]
Definition: libsheepyObjectTest.c:1278
setPSmallStringSmallDict
internal smallDictt * setPSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:1903
finalizeRecycleSmallDict
void finalizeRecycleSmallDict(void *arg UNUSED)
Definition: libsheepyCSmallDict.c:991
elif
#define elif
elif definition as alternative to else if
Definition: libsheepy.h:589
setPDictSmallDict
internal smallDictt * setPDictSmallDict(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:1848
getSmallJsonSmallDictG
smallJsont * getSmallJsonSmallDictG(smallDictt *self, smallJsont *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6092
zipSmallJsonSmallDictG
smallDictt * zipSmallJsonSmallDictG(smallDictt *self, smallArrayt *keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:7202
isOUndefined
#define isOUndefined(obj)
test if obj type is undefined
Definition: libsheepyObject.h:281
sDuplicateTiny
smallt * sDuplicateTiny(smallt *obj)
duplicate small object
Definition: libsheepySmall.c:504
createAllocateSmallJson
#define createAllocateSmallJson(obj)
Definition: libsheepyCSmallJson.h:3519
setNFreeSmallBytesSmallDictG
smallDictt * setNFreeSmallBytesSmallDictG(smallDictt *self, const char *key, smallBytest *value)
Definition: libsheepyCSmallDict.c:6660
hasKCharSmallDictG
bool hasKCharSmallDictG(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:7032
removeSmallDict
internal smallDictt * removeSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3626
terminateO
#define terminateO(obj)
free buffers and obj itself
Definition: libsheepyObject.h:202
writeStreamSmallDict
internal bool writeStreamSmallDict(smallDictt *self, FILE *fp)
Definition: libsheepyCSmallDict.c:5521
setPSmallStringKCharSmallDict
internal smallDictt * setPSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:2015
setBoolKCharSmallDictG
smallDictt * setBoolKCharSmallDictG(smallDictt *self, char key, bool value)
Definition: libsheepyCSmallDict.c:6539
getBoolPKCharSmallDictG
bool * getBoolPKCharSmallDictG(smallDictt *self, bool *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6127
getSmallBoolKCharSmallDict
internal smallBoolt * getSmallBoolKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2518
setNFreeSmallBoolSmallDictG
smallDictt * setNFreeSmallBoolSmallDictG(smallDictt *self, const char *key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:6655
removeElemSmallDictG
smallDictt * removeElemSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:7017
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
getSmallIntKCharSmallDictG
smallIntt * getSmallIntKCharSmallDictG(smallDictt *self, smallIntt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6212
getBoolPSmallDict
internal bool * getBoolPSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2085
pErrorNULL
pErrorNULL(iPrependS(&ks, "[1]"))
zipCArrayArraySmallDict
internal smallDictt * zipCArrayArraySmallDict(smallDictt *self, const char **keys, char **values)
Definition: libsheepyCSmallDict.c:5221
setNFreeDictKCharSmallDict
internal smallDictt * setNFreeDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:1787
setNFreeSmallBoolSmallDict
internal smallDictt * setNFreeSmallBoolSmallDict(smallDictt *self, const char *key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:1706
equalSmallDictBaseG
bool equalSmallDictBaseG(smallDictt *self, baset *p2)
Definition: libsheepyCSmallDict.c:6857
isOSmallBytes
#define isOSmallBytes(obj)
test if obj type is smallBytes
Definition: libsheepyObject.h:239
getSmallBoolSmallDict
internal smallBoolt * getSmallBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2265
getUint32PKCharSmallDictG
uint32_t * getUint32PKCharSmallDictG(smallDictt *self, uint32_t *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6177
allocSContainer
sContainert * allocSContainer(void *data)
allocate a small container The container holds a pointer to a user buffer
Definition: libsheepySmall.c:239
setSmallJsonKCharSmallDictG
smallDictt * setSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *value)
Definition: libsheepyCSmallDict.c:6610
cropElemBoolSmallDictG
bool cropElemBoolSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6902
zipSmallJsonVCArraySmallDictG
smallDictt * zipSmallJsonVCArraySmallDictG(smallDictt *self, smallJsont *keys, const char **values)
Definition: libsheepyCSmallDict.c:7222
cropElemSmallBytesSmallDictG
smallBytest * cropElemSmallBytesSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6952
setNFreeSmallContainerKCharSmallDictG
smallDictt * setNFreeSmallContainerKCharSmallDictG(smallDictt *self, char key, smallContainert *container)
Definition: libsheepyCSmallDict.c:6750
logBtrace
#define logBtrace
Definition: libsheepy.h:3249
typeStringSmallDict
internal const char * typeStringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5573
areAllEContainerSmallDict
internal bool areAllEContainerSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5921
writeFileS
int writeFileS(const char *filePath, const char *string)
write string to file
Definition: libsheepy.c:4883
getDoublePKCharSmallDictG
double * getDoublePKCharSmallDictG(smallDictt *self, double *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6137
allocSUndefined
sUndefinedt * allocSUndefined(void)
allocate a small undefined object
Definition: libsheepySmall.c:345
setPDictKCharSmallDict
internal smallDictt * setPDictKCharSmallDict(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:2003
setNFreeDictKCharSmallDictG
smallDictt * setNFreeDictKCharSmallDictG(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6705
smallt::type
char type
Definition: libsheepySmall.h:68
setTopNFreeO
#define setTopNFreeO(self, value)
Definition: libsheepyObject.h:583
setSmallIntSmallDictG
smallDictt * setSmallIntSmallDictG(smallDictt *self, const char *key, smallIntt *value)
Definition: libsheepyCSmallDict.c:6509
getSmallDoubleKCharSmallDict
internal smallDoublet * getSmallDoubleKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2530
sBytest::count
uint32_t count
Definition: libsheepySmall.h:183
getDictKCharSmallDict
internal smallDictt * getDictKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2506
getKCharSmallDict
internal baset * getKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2416
getDictKCharSmallDictG
smallDictt * getDictKCharSmallDictG(smallDictt *self, smallDictt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6187
getNDupSmallDoubleKCharSmallDict
internal smallDoublet * getNDupSmallDoubleKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2953
setPDictSmallDictG
smallDictt * setPDictSmallDictG(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6756
setDoubleSmallDictG
smallDictt * setDoubleSmallDictG(smallDictt *self, const char *key, double value)
Definition: libsheepyCSmallDict.c:6439
setNFreeArraycKCharSmallDictG
smallDictt * setNFreeArraycKCharSmallDictG(smallDictt *self, char key, char **array)
Definition: libsheepyCSmallDict.c:6715
setNFreeSmallDoubleKCharSmallDict
internal smallDictt * setNFreeSmallDoubleKCharSmallDict(smallDictt *self, char key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:1817
icKeyByArraycSmallDict
internal char * icKeyByArraycSmallDict(smallDictt *self, char **array)
Definition: libsheepyCSmallDict.c:4192
setArrayKCharSmallDictG
smallDictt * setArrayKCharSmallDictG(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6569
setSmallContainerSmallDictG
smallDictt * setSmallContainerSmallDictG(smallDictt *self, const char *key, smallContainert *container)
Definition: libsheepyCSmallDict.c:6524
getIntKCharSmallDictG
int64_t getIntKCharSmallDictG(smallDictt *self, int64_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6142
setNFreeUndefinedKCharSmallDictG
smallDictt * setNFreeUndefinedKCharSmallDictG(smallDictt *self, char key, undefinedt *u)
Definition: libsheepyCSmallDict.c:6695
helpSmallDict
internal const char * helpSmallDict(smallDictt UNUSED *self)
Definition: libsheepyCSmallDict.c:1169
getArrayKCharSmallDictG
smallArrayt * getArrayKCharSmallDictG(smallDictt *self, smallArrayt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6192
removeElemKCharSmallDictG
smallDictt * removeElemKCharSmallDictG(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:7022
cropElemSmallJsonSmallDict
internal smallJsont * cropElemSmallJsonSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3488
zipCArraySmallDictG
smallDictt * zipCArraySmallDictG(smallDictt *self, const char **keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:7237
isEDoubleSmallDict
internal bool isEDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5760
getDoubleSmallDict
internal double getDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2097
getNDupSmallContainerKCharSmallDict
internal smallContainert * getNDupSmallContainerKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2983
icKeyByCharSmallDict
internal char * icKeyByCharSmallDict(smallDictt *self, char c)
Definition: libsheepyCSmallDict.c:4126
setSmallDict
internal smallDictt * setSmallDict(smallDictt *self, const char *key, baset *value)
Definition: libsheepyCSmallDict.c:1224
mergeSmallDict
internal smallDictt * mergeSmallDict(smallDictt *self, smallDictt *smallDict)
Definition: libsheepyCSmallDict.c:4399
keyBySmallIntSmallDictG
char * keyBySmallIntSmallDictG(smallDictt *self, smallIntt *value)
Definition: libsheepyCSmallDict.c:7107
fromArraySmallDict
internal smallDictt * fromArraySmallDict(smallDictt *self, smallArrayt *items)
Definition: libsheepyCSmallDict.c:5419
smallStringFunctionst::toString
toStringSmallStringFt toString
Definition: libsheepyCSmallString.h:1253
setSmallIntKCharSmallDict
internal smallDictt * setSmallIntKCharSmallDict(smallDictt *self, char key, smallIntt *value)
Definition: libsheepyCSmallDict.c:1611
iterStartSmallDict
internal baset * iterStartSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4734
setDoubleKCharSmallDictG
smallDictt * setDoubleKCharSmallDictG(smallDictt *self, char key, double value)
Definition: libsheepyCSmallDict.c:6544
appendFileSmallStringSmallDictG
bool appendFileSmallStringSmallDictG(smallDictt *self, smallStringt *filePath)
Definition: libsheepyCSmallDict.c:7312
equalSmallDict
internal bool equalSmallDict(smallDictt *self, smallDictt *p2)
Definition: libsheepyCSmallDict.c:4541
typeStringKCharSmallDict
internal const char * typeStringKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:5600
getNDupDoubleKCharSmallDictG
double getNDupDoubleKCharSmallDictG(smallDictt *self, double retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6348
getNDupSSmallDict
internal char * getNDupSSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2675
getDictSmallDict
internal smallDictt * getDictSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2229
getNDupInt32SmallDictG
int32_t getNDupInt32SmallDictG(smallDictt *self, int32_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6263
icKeyBySmallDictG
char * icKeyBySmallDictG(smallDictt *self, baset *value)
Definition: libsheepyCSmallDict.c:7127
logSmallDictG
void logSmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7317
fp
END_TEST FILE * fp
Definition: libsheepyObjectTest.c:2195
setsoSmallDict
internal void setsoSmallDict(smallDictt *self, sDictt *so)
Definition: libsheepyCSmallDict.c:1192
setSmallDoubleSmallDictG
smallDictt * setSmallDoubleSmallDictG(smallDictt *self, const char *key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:6504
getBoolSmallDictG
bool getBoolSmallDictG(smallDictt *self, bool retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:5997
setNFreePSmallStringSmallDict
internal smallDictt * setNFreePSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:1978
getDoubleKCharSmallDictG
double getDoubleKCharSmallDictG(smallDictt *self, double retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6132
setNFreeSmallContainerKCharSmallDict
internal smallDictt * setNFreeSmallContainerKCharSmallDict(smallDictt *self, char key, smallContainert *container)
Definition: libsheepyCSmallDict.c:1841
setBoolSmallDict
internal smallDictt * setBoolSmallDict(smallDictt *self, const char *key, bool value)
Definition: libsheepyCSmallDict.c:1251
getSmallContainerKCharSmallDictG
smallContainert * getSmallContainerKCharSmallDictG(smallDictt *self, smallContainert *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6232
finalizeSmallDict
void finalizeSmallDict(void)
Definition: libsheepyCSmallDict.c:999
getNDupSmallJsonSmallDict
internal smallJsont * getNDupSmallJsonSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2795
cropElemSmallDoubleSmallDict
internal smallDoublet * cropElemSmallDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3432
icKeyByArraySmallDict
internal char * icKeyByArraySmallDict(smallDictt *self, smallArrayt *array)
Definition: libsheepyCSmallDict.c:4162
getSmallStringKCharSmallDict
internal smallStringt * getSmallStringKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2548
cast
#define cast(type, casted, toCast)
define variable and cast pointer
Definition: libsheepy.h:617
zipArraySmallDict
internal smallDictt * zipArraySmallDict(smallDictt *self, char **keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:5067
isEArraySmallDict
internal bool isEArraySmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5836
setCArraycSmallDictG
smallDictt * setCArraycSmallDictG(smallDictt *self, const char *key, const char **array)
Definition: libsheepyCSmallDict.c:6474
getNDupUintKCharSmallDict
internal uint64_t getNDupUintKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2911
setNFreeSmallBytesKCharSmallDictG
smallDictt * setNFreeSmallBytesKCharSmallDictG(smallDictt *self, char key, smallBytest *value)
Definition: libsheepyCSmallDict.c:6725
initiateAllocateSmallDict
void initiateAllocateSmallDict(smallDictt **self)
Definition: libsheepyCSmallDict.c:973
c
char c
Definition: libsheepyObjectTest.c:246
setNFreeSmallBoolKCharSmallDict
internal smallDictt * setNFreeSmallBoolKCharSmallDict(smallDictt *self, char key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:1805
valuesSmallDict
internal smallArrayt * valuesSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4378
delKCharSmallDictG
smallDictt * delKCharSmallDictG(smallDictt *self, char key, int unused UNUSED)
Definition: libsheepyCSmallDict.c:6992
setNFreeKCharSmallDict
internal smallDictt * setNFreeKCharSmallDict(smallDictt *self, char key, baset *value)
Definition: libsheepyCSmallDict.c:1769
zipCArrayCArraySmallDict
internal smallDictt * zipCArrayCArraySmallDict(smallDictt *self, const char **keys, const char **values)
Definition: libsheepyCSmallDict.c:5293
setNFreeSmallContainerSmallDict
internal smallDictt * setNFreeSmallContainerSmallDict(smallDictt *self, const char *key, smallContainert *container)
Definition: libsheepyCSmallDict.c:1760
zipArrayCArraySmallDictG
smallDictt * zipArrayCArraySmallDictG(smallDictt *self, char **keys, const char **values)
Definition: libsheepyCSmallDict.c:7257
toStringO
#define toStringO(obj)
convert data in obj to string
Definition: libsheepyObject.h:346
setDictSmallDictG
smallDictt * setDictSmallDictG(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6459
writeStreamSmallDictG
bool writeStreamSmallDictG(smallDictt *self, FILE *fp)
Definition: libsheepyCSmallDict.c:7302
setNFreeArraycKCharSmallDict
internal smallDictt * setNFreeArraycKCharSmallDict(smallDictt *self, char key, char **array)
Definition: libsheepyCSmallDict.c:1799
freeSmallDictG
void freeSmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:5979
getNDupDictSmallDictG
smallDictt * getNDupDictSmallDictG(smallDictt *self, smallDictt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6283
isETypeSmallDict
internal bool isETypeSmallDict(smallDictt *self, const char *key, const char *type)
Definition: libsheepyCSmallDict.c:5665
setNFreeSmallStringKCharSmallDictG
smallDictt * setNFreeSmallStringKCharSmallDictG(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6745
getNDupUndefinedKCharSmallDictG
undefinedt * getNDupUndefinedKCharSmallDictG(smallDictt *self, undefinedt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6338
getUndefinedSmallDict
internal undefinedt * getUndefinedSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2055
removeElemO
#define removeElemO(self, index)
Definition: libsheepyObject.h:2982
keyBySmallDict
internal char * keyBySmallDict(smallDictt *self, baset *value)
Definition: libsheepyCSmallDict.c:3672
cropElemVoidSmallDict
internal void * cropElemVoidSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3548
keyByArraycSmallDict
internal char * keyByArraycSmallDict(smallDictt *self, char **array)
Definition: libsheepyCSmallDict.c:3847
setArraycSmallDict
internal smallDictt * setArraycSmallDict(smallDictt *self, const char *key, char **array)
Definition: libsheepyCSmallDict.c:1351
getSmallDictG
baset * getSmallDictG(smallDictt *self, baset *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:5987
cropElemSmallIntSmallDict
internal smallIntt * cropElemSmallIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3460
setNFreeArraycSmallDict
internal smallDictt * setNFreeArraycSmallDict(smallDictt *self, const char *key, char **array)
Definition: libsheepyCSmallDict.c:1697
getNDupSmallIntKCharSmallDictG
smallIntt * getNDupSmallIntKCharSmallDictG(smallDictt *self, smallIntt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6403
setCArraycKCharSmallDictG
smallDictt * setCArraycKCharSmallDictG(smallDictt *self, char key, const char **array)
Definition: libsheepyCSmallDict.c:6579
getNDupSmallContainerKCharSmallDictG
smallContainert * getNDupSmallContainerKCharSmallDictG(smallDictt *self, smallContainert *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6423
zipSmallDictG
smallDictt * zipSmallDictG(smallDictt *self, smallArrayt *keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:7197
getSmallStringSmallDictG
smallStringt * getSmallStringSmallDictG(smallDictt *self, smallStringt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6097
setVoidKCharSmallDictG
smallDictt * setVoidKCharSmallDictG(smallDictt *self, char key, void *value)
Definition: libsheepyCSmallDict.c:6584
setSmallIntSmallDict
internal smallDictt * setSmallIntSmallDict(smallDictt *self, const char *key, smallIntt *value)
Definition: libsheepyCSmallDict.c:1454
allocSDict
sDictt * allocSDict(void)
allocate a small dict
Definition: libsheepySmall.c:256
getSmallBytesSmallDictG
smallBytest * getSmallBytesSmallDictG(smallDictt *self, smallBytest *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6077
getSSmallDict
internal char * getSSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2217
setUndefinedKCharSmallDictG
smallDictt * setUndefinedKCharSmallDictG(smallDictt *self, char key, undefinedt *value UNUSED)
Definition: libsheepyCSmallDict.c:6534
getNDupSSmallDictG
char * getNDupSSmallDictG(smallDictt *self, char *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6278
smallContainer::data
sContainert * data
pointer to data in smallContainer
Definition: libsheepyCSmallContainer.h:196
icEqualSmallDictBase
internal bool icEqualSmallDictBase(smallDictt *self, baset *p2)
Definition: libsheepyCSmallDict.c:4588
keyByDoubleSmallDictG
char * keyByDoubleSmallDictG(smallDictt *self, double value)
Definition: libsheepyCSmallDict.c:7052
cleanUpSmallDictFreeLocalG
void cleanUpSmallDictFreeLocalG(smallDictt *val)
Definition: libsheepyCSmallDict.c:1023
getNDupSmallDoubleSmallDict
internal smallDoublet * getNDupSmallDoubleSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2759
setPSmallJsonSmallDictG
smallDictt * setPSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *json)
Definition: libsheepyCSmallDict.c:6766
getSmallStringKCharSmallDictG
smallStringt * getSmallStringKCharSmallDictG(smallDictt *self, smallStringt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6222
setNFreeSmallIntSmallDict
internal smallDictt * setNFreeSmallIntSmallDict(smallDictt *self, const char *key, smallIntt *value)
Definition: libsheepyCSmallDict.c:1733
setNFreePDictSmallDict
internal smallDictt * setNFreePDictSmallDict(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:1920
keyByArraySmallDict
internal char * keyByArraySmallDict(smallDictt *self, smallArrayt *array)
Definition: libsheepyCSmallDict.c:3817
setNFreeKCharSmallDictG
smallDictt * setNFreeKCharSmallDictG(smallDictt *self, char key, baset *value)
Definition: libsheepyCSmallDict.c:6690
emptySmallDictG
smallDictt * emptySmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7187
getSmallContainerSmallDict
internal smallContainert * getSmallContainerSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2393
getNDupSmallStringKCharSmallDictG
smallStringt * getNDupSmallStringKCharSmallDictG(smallDictt *self, smallStringt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6413
S
smallStringt * S
Definition: libsheepyObjectTest.c:2009
getNDupInt32KCharSmallDict
internal int32_t getNDupInt32KCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2905
keyByCharSmallDict
internal char * keyByCharSmallDict(smallDictt *self, char c)
Definition: libsheepyCSmallDict.c:3781
zipSmallJsonSmallJsonSmallDict
internal smallDictt * zipSmallJsonSmallJsonSmallDict(smallDictt *self, smallJsont *keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:4980
sDictGetTiny
smallt * sDictGetTiny(sDictt *dict, const char *key)
get object stored at key
Definition: libsheepySmall.c:1357
getDoublePKCharSmallDict
internal double * getDoublePKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2446
setSmallStringKCharSmallDict
internal smallDictt * setSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:1623
cleanUpSmallDictSmashG
void cleanUpSmallDictSmashG(smallDictt **val)
Definition: libsheepyCSmallDict.c:1043
o
smallDictt * o
Definition: libsheepyObjectTest.c:31
getIntPKCharSmallDict
internal int64_t * getIntPKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2458
getNDupArraySmallDict
internal smallArrayt * getNDupArraySmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2705
icKeyBySSmallDictG
char * icKeyBySSmallDictG(smallDictt *self, const char *string)
Definition: libsheepyCSmallDict.c:7132
getNDupUndefinedKCharSmallDict
internal undefinedt * getNDupUndefinedKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2881
getNDupUint32SmallDict
internal uint32_t getNDupUint32SmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2663
smallContainer::f
smallContainerFunctionst * f
Definition: libsheepyCSmallContainer.h:193
getDoubleSmallDictG
double getDoubleSmallDictG(smallDictt *self, double retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6007
getNDupSmallJsonSmallDictG
smallJsont * getNDupSmallJsonSmallDictG(smallDictt *self, smallJsont *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6313
getSmallBytesKCharSmallDictG
smallBytest * getSmallBytesKCharSmallDictG(smallDictt *self, smallBytest *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6202
getNDupKCharSmallDictG
baset * getNDupKCharSmallDictG(smallDictt *self, baset *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6333
toStringListSGF
char * toStringListSGF(char **object)
Definition: libsheepyObject.c:1279
getBoolKCharSmallDictG
bool getBoolKCharSmallDictG(smallDictt *self, bool retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6122
duplicateSmallDictG
smallDictt * duplicateSmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:5974
toBaset
baset * toBaset(smallt *obj)
convert smallt object to baset
Definition: libsheepyObject.c:5499
getNDupIntKCharSmallDict
internal int64_t getNDupIntKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2899
getUint32KCharSmallDict
internal uint32_t getUint32KCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2488
getNDupSmallContainerSmallDict
internal smallContainert * getNDupSmallContainerSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2850
setSmallBytesSmallDict
internal smallDictt * setSmallBytesSmallDict(smallDictt *self, const char *key, smallBytest *value)
Definition: libsheepyCSmallDict.c:1420
disposeO
#define disposeO(self)
Definition: libsheepyObject.h:7497
setNFreeDictSmallDictG
smallDictt * setNFreeDictSmallDictG(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6640
areAllEBytesSmallDict
internal bool areAllEBytesSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5963
setNFreeSSmallDict
internal smallDictt * setNFreeSSmallDict(smallDictt *self, const char *key, char *string)
Definition: libsheepyCSmallDict.c:1670
isOSmallDouble
#define isOSmallDouble(obj)
test if obj type is smallDouble
Definition: libsheepyObject.h:257
sDictPushTiny
void sDictPushTiny(sDictt **dict, const char *key, smallt *data)
push new key-value
Definition: libsheepySmall.c:1468
setNFreeSmallBytesSmallDict
internal smallDictt * setNFreeSmallBytesSmallDict(smallDictt *self, const char *key, smallBytest *value)
Definition: libsheepyCSmallDict.c:1715
getNDupUintSmallDict
internal uint64_t getNDupUintSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2651
sBytesGet
void * sBytesGet(sBytest *bytes)
get buffer in small bytes
Definition: libsheepySmall.c:1852
equalSmallDictG
bool equalSmallDictG(smallDictt *self, smallDictt *p2)
Definition: libsheepyCSmallDict.c:6867
delElemSmallDictG
smallDictt * delElemSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6997
getNDupVoidKCharSmallDictG
void * getNDupVoidKCharSmallDictG(smallDictt *self, void *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6418
keysSmallStringSmallDict
internal smallArrayt * keysSmallStringSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4366
cropElemUintSmallDict
internal uint64_t cropElemUintSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3218
getNDupVoidKCharSmallDict
internal void * getNDupVoidKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2977
keyBySmallContainerSmallDict
internal char * keyBySmallContainerSmallDict(smallDictt *self, smallContainert *container)
Definition: libsheepyCSmallDict.c:4072
getNDupSmallIntSmallDict
internal smallIntt * getNDupSmallIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2777
setIntSmallDict
internal smallDictt * setIntSmallDict(smallDictt *self, const char *key, int64_t value)
Definition: libsheepyCSmallDict.c:1279
allocSDouble
sDoublet * allocSDouble(double value)
allocate a small double
Definition: libsheepySmall.c:274
keyBySmallStringSmallDict
internal char * keyBySmallStringSmallDict(smallDictt *self, smallStringt *string)
Definition: libsheepyCSmallDict.c:4046
getUint32PSmallDict
internal uint32_t * getUint32PSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2205
isOSmallDict
#define isOSmallDict(obj)
test if obj type is smallDictt
Definition: libsheepyObject.h:251
getSmallBytesKCharSmallDict
internal smallBytest * getSmallBytesKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2524
typeStringKCharSmallDictG
const char * typeStringKCharSmallDictG(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:7327
getNDupVoidSmallDict
internal void * getNDupVoidSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2838
zipCArraySmallDict
internal smallDictt * zipCArraySmallDict(smallDictt *self, const char **keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:5102
BLD
#define BLD
bold for color function
Definition: libsheepy.h:765
zipSmallJsonSmallArraySmallDictG
smallDictt * zipSmallJsonSmallArraySmallDictG(smallDictt *self, smallJsont *keys, smallArrayt *values)
Definition: libsheepyCSmallDict.c:7207
getUintPKCharSmallDict
internal uint64_t * getUintPKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2482
icKeyBySmallStringSmallDict
internal char * icKeyBySmallStringSmallDict(smallDictt *self, smallStringt *string)
Definition: libsheepyCSmallDict.c:4302
getSmallDoubleKCharSmallDictG
smallDoublet * getSmallDoubleKCharSmallDictG(smallDictt *self, smallDoublet *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6207
dupS
char * dupS(const char *string)
duplicate string
Definition: libsheepy.c:6548
setPArraySmallDictG
smallDictt * setPArraySmallDictG(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6761
cropElemSmallJsonSmallDictG
smallJsont * cropElemSmallJsonSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6967
setsoO
#define setsoO(self, so)
Definition: libsheepyObject.h:7509
setSmallContainerKCharSmallDictG
smallDictt * setSmallContainerKCharSmallDictG(smallDictt *self, char key, smallContainert *container)
Definition: libsheepyCSmallDict.c:6620
zipArrayArraySmallDictG
smallDictt * zipArrayArraySmallDictG(smallDictt *self, char **keys, char **values)
Definition: libsheepyCSmallDict.c:7247
smallDictFunctionst::toString
toStringSmallDictFt toString
Definition: libsheepyCSmallDict.h:1058
allocSmallDict
smallDictt * allocSmallDict(void)
Definition: libsheepyCSmallDict.c:1008
cropElemInt32SmallDictG
int32_t cropElemInt32SmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6917
getNDupSmallBytesKCharSmallDictG
smallBytest * getNDupSmallBytesKCharSmallDictG(smallDictt *self, smallBytest *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6393
icEqualSmallDictBaseG
bool icEqualSmallDictBaseG(smallDictt *self, baset *p2)
Definition: libsheepyCSmallDict.c:6872
setPArrayKCharSmallDictG
smallDictt * setPArrayKCharSmallDictG(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6796
createSmallArray
END_TEST createSmallArray(obj)
getNDupSmallContainerSmallDictG
smallContainert * getNDupSmallContainerSmallDictG(smallDictt *self, smallContainert *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6328
isEContainerSmallDict
internal bool isEContainerSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5722
removeSmallDictG
smallDictt * removeSmallDictG(smallDictt *self, const char *key, int unused UNUSED)
Definition: libsheepyCSmallDict.c:7007
appendNSmashSmallDict
internal smallDictt * appendNSmashSmallDict(smallDictt *self, smallDictt *smallDict)
Definition: libsheepyCSmallDict.c:4499
listLengthCS
size_t listLengthCS(const char **list)
const list Length String return number of elements until the first NULL element
Definition: libsheepy.c:50843
getUint32PSmallDictG
uint32_t * getUint32PSmallDictG(smallDictt *self, uint32_t *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6052
strEq
#define strEq
Definition: libsheepy.h:2018
setNFreePDictSmallDictG
smallDictt * setNFreePDictSmallDictG(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6776
icEqualSmallDictG
bool icEqualSmallDictG(smallDictt *self, smallDictt *p2)
Definition: libsheepyCSmallDict.c:6882
keyBySmallBytesSmallDict
internal char * keyBySmallBytesSmallDict(smallDictt *self, smallBytest *value)
Definition: libsheepyCSmallDict.c:3921
getNDupArrayKCharSmallDictG
smallArrayt * getNDupArrayKCharSmallDictG(smallDictt *self, smallArrayt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6383
getUintPSmallDictG
uint64_t * getUintPSmallDictG(smallDictt *self, uint64_t *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6042
json
initiateAllocateSmallJson & json
Definition: libsheepyObjectTest.c:911
disposeSmallDict
internal void disposeSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1106
setNFreeDictSmallDict
internal smallDictt * setNFreeDictSmallDict(smallDictt *self, const char *key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:1679
enumerateSmallDictF
internal void enumerateSmallDictF(smallDictt *self, void *closure, enumerateElementSmallDictFt funcElem)
Definition: libsheepyCSmallDict.c:4710
getNDupUint32KCharSmallDictG
uint32_t getNDupUint32KCharSmallDictG(smallDictt *self, uint32_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6368
a
smallArrayt * a
Definition: libsheepyObjectTest.c:2316
setPSmallStringSmallDictG
smallDictt * setPSmallStringSmallDictG(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6771
value
in value value
Definition: libsheepyObjectTest.c:1363
keyByUndefinedSmallDictG
char * keyByUndefinedSmallDictG(smallDictt *self, undefinedt *u)
Definition: libsheepyCSmallDict.c:7042
isOSmallBool
#define isOSmallBool(obj)
test if obj type is smallBool
Definition: libsheepyObject.h:233
forEachSDict
#define forEachSDict(dict, element)
Definition: libsheepySmall.h:260
getNDupBoolKCharSmallDict
internal bool getNDupBoolKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2887
isEBytesSmallDict
internal bool isEBytesSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5855
zipArrayCArraySmallDict
internal smallDictt * zipArrayCArraySmallDict(smallDictt *self, char **keys, const char **values)
Definition: libsheepyCSmallDict.c:5257
typeSmallStringKCharSmallDict
internal smallStringt * typeSmallStringKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:5606
writeFileSmallStringSmallDictG
bool writeFileSmallStringSmallDictG(smallDictt *self, smallStringt *filePath)
Definition: libsheepyCSmallDict.c:7297
getInt32PSmallDict
internal int32_t * getInt32PSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2157
getInt32PKCharSmallDict
internal int32_t * getInt32PKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2470
setVoidSmallDictG
smallDictt * setVoidSmallDictG(smallDictt *self, const char *key, void *value)
Definition: libsheepyCSmallDict.c:6479
getNDupDoubleSmallDictG
double getNDupDoubleSmallDictG(smallDictt *self, double retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6253
sDictt
dictionary
Definition: libsheepySmall.h:109
duplicateSmallDict
internal smallDictt * duplicateSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:1068
getIntPSmallDictG
int64_t * getIntPSmallDictG(smallDictt *self, int64_t *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6022
setPDictKCharSmallDictG
smallDictt * setPDictKCharSmallDictG(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6801
cropElemDictSmallDict
internal smallDictt * cropElemDictSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3320
smallDict::f
smallDictFunctionst * f
Definition: libsheepyCSmallDict.h:1070
writeFileSmallJsonSmallDictG
bool writeFileSmallJsonSmallDictG(smallDictt *self, smallJsont *filePath)
Definition: libsheepyCSmallDict.c:7292
logSmallDict
internal void logSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5556
setNFreeUndefinedKCharSmallDict
internal smallDictt * setNFreeUndefinedKCharSmallDict(smallDictt *self, char key, undefinedt *u)
Definition: libsheepyCSmallDict.c:1775
smashSmallDict
internal void smashSmallDict(smallDictt **self)
Definition: libsheepyCSmallDict.c:1124
zipCArraySmallJsonSmallDictG
smallDictt * zipCArraySmallJsonSmallDictG(smallDictt *self, const char **keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:7242
setSmallIntKCharSmallDictG
smallDictt * setSmallIntKCharSmallDictG(smallDictt *self, char key, smallIntt *value)
Definition: libsheepyCSmallDict.c:6605
cropElemSSmallDictG
char * cropElemSSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6932
getNDupSKCharSmallDict
internal char * getNDupSKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2923
sStringt
small string
Definition: libsheepySmall.h:136
sToStringTiny
char * sToStringTiny(smallt *obj)
stringify a small object
Definition: libsheepySmall.c:606
setSmallBoolKCharSmallDictG
smallDictt * setSmallBoolKCharSmallDictG(smallDictt *self, char key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:6590
zipVArraySmallDict
internal smallDictt * zipVArraySmallDict(smallDictt *self, smallArrayt *keys, char **values)
Definition: libsheepyCSmallDict.c:5329
getKCharSmallDictG
baset * getKCharSmallDictG(smallDictt *self, baset *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6112
cropElemInt32SmallDict
internal int32_t cropElemInt32SmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3184
keyBySmallIntSmallDict
internal char * keyBySmallIntSmallDict(smallDictt *self, smallIntt *value)
Definition: libsheepyCSmallDict.c:3966
setNFreeUndefinedSmallDictG
smallDictt * setNFreeUndefinedSmallDictG(smallDictt *self, const char *key, undefinedt *value)
Definition: libsheepyCSmallDict.c:6630
smallDictFunctionst::finish
finishSmallDictFt finish
Definition: libsheepyCSmallDict.h:1061
writeFileSmallStringSmallDict
internal bool writeFileSmallStringSmallDict(smallDictt *self, smallStringt *filePath)
Definition: libsheepyCSmallDict.c:5508
allocUndefined
undefinedt * allocUndefined(void)
Definition: libsheepyCUndefined.c:107
cropElemSmallDoubleSmallDictG
smallDoublet * cropElemSmallDoubleSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6957
keyByIntSmallDictG
char * keyByIntSmallDictG(smallDictt *self, int64_t value)
Definition: libsheepyCSmallDict.c:7057
getNDupSmallDict
internal baset * getNDupSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2566
helpTextSmallDict
#define helpTextSmallDict
help text for this class It is public declaration so that child classes can add their help text easil...
Definition: libsheepyCSmallDict.h:34
setPSmallJsonKCharSmallDictG
smallDictt * setPSmallJsonKCharSmallDictG(smallDictt *self, char key, smallJsont *json)
Definition: libsheepyCSmallDict.c:6806
sBoolt
small bool
Definition: libsheepySmall.h:74
keyBySmallBytesSmallDictG
char * keyBySmallBytesSmallDictG(smallDictt *self, smallBytest *value)
Definition: libsheepyCSmallDict.c:7097
cropElemUndefinedSmallDictG
undefinedt * cropElemUndefinedSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6897
getBoolKCharSmallDict
internal bool getBoolKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2428
setNFreeSmallStringKCharSmallDict
internal smallDictt * setNFreeSmallStringKCharSmallDict(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:1835
appendFileS
bool appendFileS(const char *filePath, const char *string)
append string to filePath
Definition: libsheepy.c:5023
smallJson::f
smallJsonFunctionst * f
Definition: libsheepyCSmallJson.h:3487
getSKCharSmallDict
internal char * getSKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2500
smallDictFunctionst::duplicate
duplicateSmallDictFt duplicate
Definition: libsheepyCSmallDict.h:1059
getNDupSmallDoubleSmallDictG
smallDoublet * getNDupSmallDoubleSmallDictG(smallDictt *self, smallDoublet *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6303
lenSmallDict
internal size_t lenSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4668
getInt32SmallDictG
int32_t getInt32SmallDictG(smallDictt *self, int32_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6027
setSmallJsonKCharSmallDict
internal smallDictt * setSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *value)
Definition: libsheepyCSmallDict.c:1617
setNFreeSKCharSmallDict
internal smallDictt * setNFreeSKCharSmallDict(smallDictt *self, char key, char *string)
Definition: libsheepyCSmallDict.c:1781
toSmallt
smallt * toSmallt(baset *obj)
convert baset object to smallt
Definition: libsheepyObject.c:5426
appendFileSmallDict
internal bool appendFileSmallDict(smallDictt *self, const char *filePath)
Definition: libsheepyCSmallDict.c:5532
setArraySmallDictG
smallDictt * setArraySmallDictG(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6464
setNFreeSSmallDictG
smallDictt * setNFreeSSmallDictG(smallDictt *self, const char *key, char *string)
Definition: libsheepyCSmallDict.c:6635
setSmallDoubleKCharSmallDictG
smallDictt * setSmallDoubleKCharSmallDictG(smallDictt *self, char key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:6600
setSmallJsonSmallDictG
smallDictt * setSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *value)
Definition: libsheepyCSmallDict.c:6514
getNDupBoolSmallDict
internal bool getNDupBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2603
UNUSED
#define UNUSED
Definition: libsheepy.h:8195
sDictDelTiny
void sDictDelTiny(sDictt *dict, const char *key)
delete dictionary element
Definition: libsheepySmall.c:1518
getNDupBoolSmallDictG
bool getNDupBoolSmallDictG(smallDictt *self, bool retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6248
allocSBool
sBoolt * allocSBool(bool value)
allocate a small bool
Definition: libsheepySmall.c:221
cleanUpSmallDictFreeG
void cleanUpSmallDictFreeG(smallDictt **val)
Definition: libsheepyCSmallDict.c:1028
zipArraySmallJsonSmallDict
internal smallDictt * zipArraySmallJsonSmallDict(smallDictt *self, char **keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:5137
getIntPSmallDict
internal int64_t * getIntPSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2133
keyBySmallStringSmallDictG
char * keyBySmallStringSmallDictG(smallDictt *self, smallStringt *string)
Definition: libsheepyCSmallDict.c:7117
getNDupIntKCharSmallDictG
int64_t getNDupIntKCharSmallDictG(smallDictt *self, int64_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6353
writeFileSmallJsonSmallDict
internal bool writeFileSmallJsonSmallDict(smallDictt *self, smallJsont *filePath)
Definition: libsheepyCSmallDict.c:5489
cropElemIntSmallDict
internal int64_t cropElemIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3150
sArrayFreeTiny
void sArrayFreeTiny(sArrayt *array)
free array elements and array object
Definition: libsheepySmall.c:470
setDictKCharSmallDictG
smallDictt * setDictKCharSmallDictG(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6564
cropElemUintSmallDictG
uint64_t cropElemUintSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6922
getNDupSmallBoolSmallDictG
smallBoolt * getNDupSmallBoolSmallDictG(smallDictt *self, smallBoolt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6293
isEmptySmallDictG
bool isEmptySmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7192
setSKCharSmallDict
internal smallDictt * setSKCharSmallDict(smallDictt *self, char key, const char *string)
Definition: libsheepyCSmallDict.c:1557
getSmallIntKCharSmallDict
internal smallIntt * getSmallIntKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2536
mergeSmallDictG
smallDictt * mergeSmallDictG(smallDictt *self, smallDictt *smallDict)
Definition: libsheepyCSmallDict.c:6837
forEachCharP
#define forEachCharP(list, element)
forEach - loop macro on list indexes to access the element in the loop, use *element ...
Definition: libsheepy.h:2979
getVoidKCharSmallDictG
void * getVoidKCharSmallDictG(smallDictt *self, void *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6227
getUint32SmallDictG
uint32_t getUint32SmallDictG(smallDictt *self, uint32_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6047
setCArraycSmallDict
internal smallDictt * setCArraycSmallDict(smallDictt *self, const char *key, const char **array)
Definition: libsheepyCSmallDict.c:1377
cropElemSmallBoolSmallDictG
smallBoolt * cropElemSmallBoolSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6947
sDictSetTiny
void sDictSetTiny(sDictt **dict, const char *key, smallt *data)
dictionary set key, value
Definition: libsheepySmall.c:1426
allocSmallString
smallStringt * allocSmallString(const char *string)
Definition: libsheepyCSmallString.c:827
keyByDictSmallDictG
char * keyByDictSmallDictG(smallDictt *self, smallDictt *dict)
Definition: libsheepyCSmallDict.c:7072
getUndefinedKCharSmallDict
internal undefinedt * getUndefinedKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2422
setNFreePDictKCharSmallDictG
smallDictt * setNFreePDictKCharSmallDictG(smallDictt *self, char key, smallDictt *dict)
Definition: libsheepyCSmallDict.c:6821
keysSmallStringSmallDictG
smallArrayt * keysSmallStringSmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7177
getTopO
#define getTopO(self)
Definition: libsheepyObject.h:601
setNFreeSmallStringSmallDict
internal smallDictt * setNFreeSmallStringSmallDict(smallDictt *self, const char *key, smallStringt *string)
Definition: libsheepyCSmallDict.c:1751
keyByIntSmallDict
internal char * keyByIntSmallDict(smallDictt *self, int64_t value)
Definition: libsheepyCSmallDict.c:3750
getNDupSKCharSmallDictG
char * getNDupSKCharSmallDictG(smallDictt *self, char *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6373
smallBool::f
smallBoolFunctionst * f
Definition: libsheepyCSmallBool.h:226
getNDupBoolKCharSmallDictG
bool getNDupBoolKCharSmallDictG(smallDictt *self, bool retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6343
getValO
#define getValO(self)
get value in smallBool, smallBytes, smallDouble, smallInt, smallString
Definition: libsheepyObject.h:474
getNDupUint32KCharSmallDict
internal uint32_t getNDupUint32KCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2917
zipArraySmallJsonSmallDictG
smallDictt * zipArraySmallJsonSmallDictG(smallDictt *self, char **keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:7232
getNDupUintSmallDictG
uint64_t getNDupUintSmallDictG(smallDictt *self, uint64_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6268
keyBySmallDoubleSmallDict
internal char * keyBySmallDoubleSmallDict(smallDictt *self, smallDoublet *value)
Definition: libsheepyCSmallDict.c:3944
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
cleanUpSmallDictDisposeG
void cleanUpSmallDictDisposeG(smallDictt *val)
Definition: libsheepyCSmallDict.c:1038
getNDupSmallBoolKCharSmallDictG
smallBoolt * getNDupSmallBoolKCharSmallDictG(smallDictt *self, smallBoolt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6388
getNDupVoidSmallDictG
void * getNDupVoidSmallDictG(smallDictt *self, void *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6323
setNFreeSmallJsonKCharSmallDict
internal smallDictt * setNFreeSmallJsonKCharSmallDict(smallDictt *self, char key, smallJsont *value)
Definition: libsheepyCSmallDict.c:1829
getNDupSmallStringSmallDict
internal smallStringt * getNDupSmallStringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2820
r
bool r
Definition: libsheepyObjectTest.c:1259
keys
char ** keys
Definition: libsheepyObjectTest.c:107
logW
#define logW(...)
Definition: libsheepy.h:1061
fromArrayNFreeO
#define fromArrayNFreeO(self, array, size)
Definition: libsheepyObject.h:7518
getSmallJsonKCharSmallDictG
smallJsont * getSmallJsonKCharSmallDictG(smallDictt *self, smallJsont *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6217
enumerateElementSmallDictFt
bool(* enumerateElementSmallDictFt)(void *closure, char *key, baset *element)
user defined function called in the enumerate loop this fucntion is a parameter to the enumerate func...
Definition: libsheepyCSmallDict.h:562
setPSmallStringKCharSmallDictG
smallDictt * setPSmallStringKCharSmallDictG(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6811
cropElemUint32SmallDictG
uint32_t cropElemUint32SmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6927
setNFreeSmallDoubleKCharSmallDictG
smallDictt * setNFreeSmallDoubleKCharSmallDictG(smallDictt *self, char key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:6730
getNDupInt32KCharSmallDictG
int32_t getNDupInt32KCharSmallDictG(smallDictt *self, int32_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6358
zipSmallJsonSmallDict
internal smallDictt * zipSmallJsonSmallDict(smallDictt *self, smallArrayt *keys, smallJsont *values)
Definition: libsheepyCSmallDict.c:4924
base
base class
Definition: libsheepyObject.h:9597
setIntKCharSmallDict
internal smallDictt * setIntKCharSmallDict(smallDictt *self, char key, int64_t value)
Definition: libsheepyCSmallDict.c:1551
getDoublePSmallDict
internal double * getDoublePSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2109
getSmallDict
internal baset * getSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2046
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
getSmallJsonKCharSmallDict
internal smallJsont * getSmallJsonKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2542
getNDupSmallBoolKCharSmallDict
internal smallBoolt * getNDupSmallBoolKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2941
getNDupKCharSmallDict
internal baset * getNDupKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2875
sDoublet
small double
Definition: libsheepySmall.h:120
setNFreePSmallStringKCharSmallDictG
smallDictt * setNFreePSmallStringKCharSmallDictG(smallDictt *self, char key, smallStringt *string)
Definition: libsheepyCSmallDict.c:6831
setNFreeSmallIntKCharSmallDictG
smallDictt * setNFreeSmallIntKCharSmallDictG(smallDictt *self, char key, smallIntt *value)
Definition: libsheepyCSmallDict.c:6735
setNFreeSmallJsonSmallDict
internal smallDictt * setNFreeSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *value)
Definition: libsheepyCSmallDict.c:1742
getSmallContainerSmallDictG
smallContainert * getSmallContainerSmallDictG(smallDictt *self, smallContainert *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6107
ARRAY_SIZE
#define ARRAY_SIZE
Definition: libsheepy.h:473
setUndefinedKCharSmallDict
internal smallDictt * setUndefinedKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:1533
sFree
void sFree(smallt *obj)
free non null objects
Definition: libsheepySmall.c:371
isEIntSmallDict
internal bool isEIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5779
keyBySmallBoolSmallDict
internal char * keyBySmallBoolSmallDict(smallDictt *self, smallBoolt *value)
Definition: libsheepyCSmallDict.c:3899
terminateSmallDict
internal void terminateSmallDict(smallDictt **self)
Definition: libsheepyCSmallDict.c:1054
setNFreeArraySmallDict
internal smallDictt * setNFreeArraySmallDict(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1688
cropElemSmallStringSmallDict
internal smallStringt * cropElemSmallStringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3520
lenSmallDictG
size_t lenSmallDictG(smallDictt *self)
Definition: libsheepyCSmallDict.c:7182
setNFreePArrayKCharSmallDictG
smallDictt * setNFreePArrayKCharSmallDictG(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6816
getNDupUintKCharSmallDictG
uint64_t getNDupUintKCharSmallDictG(smallDictt *self, uint64_t retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6363
delElemO
#define delElemO(self, index)
Definition: libsheepyObject.h:2926
appendSmallDict
internal smallDictt * appendSmallDict(smallDictt *self, smallDictt *smallDict)
Definition: libsheepyCSmallDict.c:4472
cropElemSmallDictG
baset * cropElemSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6892
setSmallContainerKCharSmallDict
internal smallDictt * setSmallContainerKCharSmallDict(smallDictt *self, char key, smallContainert *container)
Definition: libsheepyCSmallDict.c:1629
setSmallJsonSmallDict
internal smallDictt * setSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *value)
Definition: libsheepyCSmallDict.c:1471
cropElemSSmallDict
internal char * cropElemSSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3286
getSmallBoolKCharSmallDictG
smallBoolt * getSmallBoolKCharSmallDictG(smallDictt *self, smallBoolt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6197
cleanUpSmallDictTerminateG
void cleanUpSmallDictTerminateG(smallDictt **val)
Definition: libsheepyCSmallDict.c:1018
setNFreePSmallJsonSmallDictG
smallDictt * setNFreePSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *json)
Definition: libsheepyCSmallDict.c:6786
getUint32PKCharSmallDict
internal uint32_t * getUint32PKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2494
setSmallDictG
smallDictt * setSmallDictG(smallDictt *self, const char *key, baset *value)
Definition: libsheepyCSmallDict.c:5981
setNFreeSmallDoubleSmallDictG
smallDictt * setNFreeSmallDoubleSmallDictG(smallDictt *self, const char *key, smallDoublet *value)
Definition: libsheepyCSmallDict.c:6665
listLengthS
size_t listLengthS(char **list)
list Length String return number of elements until the first NULL element
Definition: libsheepy.c:50820
listPushS
char ** listPushS(char ***list, const char *s)
list Push String append s at the end of the list when list is NULL, a new list with one element is re...
Definition: libsheepy.c:50504
setPSmallJsonSmallDict
internal smallDictt * setPSmallJsonSmallDict(smallDictt *self, const char *key, smallJsont *json)
Definition: libsheepyCSmallDict.c:1884
icEqualSmallDictSmallJsonG
bool icEqualSmallDictSmallJsonG(smallDictt *self, smallJsont *p2)
Definition: libsheepyCSmallDict.c:6877
setCArraycKCharSmallDict
internal smallDictt * setCArraycKCharSmallDict(smallDictt *self, char key, const char **array)
Definition: libsheepyCSmallDict.c:1587
cropElemSmallDict
internal baset * cropElemSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3019
keyByCharSmallDictG
char * keyByCharSmallDictG(smallDictt *self, char c)
Definition: libsheepyCSmallDict.c:7067
delSmallDictG
smallDictt * delSmallDictG(smallDictt *self, const char *key, int unused UNUSED)
Definition: libsheepyCSmallDict.c:6987
smallInt::f
smallIntFunctionst * f
Definition: libsheepyCSmallInt.h:227
getSmallDoubleSmallDictG
smallDoublet * getSmallDoubleSmallDictG(smallDictt *self, smallDoublet *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6082
allocSArray
sArrayt * allocSArray(void)
allocate a small array
Definition: libsheepySmall.c:329
getInt32KCharSmallDict
internal int32_t getInt32KCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2464
trimSmallDict
internal smallDictt * trimSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4329
setSmallBoolSmallDict
internal smallDictt * setSmallBoolSmallDict(smallDictt *self, const char *key, smallBoolt *value)
Definition: libsheepyCSmallDict.c:1403
pushNFreeO
#define pushNFreeO(self, value)
Definition: libsheepyObject.h:732
mergeSmallJsonSmallDictG
smallDictt * mergeSmallJsonSmallDictG(smallDictt *self, smallJsont *json)
Definition: libsheepyCSmallDict.c:6842
getNDupSmallBytesSmallDictG
smallBytest * getNDupSmallBytesSmallDictG(smallDictt *self, smallBytest *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6298
setPArraySmallDict
internal smallDictt * setPArraySmallDict(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1866
getNDupDoubleKCharSmallDict
internal double getNDupDoubleKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2893
keyByDoubleSmallDict
internal char * keyByDoubleSmallDict(smallDictt *self, double value)
Definition: libsheepyCSmallDict.c:3734
cropElemVoidSmallDictG
void * cropElemVoidSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6977
freeManyS
#define freeManyS(...)
Definition: libsheepy.h:1867
getIntPKCharSmallDictG
int64_t * getIntPKCharSmallDictG(smallDictt *self, int64_t *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6147
keyBySSmallDictG
char * keyBySSmallDictG(smallDictt *self, const char *string)
Definition: libsheepyCSmallDict.c:7062
getUintSmallDictG
uint64_t getUintSmallDictG(smallDictt *self, uint64_t retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6037
getSmallBoolSmallDictG
smallBoolt * getSmallBoolSmallDictG(smallDictt *self, smallBoolt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6072
u
undefinedt * u
Definition: libsheepyObjectTest.c:56
icKeyBySmallDict
internal char * icKeyBySmallDict(smallDictt *self, baset *value)
Definition: libsheepyCSmallDict.c:4085
equalSmallDictSmallJsonG
bool equalSmallDictSmallJsonG(smallDictt *self, smallJsont *p2)
Definition: libsheepyCSmallDict.c:6862
setArrayKCharSmallDict
internal smallDictt * setArrayKCharSmallDict(smallDictt *self, char key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:1575
cropElemDoubleSmallDictG
double cropElemDoubleSmallDictG(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:6907
getUndefinedKCharSmallDictG
undefinedt * getUndefinedKCharSmallDictG(smallDictt *self, undefinedt *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6117
getUintPSmallDict
internal uint64_t * getUintPSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2181
getsoO
#define getsoO(self)
Definition: libsheepyObject.h:7506
getDoublePSmallDictG
double * getDoublePSmallDictG(smallDictt *self, double *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6012
icEqualSmallDict
internal bool icEqualSmallDict(smallDictt *self, smallDictt *p2)
Definition: libsheepyCSmallDict.c:4620
getUndefinedSmallDictG
undefinedt * getUndefinedSmallDictG(smallDictt *self, undefinedt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:5992
createAllocateSmallArray
#define createAllocateSmallArray(obj)
Definition: libsheepyCSmallArray.h:1912
removeKCharSmallDictG
smallDictt * removeKCharSmallDictG(smallDictt *self, char key, int unused UNUSED)
Definition: libsheepyCSmallDict.c:7012
getNDupSmallIntSmallDictG
smallIntt * getNDupSmallIntSmallDictG(smallDictt *self, smallIntt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6308
keyByBoolSmallDict
internal char * keyByBoolSmallDict(smallDictt *self, bool value)
Definition: libsheepyCSmallDict.c:3718
isEStringSmallDict
internal bool isEStringSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5798
iterElementSmallDict
internal baset * iterElementSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4874
getUintKCharSmallDict
internal uint64_t getUintKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2476
iterStartKeySmallDict
internal const char * iterStartKeySmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4765
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
getNDupSmallDoubleKCharSmallDictG
smallDoublet * getNDupSmallDoubleKCharSmallDictG(smallDictt *self, smallDoublet *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6398
equalSmallDictSmallJson
internal bool equalSmallDictSmallJson(smallDictt *self, smallJsont *p2)
Definition: libsheepyCSmallDict.c:4521
getNDupSmallBytesKCharSmallDict
internal smallBytest * getNDupSmallBytesKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2947
getIntKCharSmallDict
internal int64_t getIntKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2452
setNFreeSmallJsonSmallDictG
smallDictt * setNFreeSmallJsonSmallDictG(smallDictt *self, const char *key, smallJsont *value)
Definition: libsheepyCSmallDict.c:6675
zipVCArraySmallDictG
smallDictt * zipVCArraySmallDictG(smallDictt *self, smallArrayt *keys, const char **values)
Definition: libsheepyCSmallDict.c:7272
getUint32SmallDict
internal uint32_t getUint32SmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2193
areAllEIntSmallDict
internal bool areAllEIntSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:5939
getInt32PKCharSmallDictG
int32_t * getInt32PKCharSmallDictG(smallDictt *self, int32_t *retType UNUSED, char key)
Definition: libsheepyCSmallDict.c:6157
smashO
#define smashO(obj)
free object and keep data
Definition: libsheepyObject.h:357
smallDouble::f
smallDoubleFunctionst * f
Definition: libsheepyCSmallDouble.h:225
setSmallBytesSmallDictG
smallDictt * setSmallBytesSmallDictG(smallDictt *self, const char *key, smallBytest *value)
Definition: libsheepyCSmallDict.c:6499
getNDupArraySmallDictG
smallArrayt * getNDupArraySmallDictG(smallDictt *self, smallArrayt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6288
getNDupSmallStringSmallDictG
smallStringt * getNDupSmallStringSmallDictG(smallDictt *self, smallStringt *retType UNUSED, const char *key)
Definition: libsheepyCSmallDict.c:6318
isEBoolSmallDict
internal bool isEBoolSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:5703
sDuplicate
smallt * sDuplicate(smallt *o)
duplicate small object
Definition: libsheepySmall.c:485
getIntSmallDict
internal int64_t getIntSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2121
setNFreeSKCharSmallDictG
smallDictt * setNFreeSKCharSmallDictG(smallDictt *self, char key, char *string)
Definition: libsheepyCSmallDict.c:6700
getSmallJsonSmallDict
internal smallJsont * getSmallJsonSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:2337
setNFreePArraySmallDictG
smallDictt * setNFreePArraySmallDictG(smallDictt *self, const char *key, smallArrayt *array)
Definition: libsheepyCSmallDict.c:6781
zipSmallJsonVArraySmallDict
internal smallDictt * zipSmallJsonVArraySmallDict(smallDictt *self, smallJsont *keys, char **values)
Definition: libsheepyCSmallDict.c:5019
hasSmallDict
internal bool hasSmallDict(smallDictt *self, const char *key)
Definition: libsheepyCSmallDict.c:3647
setNFreeUndefinedSmallDict
internal smallDictt * setNFreeUndefinedSmallDict(smallDictt *self, const char *key, undefinedt *u)
Definition: libsheepyCSmallDict.c:1658
setCharSmallDictG
smallDictt * setCharSmallDictG(smallDictt *self, const char *key, char c)
Definition: libsheepyCSmallDict.c:6454
duplicateO
#define duplicateO(obj)
create a copy of obj
Definition: libsheepyObject.h:351
iterNextSmallDict
internal baset * iterNextSmallDict(smallDictt *self)
Definition: libsheepyCSmallDict.c:4796
getNDupSmallIntKCharSmallDict
internal smallIntt * getNDupSmallIntKCharSmallDict(smallDictt *self, char key)
Definition: libsheepyCSmallDict.c:2959
registerMethodsSmallDict
void registerMethodsSmallDict(smallDictFunctionst *f)
Definition: libsheepyCSmallDict.c:654
zipVArraySmallDictG
smallDictt * zipVArraySmallDictG(smallDictt *self, smallArrayt *keys, char **values)
Definition: libsheepyCSmallDict.c:7267
setNFreeSmallDict
internal smallDictt * setNFreeSmallDict(smallDictt *self, const char *key, baset *value)
Definition: libsheepyCSmallDict.c:1636
isOSmallString
#define isOSmallString(obj)
test if obj type is smallString
Definition: libsheepyObject.h:275
icKeyByCArraycSmallDict
internal char * icKeyByCArraycSmallDict(smallDictt *self, const char **array)
Definition: libsheepyCSmallDict.c:4218
Generated on Thu Jul 13 2023 14:34:30 for libsheepy by   doxygen 1.8.13