libsheepyCSmallDict.c (211145B)
1 // MIT License 2 // 3 // Copyright (c) 2026 Remy Noulin 4 // 5 // Permission is hereby granted, free of charge, to any person obtaining a copy 6 // of this software and associated documentation files (the "Software"), to deal 7 // in the Software without restriction, including without limitation the rights 8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 // copies of the Software, and to permit persons to whom the Software is 10 // furnished to do so, subject to the following conditions: 11 // 12 // The above copyright notice and this permission notice shall be included in all 13 // copies or substantial portions of the Software. 14 // 15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 // SOFTWARE. 22 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