1 | // Copyright (c) Microsoft. All rights reserved.
|
---|
2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
---|
3 |
|
---|
4 | #include <stdlib.h>
|
---|
5 | #include "azure_macro_utils/macro_utils.h"
|
---|
6 | #include "azure_c_shared_utility/gballoc.h"
|
---|
7 | #include "azure_c_shared_utility/map.h"
|
---|
8 | #include "azure_c_shared_utility/optimize_size.h"
|
---|
9 | #include "azure_c_shared_utility/xlogging.h"
|
---|
10 | #include "azure_c_shared_utility/strings.h"
|
---|
11 |
|
---|
12 | MU_DEFINE_ENUM_STRINGS(MAP_RESULT, MAP_RESULT_VALUES);
|
---|
13 |
|
---|
14 | typedef struct MAP_HANDLE_DATA_TAG
|
---|
15 | {
|
---|
16 | char** keys;
|
---|
17 | char** values;
|
---|
18 | size_t count;
|
---|
19 | MAP_FILTER_CALLBACK mapFilterCallback;
|
---|
20 | }MAP_HANDLE_DATA;
|
---|
21 |
|
---|
22 | #define LOG_MAP_ERROR LogError("result = %" PRI_MU_ENUM "", MU_ENUM_VALUE(MAP_RESULT, result));
|
---|
23 |
|
---|
24 | MAP_HANDLE Map_Create(MAP_FILTER_CALLBACK mapFilterFunc)
|
---|
25 | {
|
---|
26 | /*Codes_SRS_MAP_02_001: [Map_Create shall create a new, empty map.]*/
|
---|
27 | MAP_HANDLE_DATA* result = (MAP_HANDLE_DATA*)calloc(1, sizeof(MAP_HANDLE_DATA));
|
---|
28 | /*Codes_SRS_MAP_02_002: [If during creation there are any error, then Map_Create shall return NULL.]*/
|
---|
29 | if (result != NULL)
|
---|
30 | {
|
---|
31 | /*Codes_SRS_MAP_02_003: [Otherwise, it shall return a non-NULL handle that can be used in subsequent calls.] */
|
---|
32 | result->keys = NULL;
|
---|
33 | result->values = NULL;
|
---|
34 | result->count = 0;
|
---|
35 | result->mapFilterCallback = mapFilterFunc;
|
---|
36 | }
|
---|
37 | return (MAP_HANDLE)result;
|
---|
38 | }
|
---|
39 |
|
---|
40 | void Map_Destroy(MAP_HANDLE handle)
|
---|
41 | {
|
---|
42 | /*Codes_SRS_MAP_02_005: [If parameter handle is NULL then Map_Destroy shall take no action.] */
|
---|
43 | if (handle != NULL)
|
---|
44 | {
|
---|
45 | /*Codes_SRS_MAP_02_004: [Map_Destroy shall release all resources associated with the map.] */
|
---|
46 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA*)handle;
|
---|
47 | size_t i;
|
---|
48 |
|
---|
49 | for (i = 0; i < handleData->count; i++)
|
---|
50 | {
|
---|
51 | free(handleData->keys[i]);
|
---|
52 | free(handleData->values[i]);
|
---|
53 | }
|
---|
54 | free(handleData->keys);
|
---|
55 | free(handleData->values);
|
---|
56 | free(handleData);
|
---|
57 | }
|
---|
58 | }
|
---|
59 |
|
---|
60 | /*makes a copy of a vector of const char*, having size "size". source cannot be NULL*/
|
---|
61 | /*returns NULL if it fails*/
|
---|
62 | static char** Map_CloneVector(const char*const * source, size_t count)
|
---|
63 | {
|
---|
64 | char** result;
|
---|
65 | result = (char**)malloc(count *sizeof(char*));
|
---|
66 | if (result == NULL)
|
---|
67 | {
|
---|
68 | /*do nothing, just return it (NULL)*/
|
---|
69 | }
|
---|
70 | else
|
---|
71 | {
|
---|
72 | size_t i;
|
---|
73 | for (i = 0; i < count; i++)
|
---|
74 | {
|
---|
75 | if (mallocAndStrcpy_s(result + i, source[i]) != 0)
|
---|
76 | {
|
---|
77 | break;
|
---|
78 | }
|
---|
79 | }
|
---|
80 |
|
---|
81 | if (i == count)
|
---|
82 | {
|
---|
83 | /*it is all good, proceed to return result*/
|
---|
84 | }
|
---|
85 | else
|
---|
86 | {
|
---|
87 | size_t j;
|
---|
88 | for (j = 0; j < i; j++)
|
---|
89 | {
|
---|
90 | free(result[j]);
|
---|
91 | }
|
---|
92 | free(result);
|
---|
93 | result = NULL;
|
---|
94 | }
|
---|
95 | }
|
---|
96 | return result;
|
---|
97 | }
|
---|
98 |
|
---|
99 | /*Codes_SRS_MAP_02_039: [Map_Clone shall make a copy of the map indicated by parameter handle and return a non-NULL handle to it.]*/
|
---|
100 | MAP_HANDLE Map_Clone(MAP_HANDLE handle)
|
---|
101 | {
|
---|
102 | MAP_HANDLE_DATA* result;
|
---|
103 | if (handle == NULL)
|
---|
104 | {
|
---|
105 | /*Codes_SRS_MAP_02_038: [Map_Clone returns NULL if parameter handle is NULL.]*/
|
---|
106 | result = NULL;
|
---|
107 | LogError("invalid arg to Map_Clone (NULL)");
|
---|
108 | }
|
---|
109 | else
|
---|
110 | {
|
---|
111 | MAP_HANDLE_DATA * handleData = (MAP_HANDLE_DATA *)handle;
|
---|
112 | result = (MAP_HANDLE_DATA*)calloc(1, sizeof(MAP_HANDLE_DATA));
|
---|
113 | if (result == NULL)
|
---|
114 | {
|
---|
115 | /*Codes_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
|
---|
116 | /*do nothing, proceed to return it, this is an error case*/
|
---|
117 | LogError("unable to malloc");
|
---|
118 | }
|
---|
119 | else
|
---|
120 | {
|
---|
121 | if (handleData->count == 0)
|
---|
122 | {
|
---|
123 | result->count = 0;
|
---|
124 | result->keys = NULL;
|
---|
125 | result->values = NULL;
|
---|
126 | result->mapFilterCallback = NULL;
|
---|
127 | }
|
---|
128 | else
|
---|
129 | {
|
---|
130 | result->mapFilterCallback = handleData->mapFilterCallback;
|
---|
131 | result->count = handleData->count;
|
---|
132 | if( (result->keys = Map_CloneVector((const char* const*)handleData->keys, handleData->count))==NULL)
|
---|
133 | {
|
---|
134 | /*Codes_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
|
---|
135 | LogError("unable to clone keys");
|
---|
136 | free(result);
|
---|
137 | result = NULL;
|
---|
138 | }
|
---|
139 | else if ((result->values = Map_CloneVector((const char* const*)handleData->values, handleData->count)) == NULL)
|
---|
140 | {
|
---|
141 | size_t i;
|
---|
142 | /*Codes_SRS_MAP_02_047: [If during cloning, any operation fails, then Map_Clone shall return NULL.] */
|
---|
143 | LogError("unable to clone values");
|
---|
144 | for (i = 0; i < result->count; i++)
|
---|
145 | {
|
---|
146 | free(result->keys[i]);
|
---|
147 | }
|
---|
148 | free(result->keys);
|
---|
149 | free(result);
|
---|
150 | result = NULL;
|
---|
151 | }
|
---|
152 | else
|
---|
153 | {
|
---|
154 | /*all fine, return it*/
|
---|
155 | }
|
---|
156 | }
|
---|
157 | }
|
---|
158 | }
|
---|
159 | return (MAP_HANDLE)result;
|
---|
160 | }
|
---|
161 |
|
---|
162 | static int Map_IncreaseStorageKeysValues(MAP_HANDLE_DATA* handleData)
|
---|
163 | {
|
---|
164 | int result;
|
---|
165 | char** newKeys = (char**)realloc(handleData->keys, (handleData->count + 1) * sizeof(char*));
|
---|
166 | if (newKeys == NULL)
|
---|
167 | {
|
---|
168 | LogError("realloc error");
|
---|
169 | result = MU_FAILURE;
|
---|
170 | }
|
---|
171 | else
|
---|
172 | {
|
---|
173 | char** newValues;
|
---|
174 | handleData->keys = newKeys;
|
---|
175 | handleData->keys[handleData->count] = NULL;
|
---|
176 | newValues = (char**)realloc(handleData->values, (handleData->count + 1) * sizeof(char*));
|
---|
177 | if (newValues == NULL)
|
---|
178 | {
|
---|
179 | LogError("realloc error");
|
---|
180 | if (handleData->count == 0) /*avoiding an implementation defined behavior */
|
---|
181 | {
|
---|
182 | free(handleData->keys);
|
---|
183 | handleData->keys = NULL;
|
---|
184 | }
|
---|
185 | else
|
---|
186 | {
|
---|
187 | char** undoneKeys = (char**)realloc(handleData->keys, (handleData->count) * sizeof(char*));
|
---|
188 | if (undoneKeys == NULL)
|
---|
189 | {
|
---|
190 | LogError("CATASTROPHIC error, unable to undo through realloc to a smaller size");
|
---|
191 | }
|
---|
192 | else
|
---|
193 | {
|
---|
194 | handleData->keys = undoneKeys;
|
---|
195 | }
|
---|
196 | }
|
---|
197 | result = MU_FAILURE;
|
---|
198 | }
|
---|
199 | else
|
---|
200 | {
|
---|
201 | handleData->values = newValues;
|
---|
202 | handleData->values[handleData->count] = NULL;
|
---|
203 | handleData->count++;
|
---|
204 | result = 0;
|
---|
205 | }
|
---|
206 | }
|
---|
207 | return result;
|
---|
208 | }
|
---|
209 |
|
---|
210 | static void Map_DecreaseStorageKeysValues(MAP_HANDLE_DATA* handleData)
|
---|
211 | {
|
---|
212 | if (handleData->count == 1)
|
---|
213 | {
|
---|
214 | free(handleData->keys);
|
---|
215 | handleData->keys = NULL;
|
---|
216 | free(handleData->values);
|
---|
217 | handleData->values = NULL;
|
---|
218 | handleData->count = 0;
|
---|
219 | handleData->mapFilterCallback = NULL;
|
---|
220 | }
|
---|
221 | else
|
---|
222 | {
|
---|
223 | /*certainly > 1...*/
|
---|
224 | char** undoneValues;
|
---|
225 | char** undoneKeys = (char**)realloc(handleData->keys, sizeof(char*)* (handleData->count - 1));
|
---|
226 | if (undoneKeys == NULL)
|
---|
227 | {
|
---|
228 | LogError("CATASTROPHIC error, unable to undo through realloc to a smaller size");
|
---|
229 | }
|
---|
230 | else
|
---|
231 | {
|
---|
232 | handleData->keys = undoneKeys;
|
---|
233 | }
|
---|
234 |
|
---|
235 | undoneValues = (char**)realloc(handleData->values, sizeof(char*)* (handleData->count - 1));
|
---|
236 | if (undoneValues == NULL)
|
---|
237 | {
|
---|
238 | LogError("CATASTROPHIC error, unable to undo through realloc to a smaller size");
|
---|
239 | }
|
---|
240 | else
|
---|
241 | {
|
---|
242 | handleData->values = undoneValues;
|
---|
243 | }
|
---|
244 |
|
---|
245 | handleData->count--;
|
---|
246 | }
|
---|
247 | }
|
---|
248 |
|
---|
249 | static char** findKey(MAP_HANDLE_DATA* handleData, const char* key)
|
---|
250 | {
|
---|
251 | char** result;
|
---|
252 | if (handleData->keys == NULL)
|
---|
253 | {
|
---|
254 | result = NULL;
|
---|
255 | }
|
---|
256 | else
|
---|
257 | {
|
---|
258 | size_t i;
|
---|
259 | result = NULL;
|
---|
260 | for (i = 0; i < handleData->count; i++)
|
---|
261 | {
|
---|
262 | if (strcmp(handleData->keys[i], key) == 0)
|
---|
263 | {
|
---|
264 | result = handleData->keys + i;
|
---|
265 | break;
|
---|
266 | }
|
---|
267 | }
|
---|
268 | }
|
---|
269 | return result;
|
---|
270 | }
|
---|
271 |
|
---|
272 | static char** findValue(MAP_HANDLE_DATA* handleData, const char* value)
|
---|
273 | {
|
---|
274 | char** result;
|
---|
275 | if (handleData->values == NULL)
|
---|
276 | {
|
---|
277 | result = NULL;
|
---|
278 | }
|
---|
279 | else
|
---|
280 | {
|
---|
281 | size_t i;
|
---|
282 | result = NULL;
|
---|
283 | for (i = 0; i < handleData->count; i++)
|
---|
284 | {
|
---|
285 | if (strcmp(handleData->values[i], value) == 0)
|
---|
286 | {
|
---|
287 | result = handleData->values + i;
|
---|
288 | break;
|
---|
289 | }
|
---|
290 | }
|
---|
291 | }
|
---|
292 | return result;
|
---|
293 | }
|
---|
294 |
|
---|
295 | static int insertNewKeyValue(MAP_HANDLE_DATA* handleData, const char* key, const char* value)
|
---|
296 | {
|
---|
297 | int result;
|
---|
298 | if (Map_IncreaseStorageKeysValues(handleData) != 0) /*this increases handleData->count*/
|
---|
299 | {
|
---|
300 | result = MU_FAILURE;
|
---|
301 | }
|
---|
302 | else
|
---|
303 | {
|
---|
304 | if (mallocAndStrcpy_s(&(handleData->keys[handleData->count - 1]), key) != 0)
|
---|
305 | {
|
---|
306 | Map_DecreaseStorageKeysValues(handleData);
|
---|
307 | LogError("unable to mallocAndStrcpy_s");
|
---|
308 | result = MU_FAILURE;
|
---|
309 | }
|
---|
310 | else
|
---|
311 | {
|
---|
312 | if (mallocAndStrcpy_s(&(handleData->values[handleData->count - 1]), value) != 0)
|
---|
313 | {
|
---|
314 | free(handleData->keys[handleData->count - 1]);
|
---|
315 | Map_DecreaseStorageKeysValues(handleData);
|
---|
316 | LogError("unable to mallocAndStrcpy_s");
|
---|
317 | result = MU_FAILURE;
|
---|
318 | }
|
---|
319 | else
|
---|
320 | {
|
---|
321 | result = 0;
|
---|
322 | }
|
---|
323 | }
|
---|
324 | }
|
---|
325 | return result;
|
---|
326 | }
|
---|
327 |
|
---|
328 | MAP_RESULT Map_Add(MAP_HANDLE handle, const char* key, const char* value)
|
---|
329 | {
|
---|
330 | MAP_RESULT result;
|
---|
331 | /*Codes_SRS_MAP_02_006: [If parameter handle is NULL then Map_Add shall return MAP_INVALID_ARG.] */
|
---|
332 | /*Codes_SRS_MAP_02_007: [If parameter key is NULL then Map_Add shall return MAP_INVALID_ARG.]*/
|
---|
333 | /*Codes_SRS_MAP_02_008: [If parameter value is NULL then Map_Add shall return MAP_INVALID_ARG.] */
|
---|
334 | if (
|
---|
335 | (handle == NULL) ||
|
---|
336 | (key == NULL) ||
|
---|
337 | (value == NULL)
|
---|
338 | )
|
---|
339 | {
|
---|
340 | result = MAP_INVALIDARG;
|
---|
341 | LOG_MAP_ERROR;
|
---|
342 | }
|
---|
343 | else
|
---|
344 | {
|
---|
345 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA*)handle;
|
---|
346 | /*Codes_SRS_MAP_02_009: [If the key already exists, then Map_Add shall return MAP_KEYEXISTS.] */
|
---|
347 | if (findKey(handleData, key) != NULL)
|
---|
348 | {
|
---|
349 | result = MAP_KEYEXISTS;
|
---|
350 | }
|
---|
351 | else
|
---|
352 | {
|
---|
353 | /* Codes_SRS_MAP_07_009: [If the mapFilterCallback function is not NULL, then the return value will be check and if it is not zero then Map_Add shall return MAP_FILTER_REJECT.] */
|
---|
354 | if ( (handleData->mapFilterCallback != NULL) && (handleData->mapFilterCallback(key, value) != 0) )
|
---|
355 | {
|
---|
356 | result = MAP_FILTER_REJECT;
|
---|
357 | }
|
---|
358 | else
|
---|
359 | {
|
---|
360 | /*Codes_SRS_MAP_02_010: [Otherwise, Map_Add shall add the pair <key,value> to the map.] */
|
---|
361 | if (insertNewKeyValue(handleData, key, value) != 0)
|
---|
362 | {
|
---|
363 | /*Codes_SRS_MAP_02_011: [If adding the pair <key,value> fails then Map_Add shall return MAP_ERROR.] */
|
---|
364 | result = MAP_ERROR;
|
---|
365 | LOG_MAP_ERROR;
|
---|
366 | }
|
---|
367 | else
|
---|
368 | {
|
---|
369 | /*Codes_SRS_MAP_02_012: [Otherwise, Map_Add shall return MAP_OK.] */
|
---|
370 | result = MAP_OK;
|
---|
371 | }
|
---|
372 | }
|
---|
373 | }
|
---|
374 | }
|
---|
375 | return result;
|
---|
376 | }
|
---|
377 |
|
---|
378 | MAP_RESULT Map_AddOrUpdate(MAP_HANDLE handle, const char* key, const char* value)
|
---|
379 | {
|
---|
380 | MAP_RESULT result;
|
---|
381 | /*Codes_SRS_MAP_02_013: [If parameter handle is NULL then Map_AddOrUpdate shall return MAP_INVALID_ARG.]*/
|
---|
382 | /*Codes_SRS_MAP_02_014: [If parameter key is NULL then Map_AddOrUpdate shall return MAP_INVALID_ARG.]*/
|
---|
383 | /*Codes_SRS_MAP_02_015: [If parameter value is NULL then Map_AddOrUpdate shall return MAP_INVALID_ARG.] */
|
---|
384 | if (
|
---|
385 | (handle == NULL) ||
|
---|
386 | (key == NULL) ||
|
---|
387 | (value == NULL)
|
---|
388 | )
|
---|
389 | {
|
---|
390 | result = MAP_INVALIDARG;
|
---|
391 | LOG_MAP_ERROR;
|
---|
392 | }
|
---|
393 | else
|
---|
394 | {
|
---|
395 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA*)handle;
|
---|
396 |
|
---|
397 | /* Codes_SRS_MAP_07_008: [If the mapFilterCallback function is not NULL, then the return value will be check and if it is not zero then Map_AddOrUpdate shall return MAP_FILTER_REJECT.] */
|
---|
398 | if (handleData->mapFilterCallback != NULL && handleData->mapFilterCallback(key, value) != 0)
|
---|
399 | {
|
---|
400 | result = MAP_FILTER_REJECT;
|
---|
401 | }
|
---|
402 | else
|
---|
403 | {
|
---|
404 | char** whereIsIt = findKey(handleData, key);
|
---|
405 | if (whereIsIt == NULL)
|
---|
406 | {
|
---|
407 | /*Codes_SRS_MAP_02_017: [Otherwise, Map_AddOrUpdate shall add the pair <key,value> to the map.]*/
|
---|
408 | if (insertNewKeyValue(handleData, key, value) != 0)
|
---|
409 | {
|
---|
410 | result = MAP_ERROR;
|
---|
411 | LOG_MAP_ERROR;
|
---|
412 | }
|
---|
413 | else
|
---|
414 | {
|
---|
415 | result = MAP_OK;
|
---|
416 | }
|
---|
417 | }
|
---|
418 | else
|
---|
419 | {
|
---|
420 | /*Codes_SRS_MAP_02_016: [If the key already exists, then Map_AddOrUpdate shall overwrite the value of the existing key with parameter value.]*/
|
---|
421 | size_t index = whereIsIt - handleData->keys;
|
---|
422 | size_t valueLength = strlen(value);
|
---|
423 | /*try to realloc value of this key*/
|
---|
424 | char* newValue = (char*)realloc(handleData->values[index],valueLength + 1);
|
---|
425 | if (newValue == NULL)
|
---|
426 | {
|
---|
427 | result = MAP_ERROR;
|
---|
428 | LOG_MAP_ERROR;
|
---|
429 | }
|
---|
430 | else
|
---|
431 | {
|
---|
432 | (void)memcpy(newValue, value, valueLength + 1);
|
---|
433 | handleData->values[index] = newValue;
|
---|
434 | /*Codes_SRS_MAP_02_019: [Otherwise, Map_AddOrUpdate shall return MAP_OK.] */
|
---|
435 | result = MAP_OK;
|
---|
436 | }
|
---|
437 | }
|
---|
438 | }
|
---|
439 | }
|
---|
440 | return result;
|
---|
441 | }
|
---|
442 |
|
---|
443 | MAP_RESULT Map_Delete(MAP_HANDLE handle, const char* key)
|
---|
444 | {
|
---|
445 | MAP_RESULT result;
|
---|
446 | /*Codes_SRS_MAP_02_020: [If parameter handle is NULL then Map_Delete shall return MAP_INVALIDARG.]*/
|
---|
447 | /*Codes_SRS_MAP_02_021: [If parameter key is NULL then Map_Delete shall return MAP_INVALIDARG.]*/
|
---|
448 | if (
|
---|
449 | (handle == NULL) ||
|
---|
450 | (key == NULL)
|
---|
451 | )
|
---|
452 | {
|
---|
453 | result = MAP_INVALIDARG;
|
---|
454 | LOG_MAP_ERROR;
|
---|
455 | }
|
---|
456 | else
|
---|
457 | {
|
---|
458 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA*)handle;
|
---|
459 | char** whereIsIt = findKey(handleData,key);
|
---|
460 | if (whereIsIt == NULL)
|
---|
461 | {
|
---|
462 | /*Codes_SRS_MAP_02_022: [If key does not exist then Map_Delete shall return MAP_KEYNOTFOUND.]*/
|
---|
463 | result = MAP_KEYNOTFOUND;
|
---|
464 | }
|
---|
465 | else
|
---|
466 | {
|
---|
467 | /*Codes_SRS_MAP_02_023: [Otherwise, Map_Delete shall remove the key and its associated value from the map and return MAP_OK.]*/
|
---|
468 | size_t index = whereIsIt - handleData->keys;
|
---|
469 | free(handleData->keys[index]);
|
---|
470 | free(handleData->values[index]);
|
---|
471 | memmove(handleData->keys + index, handleData->keys + index + 1, (handleData->count - index - 1)*sizeof(char*)); /*if order doesn't matter... then this can be optimized*/
|
---|
472 | memmove(handleData->values + index, handleData->values + index + 1, (handleData->count - index - 1)*sizeof(char*));
|
---|
473 | Map_DecreaseStorageKeysValues(handleData);
|
---|
474 | result = MAP_OK;
|
---|
475 | }
|
---|
476 |
|
---|
477 | }
|
---|
478 | return result;
|
---|
479 | }
|
---|
480 |
|
---|
481 | MAP_RESULT Map_ContainsKey(MAP_HANDLE handle, const char* key, bool* keyExists)
|
---|
482 | {
|
---|
483 | MAP_RESULT result;
|
---|
484 | /*Codes_SRS_MAP_02_024: [If parameter handle, key or keyExists are NULL then Map_ContainsKey shall return MAP_INVALIDARG.]*/
|
---|
485 | if (
|
---|
486 | (handle ==NULL) ||
|
---|
487 | (key == NULL) ||
|
---|
488 | (keyExists == NULL)
|
---|
489 | )
|
---|
490 | {
|
---|
491 | result = MAP_INVALIDARG;
|
---|
492 | LOG_MAP_ERROR;
|
---|
493 | }
|
---|
494 | else
|
---|
495 | {
|
---|
496 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA*)handle;
|
---|
497 | /*Codes_SRS_MAP_02_025: [Otherwise if a key exists then Map_ContainsKey shall return MAP_OK and shall write in keyExists "true".]*/
|
---|
498 | /*Codes_SRS_MAP_02_026: [If a key doesn't exist, then Map_ContainsKey shall return MAP_OK and write in keyExists "false".] */
|
---|
499 | *keyExists = (findKey(handleData, key) != NULL) ? true: false;
|
---|
500 | result = MAP_OK;
|
---|
501 | }
|
---|
502 | return result;
|
---|
503 | }
|
---|
504 |
|
---|
505 | MAP_RESULT Map_ContainsValue(MAP_HANDLE handle, const char* value, bool* valueExists)
|
---|
506 | {
|
---|
507 | MAP_RESULT result;
|
---|
508 | /*Codes_SRS_MAP_02_027: [If parameter handle, value or valueExists is NULL then Map_ContainsValue shall return MAP_INVALIDARG.] */
|
---|
509 | if (
|
---|
510 | (handle == NULL) ||
|
---|
511 | (value == NULL) ||
|
---|
512 | (valueExists == NULL)
|
---|
513 | )
|
---|
514 | {
|
---|
515 | result = MAP_INVALIDARG;
|
---|
516 | LOG_MAP_ERROR;
|
---|
517 | }
|
---|
518 | else
|
---|
519 | {
|
---|
520 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA*)handle;
|
---|
521 | /*Codes_SRS_MAP_02_028: [Otherwise, if a pair <key, value> has its value equal to the parameter value, the Map_ContainsValue shall return MAP_OK and shall write in valueExists "true".]*/
|
---|
522 | /*Codes_SRS_MAP_02_029: [Otherwise, if such a <key, value> does not exist, then Map_ContainsValue shall return MAP_OK and shall write in valueExists "false".] */
|
---|
523 | *valueExists = (findValue(handleData, value) != NULL) ? true : false;
|
---|
524 | result = MAP_OK;
|
---|
525 | }
|
---|
526 | return result;
|
---|
527 | }
|
---|
528 |
|
---|
529 | const char* Map_GetValueFromKey(MAP_HANDLE handle, const char* key)
|
---|
530 | {
|
---|
531 | const char* result;
|
---|
532 | /*Codes_SRS_MAP_02_040: [If parameter handle or key is NULL then Map_GetValueFromKey returns NULL.]*/
|
---|
533 | if (
|
---|
534 | (handle == NULL) ||
|
---|
535 | (key == NULL)
|
---|
536 | )
|
---|
537 | {
|
---|
538 | result = NULL;
|
---|
539 | LogError("invalid parameter to Map_GetValueFromKey");
|
---|
540 | }
|
---|
541 | else
|
---|
542 | {
|
---|
543 | MAP_HANDLE_DATA * handleData = (MAP_HANDLE_DATA *)handle;
|
---|
544 | char** whereIsIt = findKey(handleData, key);
|
---|
545 | if(whereIsIt == NULL)
|
---|
546 | {
|
---|
547 | /*Codes_SRS_MAP_02_041: [If the key is not found, then Map_GetValueFromKey returns NULL.]*/
|
---|
548 | result = NULL;
|
---|
549 | }
|
---|
550 | else
|
---|
551 | {
|
---|
552 | /*Codes_SRS_MAP_02_042: [Otherwise, Map_GetValueFromKey returns the key's value.] */
|
---|
553 | size_t index = whereIsIt - handleData->keys;
|
---|
554 | result = handleData->values[index];
|
---|
555 | }
|
---|
556 | }
|
---|
557 | return result;
|
---|
558 | }
|
---|
559 |
|
---|
560 | MAP_RESULT Map_GetInternals(MAP_HANDLE handle, const char*const** keys, const char*const** values, size_t* count)
|
---|
561 | {
|
---|
562 | MAP_RESULT result;
|
---|
563 | /*Codes_SRS_MAP_02_046: [If parameter handle, keys, values or count is NULL then Map_GetInternals shall return MAP_INVALIDARG.] */
|
---|
564 | if (
|
---|
565 | (handle == NULL) ||
|
---|
566 | (keys == NULL) ||
|
---|
567 | (values == NULL) ||
|
---|
568 | (count == NULL)
|
---|
569 | )
|
---|
570 | {
|
---|
571 | result = MAP_INVALIDARG;
|
---|
572 | LOG_MAP_ERROR;
|
---|
573 | }
|
---|
574 | else
|
---|
575 | {
|
---|
576 | /*Codes_SRS_MAP_02_043: [Map_GetInternals shall produce in *keys an pointer to an array of const char* having all the keys stored so far by the map.]*/
|
---|
577 | /*Codes_SRS_MAP_02_044: [Map_GetInternals shall produce in *values a pointer to an array of const char* having all the values stored so far by the map.]*/
|
---|
578 | /*Codes_SRS_MAP_02_045: [ Map_GetInternals shall produce in *count the number of stored keys and values.]*/
|
---|
579 | MAP_HANDLE_DATA * handleData = (MAP_HANDLE_DATA *)handle;
|
---|
580 | *keys =(const char* const*)(handleData->keys);
|
---|
581 | *values = (const char* const*)(handleData->values);
|
---|
582 | *count = handleData->count;
|
---|
583 | result = MAP_OK;
|
---|
584 | }
|
---|
585 | return result;
|
---|
586 | }
|
---|
587 |
|
---|
588 | STRING_HANDLE Map_ToJSON(MAP_HANDLE handle)
|
---|
589 | {
|
---|
590 | STRING_HANDLE result;
|
---|
591 | /*Codes_SRS_MAP_02_052: [If parameter handle is NULL then Map_ToJSON shall return NULL.] */
|
---|
592 | if (handle == NULL)
|
---|
593 | {
|
---|
594 | result = NULL;
|
---|
595 | LogError("invalid arg (NULL)");
|
---|
596 | }
|
---|
597 | else
|
---|
598 | {
|
---|
599 | /*Codes_SRS_MAP_02_048: [Map_ToJSON shall produce a STRING_HANDLE representing the content of the MAP.] */
|
---|
600 | result = STRING_construct("{");
|
---|
601 | if (result == NULL)
|
---|
602 | {
|
---|
603 | LogError("STRING_construct failed");
|
---|
604 | }
|
---|
605 | else
|
---|
606 | {
|
---|
607 | size_t i;
|
---|
608 | MAP_HANDLE_DATA* handleData = (MAP_HANDLE_DATA *)handle;
|
---|
609 | /*Codes_SRS_MAP_02_049: [If the MAP is empty, then Map_ToJSON shall produce the string "{}".*/
|
---|
610 | bool breakFor = false; /*used to break out of for*/
|
---|
611 | for (i = 0; (i < handleData->count) && (!breakFor); i++)
|
---|
612 | {
|
---|
613 | /*add one entry to the JSON*/
|
---|
614 | /*Codes_SRS_MAP_02_050: [If the map has properties then Map_ToJSON shall produce the following string:{"name1":"value1", "name2":"value2" ...}]*/
|
---|
615 | STRING_HANDLE key = STRING_new_JSON(handleData->keys[i]);
|
---|
616 | if (key == NULL)
|
---|
617 | {
|
---|
618 | LogError("STRING_new_JSON failed");
|
---|
619 | STRING_delete(result);
|
---|
620 | result = NULL;
|
---|
621 | breakFor = true;
|
---|
622 | }
|
---|
623 | else
|
---|
624 | {
|
---|
625 | STRING_HANDLE value = STRING_new_JSON(handleData->values[i]);
|
---|
626 | if (value == NULL)
|
---|
627 | {
|
---|
628 | LogError("STRING_new_JSON failed");
|
---|
629 | STRING_delete(result);
|
---|
630 | result = NULL;
|
---|
631 | breakFor = true;
|
---|
632 | }
|
---|
633 | else
|
---|
634 | {
|
---|
635 | if (!(
|
---|
636 | ((i>0) ? (STRING_concat(result, ",") == 0) : 1) &&
|
---|
637 | (STRING_concat_with_STRING(result, key) == 0) &&
|
---|
638 | (STRING_concat(result, ":") == 0) &&
|
---|
639 | (STRING_concat_with_STRING(result, value) == 0)
|
---|
640 | ))
|
---|
641 | {
|
---|
642 | LogError("failed to build the JSON");
|
---|
643 | STRING_delete(result);
|
---|
644 | result = NULL;
|
---|
645 | breakFor = true;
|
---|
646 | }
|
---|
647 | else
|
---|
648 | {
|
---|
649 | /*all nice, go to the next element in the map*/
|
---|
650 | }
|
---|
651 | STRING_delete(value);
|
---|
652 | }
|
---|
653 | STRING_delete(key);
|
---|
654 | }
|
---|
655 | }
|
---|
656 |
|
---|
657 | if (breakFor)
|
---|
658 | {
|
---|
659 | LogError("error happened during JSON string builder");
|
---|
660 | }
|
---|
661 | else
|
---|
662 | {
|
---|
663 | if (STRING_concat(result, "}") != 0)
|
---|
664 | {
|
---|
665 | LogError("failed to build the JSON");
|
---|
666 | STRING_delete(result);
|
---|
667 | result = NULL;
|
---|
668 | }
|
---|
669 | else
|
---|
670 | {
|
---|
671 | /*return as is, JSON has been build*/
|
---|
672 | }
|
---|
673 | }
|
---|
674 | }
|
---|
675 | }
|
---|
676 | return result;
|
---|
677 |
|
---|
678 | }
|
---|