From 96c1bda6082ddf74d301dad80231b3808c2b40a7 Mon Sep 17 00:00:00 2001 From: Michele Albano Date: Wed, 27 Nov 2019 10:15:47 +0100 Subject: [PATCH] C additional properties fix #4289 (#4349) * Correction to C support for additional_properties * TAB to SPACE in one file --- .../resources/C-libcurl/model-body.mustache | 108 +- .../petstore/c/.openapi-generator/VERSION | 2 +- samples/client/petstore/c/CMakeLists.txt | 45 +- samples/client/petstore/c/api/PetAPI.c | 1027 ++-- samples/client/petstore/c/api/PetAPI.h | 28 +- samples/client/petstore/c/api/StoreAPI.c | 441 +- samples/client/petstore/c/api/StoreAPI.h | 14 +- samples/client/petstore/c/api/UserAPI.c | 886 ++-- samples/client/petstore/c/api/UserAPI.h | 26 +- samples/client/petstore/c/external/cJSON.c | 4333 +++++++++-------- samples/client/petstore/c/external/cJSON.h | 282 +- samples/client/petstore/c/include/apiClient.h | 25 +- .../client/petstore/c/include/keyValuePair.h | 6 +- samples/client/petstore/c/include/list.h | 41 +- .../client/petstore/c/model/api_response.c | 152 +- .../client/petstore/c/model/api_response.h | 14 +- samples/client/petstore/c/model/category.c | 111 +- samples/client/petstore/c/model/category.h | 11 +- samples/client/petstore/c/model/object.c | 22 +- samples/client/petstore/c/model/object.h | 2 +- samples/client/petstore/c/model/order.c | 288 +- samples/client/petstore/c/model/order.h | 30 +- samples/client/petstore/c/model/pet.c | 422 +- samples/client/petstore/c/model/pet.h | 30 +- samples/client/petstore/c/model/tag.c | 109 +- samples/client/petstore/c/model/tag.h | 11 +- samples/client/petstore/c/model/user.c | 331 +- samples/client/petstore/c/model/user.h | 30 +- samples/client/petstore/c/src/apiClient.c | 743 ++- samples/client/petstore/c/src/apiKey.c | 10 +- samples/client/petstore/c/src/list.c | 212 +- 31 files changed, 4959 insertions(+), 4833 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/C-libcurl/model-body.mustache b/modules/openapi-generator/src/main/resources/C-libcurl/model-body.mustache index eafb8a326a8..c53d1c36cf4 100644 --- a/modules/openapi-generator/src/main/resources/C-libcurl/model-body.mustache +++ b/modules/openapi-generator/src/main/resources/C-libcurl/model-body.mustache @@ -189,15 +189,15 @@ return 0; {{/isContainer}} {{/vars}} ) { - {{classname}}_t *{{classname}}_local_var = malloc(sizeof({{classname}}_t)); + {{classname}}_t *{{classname}}_local_var = malloc(sizeof({{classname}}_t)); if (!{{classname}}_local_var) { return NULL; } - {{#vars}} - {{classname}}_local_var->{{{baseName}}} = {{{baseName}}}; - {{/vars}} + {{#vars}} + {{classname}}_local_var->{{{baseName}}} = {{{baseName}}}; + {{/vars}} - return {{classname}}_local_var; + return {{classname}}_local_var; } @@ -241,36 +241,36 @@ void {{classname}}_free({{classname}}_t *{{classname}}) { {{#isContainer}} {{#isListContainer}} {{#isPrimitiveType}} - list_ForEach(listEntry, {{classname}}->{{baseName}}) { - free(listEntry->data); - } - list_free({{classname}}->{{baseName}}); + list_ForEach(listEntry, {{classname}}->{{baseName}}) { + free(listEntry->data); + } + list_free({{classname}}->{{baseName}}); {{/isPrimitiveType}} {{^isPrimitiveType}} - list_ForEach(listEntry, {{classname}}->{{baseName}}) { - {{complexType}}_free(listEntry->data); - } - list_free({{classname}}->{{baseName}}); + list_ForEach(listEntry, {{classname}}->{{baseName}}) { + {{complexType}}_free(listEntry->data); + } + list_free({{classname}}->{{baseName}}); {{/isPrimitiveType}} {{/isListContainer}} {{#isMapContainer}} - list_ForEach(listEntry, {{classname}}->{{baseName}}) { - keyValuePair_t *localMapKeyPair = (keyValuePair_t*) listEntry->data; + list_ForEach(listEntry, {{classname}}->{{baseName}}) { + keyValuePair_t *localKeyValue = (keyValuePair_t*) listEntry->data; free (localKeyValue->key); free (localKeyValue->value); - } - list_free({{classname}}->{{baseName}}); + } + list_free({{classname}}->{{baseName}}); {{/isMapContainer}} {{/isContainer}} {{/vars}} - free({{classname}}); + free({{classname}}); } cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { - cJSON *item = cJSON_CreateObject(); - {{#vars}} + cJSON *item = cJSON_CreateObject(); + {{#vars}} - // {{{classname}}}->{{{baseName}}} + // {{{classname}}}->{{{baseName}}} {{#required}} {{^isEnum}} if (!{{{classname}}}->{{{baseName}}}) { @@ -279,8 +279,8 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { {{/isEnum}} {{/required}} {{^required}}{{^isEnum}}if({{{classname}}}->{{{baseName}}}) { {{/isEnum}}{{/required}} - {{^isContainer}} - {{#isPrimitiveType}} + {{^isContainer}} + {{#isPrimitiveType}} {{#isNumeric}} if(cJSON_AddNumberToObject(item, "{{{baseName}}}", {{{classname}}}->{{{baseName}}}) == NULL) { goto fail; //Numeric @@ -328,8 +328,8 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { goto fail; //Date-Time } {{/isDateTime}} - {{/isPrimitiveType}} - {{^isPrimitiveType}} + {{/isPrimitiveType}} + {{^isPrimitiveType}} {{#isModel}} {{#isEnum}} cJSON *{{{baseName}}}_enum_local_JSON = {{datatypeWithEnum}}_convertToJSON({{{classname}}}->{{{baseName}}}); @@ -372,17 +372,17 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { goto fail; } {{/isFreeFormObject}} - {{/isPrimitiveType}} - {{/isContainer}} - {{#isContainer}} - {{#isListContainer}} - {{#isPrimitiveType}} - cJSON *{{{name}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}"); - if({{{name}}} == NULL) { - goto fail; //primitive container - } + {{/isPrimitiveType}} + {{/isContainer}} + {{#isContainer}} + {{#isListContainer}} + {{#isPrimitiveType}} + cJSON *{{{name}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}"); + if({{{name}}} == NULL) { + goto fail; //primitive container + } - listEntry_t *{{{name}}}ListEntry; + listEntry_t *{{{name}}}ListEntry; list_ForEach({{{name}}}ListEntry, {{{classname}}}->{{{baseName}}}) { {{#items}} {{#isString}} @@ -399,8 +399,8 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { {{/isString}} {{/items}} } - {{/isPrimitiveType}} - {{^isPrimitiveType}} + {{/isPrimitiveType}} + {{^isPrimitiveType}} cJSON *{{{baseName}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}"); if({{{baseName}}} == NULL) { goto fail; //nonprimitive container @@ -416,15 +416,15 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { cJSON_AddItemToArray({{{baseName}}}, itemLocal); } } - {{/isPrimitiveType}} - {{/isListContainer}} - {{#isMapContainer}} - cJSON *{{{baseName}}} = cJSON_AddObjectToObject(item, "{{{baseName}}}"); - if({{{baseName}}} == NULL) { - goto fail; //primitive map container - } + {{/isPrimitiveType}} + {{/isListContainer}} + {{#isMapContainer}} + cJSON *{{{baseName}}} = cJSON_AddObjectToObject(item, "{{{baseName}}}"); + if({{{baseName}}} == NULL) { + goto fail; //primitive map container + } cJSON *localMapObject = cJSON_CreateObject(); //Memory free to be implemented in user code - listEntry_t *{{{baseName}}}ListEntry; + listEntry_t *{{{baseName}}}ListEntry; if ({{{classname}}}->{{{baseName}}}) { list_ForEach({{{baseName}}}ListEntry, {{{classname}}}->{{{baseName}}}) { keyValuePair_t *localKeyValue = (keyValuePair_t*){{{baseName}}}ListEntry->data; @@ -445,19 +445,19 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { cJSON_AddItemToObject({{{baseName}}},"", localMapObject); } } - {{/isMapContainer}} - {{/isContainer}} - {{^required}} + {{/isMapContainer}} + {{/isContainer}} + {{^required}} {{^isEnum}} } {{/isEnum}} - {{/required}} + {{/required}} {{/vars}} - return item; + return item; fail: - if (item) { + if (item) { cJSON_Delete(item); } - return NULL; + return NULL; } {{classname}}_t *{{classname}}_parseFromJSON(cJSON *{{classname}}JSON){ @@ -526,8 +526,8 @@ fail: char* decoded = base64decode({{{baseName}}}->valuestring, strlen({{{baseName}}}->valuestring)); decoded_str_{{{baseName}}}->data = malloc(strlen(decoded) - 1); if (!decoded_str_{{{baseName}}}->data) { - goto end; - } + goto end; + } memcpy(decoded_str_{{{baseName}}}->data,decoded,(strlen(decoded)-1)); decoded_str_{{{baseName}}}->len = strlen(decoded) - 1; {{/isBinary}} diff --git a/samples/client/petstore/c/.openapi-generator/VERSION b/samples/client/petstore/c/.openapi-generator/VERSION index d168f1d8bda..e4955748d3e 100644 --- a/samples/client/petstore/c/.openapi-generator/VERSION +++ b/samples/client/petstore/c/.openapi-generator/VERSION @@ -1 +1 @@ -4.2.1-SNAPSHOT \ No newline at end of file +4.2.2-SNAPSHOT \ No newline at end of file diff --git a/samples/client/petstore/c/CMakeLists.txt b/samples/client/petstore/c/CMakeLists.txt index 1de992031da..e685f785dde 100644 --- a/samples/client/petstore/c/CMakeLists.txt +++ b/samples/client/petstore/c/CMakeLists.txt @@ -63,27 +63,28 @@ install(TARGETS ${pkgName} DESTINATION ${CMAKE_INSTALL_PREFIX}) set(SRCS "") set(HDRS "") -# This section shows how to use the above compiled libary to compile the source files -# set source files -set(SRCS - unit-tests/manual-PetAPI.c - unit-tests/manual-StoreAPI.c - unit-tests/manual-UserAPI.c - unit-tests/manual-order.c - unit-tests/manual-user.c) -#set header files -set(HDRS -) +## This section shows how to use the above compiled libary to compile the source files +## set source files +#set(SRCS +# unit-tests/manual-PetAPI.c +# unit-tests/manual-StoreAPI.c +# unit-tests/manual-UserAPI.c +# unit-tests/manual-order.c +# unit-tests/manual-user.c) -# loop over all files in SRCS variable -foreach(SOURCE_FILE ${SRCS}) - # Get only the file name from the file as add_executable doesnot support executable with slash("/") - get_filename_component(FILE_NAME_ONLY ${SOURCE_FILE} NAME_WE) - # Remove .c from the file name and set it as executable name - string( REPLACE ".c" "" EXECUTABLE_FILE ${FILE_NAME_ONLY}) - # Add executable for every source file in SRCS - add_executable(unit-${EXECUTABLE_FILE} ${SOURCE_FILE}) - # Link above created libary to executable and dependent libary curl - target_link_libraries(unit-${EXECUTABLE_FILE} ${CURL_LIBRARIES} ${pkgName} ) -endforeach(SOURCE_FILE ${SRCS}) +##set header files +#set(HDRS +#) + +## loop over all files in SRCS variable +#foreach(SOURCE_FILE ${SRCS}) +# # Get only the file name from the file as add_executable doesnot support executable with slash("/") +# get_filename_component(FILE_NAME_ONLY ${SOURCE_FILE} NAME_WE) +# # Remove .c from the file name and set it as executable name +# string( REPLACE ".c" "" EXECUTABLE_FILE ${FILE_NAME_ONLY}) +# # Add executable for every source file in SRCS +# add_executable(unit-${EXECUTABLE_FILE} ${SOURCE_FILE}) +# # Link above created libary to executable and dependent libary curl +# target_link_libraries(unit-${EXECUTABLE_FILE} ${CURL_LIBRARIES} ${pkgName} ) +#endforeach(SOURCE_FILE ${SRCS}) diff --git a/samples/client/petstore/c/api/PetAPI.c b/samples/client/petstore/c/api/PetAPI.c index cc7bc440c84..59383928642 100644 --- a/samples/client/petstore/c/api/PetAPI.c +++ b/samples/client/petstore/c/api/PetAPI.c @@ -6,630 +6,643 @@ #define MAX_BUFFER_LENGTH 4096 #define intToStr(dst, src) \ - do { \ - char dst[256]; \ - snprintf(dst, 256, "%ld", (long int) (src)); \ - } while(0) + do {\ + char dst[256];\ + snprintf(dst, 256, "%ld", (long int)(src));\ +}while(0) // Add a new pet to the store // -void PetAPI_addPet(apiClient_t *apiClient, pet_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = list_create(); - char *localVarBodyParameters = NULL; +void +PetAPI_addPet(apiClient_t *apiClient ,pet_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = list_create(); + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet"); + // create the path + long sizeOfPath = strlen("/pet")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet"); - // Body Param - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - // string - localVarSingleItemJSON_body = pet_convertToJSON(body); - localVarBodyParameters = - cJSON_Print(localVarSingleItemJSON_body); - } - list_addElement(localVarContentType, "application/json"); // consumes - list_addElement(localVarContentType, "application/xml"); // consumes - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + // Body Param + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + //string + localVarSingleItemJSON_body = pet_convertToJSON(body); + localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body); + } + list_addElement(localVarContentType,"application/json"); //consumes + list_addElement(localVarContentType,"application/xml"); //consumes + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 405) { - printf("%s\n", "Invalid input"); - } - // No return type + if (apiClient->response_code == 405) { + printf("%s\n","Invalid input"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + list_free(localVarContentType); + free(localVarPath); + cJSON_Delete(localVarSingleItemJSON_body); + free(localVarBodyParameters); - - - - list_free(localVarContentType); - free(localVarPath); - cJSON_Delete(localVarSingleItemJSON_body); - free(localVarBodyParameters); } // Deletes a pet // -void PetAPI_deletePet(apiClient_t *apiClient, long petId, char *api_key) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = list_create(); - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +PetAPI_deletePet(apiClient_t *apiClient ,long petId ,char * api_key) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = list_create(); + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet/{petId}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet/{petId}"); + // create the path + long sizeOfPath = strlen("/pet/{petId}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet/{petId}"); - // Path Params - long sizeOfPathParams_petId = sizeof(petId) + 3 + strlen("{ petId }"); - if(petId == 0) { - goto end; - } - char *localVarToReplace_petId = malloc(sizeOfPathParams_petId); - snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", - "petId"); + // Path Params + long sizeOfPathParams_petId = sizeof(petId)+3 + strlen("{ petId }"); + if(petId == 0){ + goto end; + } + char* localVarToReplace_petId = malloc(sizeOfPathParams_petId); + snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", "petId"); - char localVarBuff_petId[256]; - intToStr(localVarBuff_petId, petId); + char localVarBuff_petId[256]; + intToStr(localVarBuff_petId, petId); - localVarPath = strReplace(localVarPath, localVarToReplace_petId, - localVarBuff_petId); + localVarPath = strReplace(localVarPath, localVarToReplace_petId, localVarBuff_petId); - // header parameters - char *keyHeader_api_key; - char *valueHeader_api_key; - keyValuePair_t *keyPairHeader_api_key = 0; - if(api_key) { - keyHeader_api_key = strdup("api_key"); - valueHeader_api_key = strdup((api_key)); - keyPairHeader_api_key = keyValuePair_create(keyHeader_api_key, - valueHeader_api_key); - list_addElement(localVarHeaderParameters, - keyPairHeader_api_key); - } + // header parameters + char *keyHeader_api_key; + char * valueHeader_api_key; + keyValuePair_t *keyPairHeader_api_key = 0; + if (api_key) { + keyHeader_api_key = strdup("api_key"); + valueHeader_api_key = strdup((api_key)); + keyPairHeader_api_key = keyValuePair_create(keyHeader_api_key, valueHeader_api_key); + list_addElement(localVarHeaderParameters,keyPairHeader_api_key); + } - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "DELETE"); + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "DELETE"); - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid pet value"); - } - // No return type + if (apiClient->response_code == 400) { + printf("%s\n","Invalid pet value"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + list_free(localVarHeaderParameters); + + + + free(localVarPath); + free(localVarToReplace_petId); + free(keyHeader_api_key); + free(valueHeader_api_key); + free(keyPairHeader_api_key); - list_free(localVarHeaderParameters); - - - - free(localVarPath); - free(localVarToReplace_petId); - free(keyHeader_api_key); - free(valueHeader_api_key); - free(keyPairHeader_api_key); } // Finds Pets by status // // Multiple status values can be provided with comma separated strings // -list_t *PetAPI_findPetsByStatus(apiClient_t *apiClient, list_t *status) { - list_t *localVarQueryParameters = list_create(); - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +list_t* +PetAPI_findPetsByStatus(apiClient_t *apiClient ,list_t * status) +{ + list_t *localVarQueryParameters = list_create(); + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet/findByStatus") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet/findByStatus"); + // create the path + long sizeOfPath = strlen("/pet/findByStatus")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet/findByStatus"); - // query parameters - if(status) { - list_addElement(localVarQueryParameters, status); - } - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + // query parameters + if (status) + { + list_addElement(localVarQueryParameters,status); + } + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid status value"); - } - cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - if(!cJSON_IsArray(PetAPIlocalVarJSON)) { - return 0; // nonprimitive container - } - list_t *elementToReturn = list_create(); - cJSON *VarJSON; - cJSON_ArrayForEach(VarJSON, PetAPIlocalVarJSON) - { - if(!cJSON_IsObject(VarJSON)) { - // return 0; - } - char *localVarJSONToChar = cJSON_Print(VarJSON); - list_addElement(elementToReturn, localVarJSONToChar); - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid status value"); + } + cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + if(!cJSON_IsArray(PetAPIlocalVarJSON)) { + return 0;//nonprimitive container + } + list_t *elementToReturn = list_create(); + cJSON *VarJSON; + cJSON_ArrayForEach(VarJSON, PetAPIlocalVarJSON) + { + if(!cJSON_IsObject(VarJSON)) + { + // return 0; + } + char *localVarJSONToChar = cJSON_Print(VarJSON); + list_addElement(elementToReturn , localVarJSONToChar); + } - cJSON_Delete(PetAPIlocalVarJSON); - cJSON_Delete(VarJSON); - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - list_free(localVarQueryParameters); - - - list_free(localVarHeaderType); - - free(localVarPath); - return elementToReturn; + cJSON_Delete( PetAPIlocalVarJSON); + cJSON_Delete( VarJSON); + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + list_free(localVarQueryParameters); + + + list_free(localVarHeaderType); + + free(localVarPath); + return elementToReturn; end: - return NULL; + return NULL; + } // Finds Pets by tags // // Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. // -list_t *PetAPI_findPetsByTags(apiClient_t *apiClient, list_t *tags) { - list_t *localVarQueryParameters = list_create(); - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +list_t* +PetAPI_findPetsByTags(apiClient_t *apiClient ,list_t * tags) +{ + list_t *localVarQueryParameters = list_create(); + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet/findByTags") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet/findByTags"); + // create the path + long sizeOfPath = strlen("/pet/findByTags")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet/findByTags"); - // query parameters - if(tags) { - list_addElement(localVarQueryParameters, tags); - } - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + // query parameters + if (tags) + { + list_addElement(localVarQueryParameters,tags); + } + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid tag value"); - } - cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - if(!cJSON_IsArray(PetAPIlocalVarJSON)) { - return 0; // nonprimitive container - } - list_t *elementToReturn = list_create(); - cJSON *VarJSON; - cJSON_ArrayForEach(VarJSON, PetAPIlocalVarJSON) - { - if(!cJSON_IsObject(VarJSON)) { - // return 0; - } - char *localVarJSONToChar = cJSON_Print(VarJSON); - list_addElement(elementToReturn, localVarJSONToChar); - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid tag value"); + } + cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + if(!cJSON_IsArray(PetAPIlocalVarJSON)) { + return 0;//nonprimitive container + } + list_t *elementToReturn = list_create(); + cJSON *VarJSON; + cJSON_ArrayForEach(VarJSON, PetAPIlocalVarJSON) + { + if(!cJSON_IsObject(VarJSON)) + { + // return 0; + } + char *localVarJSONToChar = cJSON_Print(VarJSON); + list_addElement(elementToReturn , localVarJSONToChar); + } - cJSON_Delete(PetAPIlocalVarJSON); - cJSON_Delete(VarJSON); - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - list_free(localVarQueryParameters); - - - list_free(localVarHeaderType); - - free(localVarPath); - return elementToReturn; + cJSON_Delete( PetAPIlocalVarJSON); + cJSON_Delete( VarJSON); + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + list_free(localVarQueryParameters); + + + list_free(localVarHeaderType); + + free(localVarPath); + return elementToReturn; end: - return NULL; + return NULL; + } // Find pet by ID // // Returns a single pet // -pet_t *PetAPI_getPetById(apiClient_t *apiClient, long petId) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +pet_t* +PetAPI_getPetById(apiClient_t *apiClient ,long petId) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet/{petId}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet/{petId}"); + // create the path + long sizeOfPath = strlen("/pet/{petId}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet/{petId}"); - // Path Params - long sizeOfPathParams_petId = sizeof(petId) + 3 + strlen("{ petId }"); - if(petId == 0) { - goto end; - } - char *localVarToReplace_petId = malloc(sizeOfPathParams_petId); - snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", - "petId"); + // Path Params + long sizeOfPathParams_petId = sizeof(petId)+3 + strlen("{ petId }"); + if(petId == 0){ + goto end; + } + char* localVarToReplace_petId = malloc(sizeOfPathParams_petId); + snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", "petId"); - char localVarBuff_petId[256]; - intToStr(localVarBuff_petId, petId); + char localVarBuff_petId[256]; + intToStr(localVarBuff_petId, petId); - localVarPath = strReplace(localVarPath, localVarToReplace_petId, - localVarBuff_petId); + localVarPath = strReplace(localVarPath, localVarToReplace_petId, localVarBuff_petId); - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid ID supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "Pet not found"); - } - // nonprimitive not container - cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - pet_t *elementToReturn = pet_parseFromJSON(PetAPIlocalVarJSON); - cJSON_Delete(PetAPIlocalVarJSON); - if(elementToReturn == NULL) { - // return 0; - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid ID supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","Pet not found"); + } + //nonprimitive not container + cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + pet_t *elementToReturn = pet_parseFromJSON(PetAPIlocalVarJSON); + cJSON_Delete(PetAPIlocalVarJSON); + if(elementToReturn == NULL) { + // return 0; + } - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - - - - list_free(localVarHeaderType); - - free(localVarPath); - free(localVarToReplace_petId); - return elementToReturn; + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + list_free(localVarHeaderType); + + free(localVarPath); + free(localVarToReplace_petId); + return elementToReturn; end: - return NULL; + return NULL; + } // Update an existing pet // -void PetAPI_updatePet(apiClient_t *apiClient, pet_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = list_create(); - char *localVarBodyParameters = NULL; +void +PetAPI_updatePet(apiClient_t *apiClient ,pet_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = list_create(); + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet"); + // create the path + long sizeOfPath = strlen("/pet")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet"); - // Body Param - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - // string - localVarSingleItemJSON_body = pet_convertToJSON(body); - localVarBodyParameters = - cJSON_Print(localVarSingleItemJSON_body); - } - list_addElement(localVarContentType, "application/json"); // consumes - list_addElement(localVarContentType, "application/xml"); // consumes - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "PUT"); + // Body Param + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + //string + localVarSingleItemJSON_body = pet_convertToJSON(body); + localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body); + } + list_addElement(localVarContentType,"application/json"); //consumes + list_addElement(localVarContentType,"application/xml"); //consumes + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "PUT"); - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid ID supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "Pet not found"); - } - if(apiClient->response_code == 405) { - printf("%s\n", "Validation exception"); - } - // No return type + if (apiClient->response_code == 400) { + printf("%s\n","Invalid ID supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","Pet not found"); + } + if (apiClient->response_code == 405) { + printf("%s\n","Validation exception"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + list_free(localVarContentType); + free(localVarPath); + cJSON_Delete(localVarSingleItemJSON_body); + free(localVarBodyParameters); - - - - list_free(localVarContentType); - free(localVarPath); - cJSON_Delete(localVarSingleItemJSON_body); - free(localVarBodyParameters); } // Updates a pet in the store with form data // -void PetAPI_updatePetWithForm(apiClient_t *apiClient, long petId, char *name, - char *status) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = list_create(); - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = list_create(); - char *localVarBodyParameters = NULL; +void +PetAPI_updatePetWithForm(apiClient_t *apiClient ,long petId ,char * name ,char * status) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = list_create(); + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = list_create(); + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet/{petId}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet/{petId}"); + // create the path + long sizeOfPath = strlen("/pet/{petId}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet/{petId}"); - // Path Params - long sizeOfPathParams_petId = sizeof(petId) + 3 + strlen("{ petId }"); - if(petId == 0) { - goto end; - } - char *localVarToReplace_petId = malloc(sizeOfPathParams_petId); - snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", - "petId"); + // Path Params + long sizeOfPathParams_petId = sizeof(petId)+3 + strlen("{ petId }"); + if(petId == 0){ + goto end; + } + char* localVarToReplace_petId = malloc(sizeOfPathParams_petId); + snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", "petId"); - char localVarBuff_petId[256]; - intToStr(localVarBuff_petId, petId); + char localVarBuff_petId[256]; + intToStr(localVarBuff_petId, petId); - localVarPath = strReplace(localVarPath, localVarToReplace_petId, - localVarBuff_petId); + localVarPath = strReplace(localVarPath, localVarToReplace_petId, localVarBuff_petId); - // form parameters - char *keyForm_name; - char *valueForm_name; - keyValuePair_t *keyPairForm_name = 0; - if(name != NULL) { - keyForm_name = strdup("name"); - valueForm_name = strdup((name)); - keyPairForm_name = keyValuePair_create(keyForm_name, - valueForm_name); - list_addElement(localVarFormParameters, keyPairForm_name); - } + // form parameters + char *keyForm_name; + char * valueForm_name; + keyValuePair_t *keyPairForm_name = 0; + if (name != NULL) + { + keyForm_name = strdup("name"); + valueForm_name = strdup((name)); + keyPairForm_name = keyValuePair_create(keyForm_name,valueForm_name); + list_addElement(localVarFormParameters,keyPairForm_name); + } - // form parameters - char *keyForm_status; - char *valueForm_status; - keyValuePair_t *keyPairForm_status = 0; - if(status != NULL) { - keyForm_status = strdup("status"); - valueForm_status = strdup((status)); - keyPairForm_status = keyValuePair_create(keyForm_status, - valueForm_status); - list_addElement(localVarFormParameters, keyPairForm_status); - } - list_addElement(localVarContentType, - "application/x-www-form-urlencoded"); // consumes - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + // form parameters + char *keyForm_status; + char * valueForm_status; + keyValuePair_t *keyPairForm_status = 0; + if (status != NULL) + { + keyForm_status = strdup("status"); + valueForm_status = strdup((status)); + keyPairForm_status = keyValuePair_create(keyForm_status,valueForm_status); + list_addElement(localVarFormParameters,keyPairForm_status); + } + list_addElement(localVarContentType,"application/x-www-form-urlencoded"); //consumes + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 405) { - printf("%s\n", "Invalid input"); - } - // No return type + if (apiClient->response_code == 405) { + printf("%s\n","Invalid input"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + list_free(localVarFormParameters); + + list_free(localVarContentType); + free(localVarPath); + free(localVarToReplace_petId); + free(keyForm_name); + free(valueForm_name); + keyValuePair_free(keyPairForm_name); + free(keyForm_status); + free(valueForm_status); + keyValuePair_free(keyPairForm_status); - - list_free(localVarFormParameters); - - list_free(localVarContentType); - free(localVarPath); - free(localVarToReplace_petId); - free(keyForm_name); - free(valueForm_name); - keyValuePair_free(keyPairForm_name); - free(keyForm_status); - free(valueForm_status); - keyValuePair_free(keyPairForm_status); } // uploads an image // -api_response_t *PetAPI_uploadFile(apiClient_t *apiClient, long petId, - char *additionalMetadata, binary_t *file) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = list_create(); - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = list_create(); - char *localVarBodyParameters = NULL; +api_response_t* +PetAPI_uploadFile(apiClient_t *apiClient ,long petId ,char * additionalMetadata ,binary_t* file) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = list_create(); + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = list_create(); + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/pet/{petId}/uploadImage") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/pet/{petId}/uploadImage"); + // create the path + long sizeOfPath = strlen("/pet/{petId}/uploadImage")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/pet/{petId}/uploadImage"); - // Path Params - long sizeOfPathParams_petId = sizeof(petId) + 3 + strlen("{ petId }"); - if(petId == 0) { - goto end; - } - char *localVarToReplace_petId = malloc(sizeOfPathParams_petId); - snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", - "petId"); + // Path Params + long sizeOfPathParams_petId = sizeof(petId)+3 + strlen("{ petId }"); + if(petId == 0){ + goto end; + } + char* localVarToReplace_petId = malloc(sizeOfPathParams_petId); + snprintf(localVarToReplace_petId, sizeOfPathParams_petId, "{%s}", "petId"); - char localVarBuff_petId[256]; - intToStr(localVarBuff_petId, petId); + char localVarBuff_petId[256]; + intToStr(localVarBuff_petId, petId); - localVarPath = strReplace(localVarPath, localVarToReplace_petId, - localVarBuff_petId); + localVarPath = strReplace(localVarPath, localVarToReplace_petId, localVarBuff_petId); - // form parameters - char *keyForm_additionalMetadata; - char *valueForm_additionalMetadata; - keyValuePair_t *keyPairForm_additionalMetadata = 0; - if(additionalMetadata != NULL) { - keyForm_additionalMetadata = strdup("additionalMetadata"); - valueForm_additionalMetadata = strdup((additionalMetadata)); - keyPairForm_additionalMetadata = keyValuePair_create( - keyForm_additionalMetadata, - valueForm_additionalMetadata); - list_addElement(localVarFormParameters, - keyPairForm_additionalMetadata); - } + // form parameters + char *keyForm_additionalMetadata; + char * valueForm_additionalMetadata; + keyValuePair_t *keyPairForm_additionalMetadata = 0; + if (additionalMetadata != NULL) + { + keyForm_additionalMetadata = strdup("additionalMetadata"); + valueForm_additionalMetadata = strdup((additionalMetadata)); + keyPairForm_additionalMetadata = keyValuePair_create(keyForm_additionalMetadata,valueForm_additionalMetadata); + list_addElement(localVarFormParameters,keyPairForm_additionalMetadata); + } - // form parameters - char *keyForm_file; - binary_t *valueForm_file; - keyValuePair_t *keyPairForm_file = 0; - if(file != NULL) { - keyForm_file = strdup("file"); - valueForm_file = file; - keyPairForm_file = keyValuePair_create(keyForm_file, - &valueForm_file); - list_addElement(localVarFormParameters, keyPairForm_file); // file adding - } - list_addElement(localVarHeaderType, "application/json"); // produces - list_addElement(localVarContentType, "multipart/form-data"); // consumes - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + // form parameters + char *keyForm_file; + binary_t* valueForm_file; + keyValuePair_t *keyPairForm_file = 0; + if (file != NULL) + { + keyForm_file = strdup("file"); + valueForm_file = file; + keyPairForm_file = keyValuePair_create(keyForm_file, &valueForm_file); + list_addElement(localVarFormParameters,keyPairForm_file); //file adding + } + list_addElement(localVarHeaderType,"application/json"); //produces + list_addElement(localVarContentType,"multipart/form-data"); //consumes + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - // nonprimitive not container - cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - api_response_t *elementToReturn = api_response_parseFromJSON( - PetAPIlocalVarJSON); - cJSON_Delete(PetAPIlocalVarJSON); - if(elementToReturn == NULL) { - // return 0; - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + //nonprimitive not container + cJSON *PetAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + api_response_t *elementToReturn = api_response_parseFromJSON(PetAPIlocalVarJSON); + cJSON_Delete(PetAPIlocalVarJSON); + if(elementToReturn == NULL) { + // return 0; + } - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - - - list_free(localVarFormParameters); - list_free(localVarHeaderType); - list_free(localVarContentType); - free(localVarPath); - free(localVarToReplace_petId); - free(keyForm_additionalMetadata); - free(valueForm_additionalMetadata); - free(keyPairForm_additionalMetadata); - free(keyForm_file); -// free(fileVar_file->data); -// free(fileVar_file); - free(keyPairForm_file); - return elementToReturn; + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + list_free(localVarFormParameters); + list_free(localVarHeaderType); + list_free(localVarContentType); + free(localVarPath); + free(localVarToReplace_petId); + free(keyForm_additionalMetadata); + free(valueForm_additionalMetadata); + free(keyPairForm_additionalMetadata); + free(keyForm_file); +// free(fileVar_file->data); +// free(fileVar_file); + free(keyPairForm_file); + return elementToReturn; end: - return NULL; + return NULL; + } + diff --git a/samples/client/petstore/c/api/PetAPI.h b/samples/client/petstore/c/api/PetAPI.h index be1693168a1..5cb6c9de2c6 100644 --- a/samples/client/petstore/c/api/PetAPI.h +++ b/samples/client/petstore/c/api/PetAPI.h @@ -10,47 +10,55 @@ // Add a new pet to the store // -void PetAPI_addPet(apiClient_t *apiClient, pet_t *body); +void +PetAPI_addPet(apiClient_t *apiClient ,pet_t * body); // Deletes a pet // -void PetAPI_deletePet(apiClient_t *apiClient, long petId, char *api_key); +void +PetAPI_deletePet(apiClient_t *apiClient ,long petId ,char * api_key); // Finds Pets by status // // Multiple status values can be provided with comma separated strings // -list_t *PetAPI_findPetsByStatus(apiClient_t *apiClient, list_t *status); +list_t* +PetAPI_findPetsByStatus(apiClient_t *apiClient ,list_t * status); // Finds Pets by tags // // Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. // -list_t *PetAPI_findPetsByTags(apiClient_t *apiClient, list_t *tags); +list_t* +PetAPI_findPetsByTags(apiClient_t *apiClient ,list_t * tags); // Find pet by ID // // Returns a single pet // -pet_t *PetAPI_getPetById(apiClient_t *apiClient, long petId); +pet_t* +PetAPI_getPetById(apiClient_t *apiClient ,long petId); // Update an existing pet // -void PetAPI_updatePet(apiClient_t *apiClient, pet_t *body); +void +PetAPI_updatePet(apiClient_t *apiClient ,pet_t * body); // Updates a pet in the store with form data // -void PetAPI_updatePetWithForm(apiClient_t *apiClient, long petId, char *name, - char *status); +void +PetAPI_updatePetWithForm(apiClient_t *apiClient ,long petId ,char * name ,char * status); // uploads an image // -api_response_t *PetAPI_uploadFile(apiClient_t *apiClient, long petId, - char *additionalMetadata, binary_t *file); +api_response_t* +PetAPI_uploadFile(apiClient_t *apiClient ,long petId ,char * additionalMetadata ,binary_t* file); + + diff --git a/samples/client/petstore/c/api/StoreAPI.c b/samples/client/petstore/c/api/StoreAPI.c index 11dabde964f..0a4a3a37fed 100644 --- a/samples/client/petstore/c/api/StoreAPI.c +++ b/samples/client/petstore/c/api/StoreAPI.c @@ -6,278 +6,283 @@ #define MAX_BUFFER_LENGTH 4096 #define intToStr(dst, src) \ - do { \ - char dst[256]; \ - snprintf(dst, 256, "%ld", (long int) (src)); \ - } while(0) + do {\ + char dst[256];\ + snprintf(dst, 256, "%ld", (long int)(src));\ +}while(0) // Delete purchase order by ID // // For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors // -void StoreAPI_deleteOrder(apiClient_t *apiClient, char *orderId) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +StoreAPI_deleteOrder(apiClient_t *apiClient ,char * orderId) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/store/order/{orderId}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}"); + // create the path + long sizeOfPath = strlen("/store/order/{orderId}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}"); - // Path Params - long sizeOfPathParams_orderId = strlen(orderId) + 3 + strlen( - "{ orderId }"); - if(orderId == NULL) { - goto end; - } - char *localVarToReplace_orderId = malloc(sizeOfPathParams_orderId); - sprintf(localVarToReplace_orderId, "{%s}", "orderId"); + // Path Params + long sizeOfPathParams_orderId = strlen(orderId)+3 + strlen("{ orderId }"); + if(orderId == NULL) { + goto end; + } + char* localVarToReplace_orderId = malloc(sizeOfPathParams_orderId); + sprintf(localVarToReplace_orderId, "{%s}", "orderId"); - localVarPath = strReplace(localVarPath, localVarToReplace_orderId, - orderId); + localVarPath = strReplace(localVarPath, localVarToReplace_orderId, orderId); - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "DELETE"); + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "DELETE"); - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid ID supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "Order not found"); - } - // No return type + if (apiClient->response_code == 400) { + printf("%s\n","Invalid ID supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","Order not found"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); + free(localVarToReplace_orderId); - - - - - free(localVarPath); - free(localVarToReplace_orderId); } // Returns pet inventories by status // // Returns a map of status codes to quantities // -list_t *StoreAPI_getInventory(apiClient_t *apiClient) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +list_t* +StoreAPI_getInventory(apiClient_t *apiClient) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/store/inventory") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/store/inventory"); + // create the path + long sizeOfPath = strlen("/store/inventory")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/store/inventory"); - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - // primitive reutrn type not simple - cJSON *localVarJSON = cJSON_Parse(apiClient->dataReceived); - cJSON *VarJSON; - list_t *elementToReturn = list_create(); - cJSON_ArrayForEach(VarJSON, localVarJSON) { - keyValuePair_t *keyPair = - keyValuePair_create(strdup( - VarJSON->string), cJSON_Print( - VarJSON)); - list_addElement(elementToReturn, keyPair); - } - cJSON_Delete(localVarJSON); + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + //primitive reutrn type not simple + cJSON *localVarJSON = cJSON_Parse(apiClient->dataReceived); + cJSON *VarJSON; + list_t *elementToReturn = list_create(); + cJSON_ArrayForEach(VarJSON, localVarJSON){ + keyValuePair_t *keyPair = keyValuePair_create(strdup(VarJSON->string), cJSON_Print(VarJSON)); + list_addElement(elementToReturn, keyPair); + } + cJSON_Delete(localVarJSON); - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - - - - list_free(localVarHeaderType); - - free(localVarPath); - return elementToReturn; + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + list_free(localVarHeaderType); + + free(localVarPath); + return elementToReturn; end: - return NULL; + return NULL; + } // Find purchase order by ID // // For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions // -order_t *StoreAPI_getOrderById(apiClient_t *apiClient, long orderId) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +order_t* +StoreAPI_getOrderById(apiClient_t *apiClient ,long orderId) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/store/order/{orderId}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}"); + // create the path + long sizeOfPath = strlen("/store/order/{orderId}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}"); - // Path Params - long sizeOfPathParams_orderId = sizeof(orderId) + 3 + strlen( - "{ orderId }"); - if(orderId == 0) { - goto end; - } - char *localVarToReplace_orderId = malloc(sizeOfPathParams_orderId); - snprintf(localVarToReplace_orderId, sizeOfPathParams_orderId, "{%s}", - "orderId"); + // Path Params + long sizeOfPathParams_orderId = sizeof(orderId)+3 + strlen("{ orderId }"); + if(orderId == 0){ + goto end; + } + char* localVarToReplace_orderId = malloc(sizeOfPathParams_orderId); + snprintf(localVarToReplace_orderId, sizeOfPathParams_orderId, "{%s}", "orderId"); - char localVarBuff_orderId[256]; - intToStr(localVarBuff_orderId, orderId); + char localVarBuff_orderId[256]; + intToStr(localVarBuff_orderId, orderId); - localVarPath = strReplace(localVarPath, localVarToReplace_orderId, - localVarBuff_orderId); + localVarPath = strReplace(localVarPath, localVarToReplace_orderId, localVarBuff_orderId); - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid ID supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "Order not found"); - } - // nonprimitive not container - cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON); - cJSON_Delete(StoreAPIlocalVarJSON); - if(elementToReturn == NULL) { - // return 0; - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid ID supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","Order not found"); + } + //nonprimitive not container + cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON); + cJSON_Delete(StoreAPIlocalVarJSON); + if(elementToReturn == NULL) { + // return 0; + } - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - - - - list_free(localVarHeaderType); - - free(localVarPath); - free(localVarToReplace_orderId); - return elementToReturn; + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + list_free(localVarHeaderType); + + free(localVarPath); + free(localVarToReplace_orderId); + return elementToReturn; end: - return NULL; + return NULL; + } // Place an order for a pet // -order_t *StoreAPI_placeOrder(apiClient_t *apiClient, order_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +order_t* +StoreAPI_placeOrder(apiClient_t *apiClient ,order_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/store/order") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/store/order"); + // create the path + long sizeOfPath = strlen("/store/order")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/store/order"); - // Body Param - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - // string - localVarSingleItemJSON_body = order_convertToJSON(body); - localVarBodyParameters = - cJSON_Print(localVarSingleItemJSON_body); - } - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + // Body Param + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + //string + localVarSingleItemJSON_body = order_convertToJSON(body); + localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body); + } + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid Order"); - } - // nonprimitive not container - cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON); - cJSON_Delete(StoreAPIlocalVarJSON); - if(elementToReturn == NULL) { - // return 0; - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid Order"); + } + //nonprimitive not container + cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON); + cJSON_Delete(StoreAPIlocalVarJSON); + if(elementToReturn == NULL) { + // return 0; + } - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - - - - list_free(localVarHeaderType); - - free(localVarPath); - cJSON_Delete(localVarSingleItemJSON_body); - free(localVarBodyParameters); - return elementToReturn; + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + list_free(localVarHeaderType); + + free(localVarPath); + cJSON_Delete(localVarSingleItemJSON_body); + free(localVarBodyParameters); + return elementToReturn; end: - return NULL; + return NULL; + } + diff --git a/samples/client/petstore/c/api/StoreAPI.h b/samples/client/petstore/c/api/StoreAPI.h index 81d68528f1f..cba13a977d5 100644 --- a/samples/client/petstore/c/api/StoreAPI.h +++ b/samples/client/petstore/c/api/StoreAPI.h @@ -11,23 +11,29 @@ // // For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors // -void StoreAPI_deleteOrder(apiClient_t *apiClient, char *orderId); +void +StoreAPI_deleteOrder(apiClient_t *apiClient ,char * orderId); // Returns pet inventories by status // // Returns a map of status codes to quantities // -list_t *StoreAPI_getInventory(apiClient_t *apiClient); +list_t* +StoreAPI_getInventory(apiClient_t *apiClient); // Find purchase order by ID // // For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions // -order_t *StoreAPI_getOrderById(apiClient_t *apiClient, long orderId); +order_t* +StoreAPI_getOrderById(apiClient_t *apiClient ,long orderId); // Place an order for a pet // -order_t *StoreAPI_placeOrder(apiClient_t *apiClient, order_t *body); +order_t* +StoreAPI_placeOrder(apiClient_t *apiClient ,order_t * body); + + diff --git a/samples/client/petstore/c/api/UserAPI.c b/samples/client/petstore/c/api/UserAPI.c index 9170293951e..1656b4472bc 100644 --- a/samples/client/petstore/c/api/UserAPI.c +++ b/samples/client/petstore/c/api/UserAPI.c @@ -6,546 +6,566 @@ #define MAX_BUFFER_LENGTH 4096 #define intToStr(dst, src) \ - do { \ - char dst[256]; \ - snprintf(dst, 256, "%ld", (long int) (src)); \ - } while(0) + do {\ + char dst[256];\ + snprintf(dst, 256, "%ld", (long int)(src));\ +}while(0) // Create user // // This can only be done by the logged in user. // -void UserAPI_createUser(apiClient_t *apiClient, user_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +UserAPI_createUser(apiClient_t *apiClient ,user_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user"); + // create the path + long sizeOfPath = strlen("/user")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user"); - // Body Param - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - // string - localVarSingleItemJSON_body = user_convertToJSON(body); - localVarBodyParameters = - cJSON_Print(localVarSingleItemJSON_body); - } - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + // Body Param + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + //string + localVarSingleItemJSON_body = user_convertToJSON(body); + localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body); + } + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 0) { - printf("%s\n", "successful operation"); - } - // No return type + if (apiClient->response_code == 0) { + printf("%s\n","successful operation"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); + cJSON_Delete(localVarSingleItemJSON_body); + free(localVarBodyParameters); - - - - - free(localVarPath); - cJSON_Delete(localVarSingleItemJSON_body); - free(localVarBodyParameters); } // Creates list of users with given input array // -void UserAPI_createUsersWithArrayInput(apiClient_t *apiClient, list_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +UserAPI_createUsersWithArrayInput(apiClient_t *apiClient ,list_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/createWithArray") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/createWithArray"); + // create the path + long sizeOfPath = strlen("/user/createWithArray")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/createWithArray"); - // Body Param - // notstring - cJSON *localVar_body; - cJSON *localVarItemJSON_body; - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - localVarItemJSON_body = cJSON_CreateObject(); - localVarSingleItemJSON_body = cJSON_AddArrayToObject( - localVarItemJSON_body, "body"); - if(localVarSingleItemJSON_body == NULL) { - // nonprimitive container + // Body Param + //notstring + cJSON *localVar_body; + cJSON *localVarItemJSON_body; + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + localVarItemJSON_body = cJSON_CreateObject(); + localVarSingleItemJSON_body = cJSON_AddArrayToObject(localVarItemJSON_body, "body"); + if (localVarSingleItemJSON_body == NULL) + { + // nonprimitive container - goto end; - } - } + goto end; + } + } - listEntry_t *bodyBodyListEntry; - list_ForEach(bodyBodyListEntry, body) - { - localVar_body = user_convertToJSON(bodyBodyListEntry->data); - if(localVar_body == NULL) { - goto end; - } - cJSON_AddItemToArray(localVarSingleItemJSON_body, - localVar_body); - localVarBodyParameters = cJSON_Print(localVarItemJSON_body); - } - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + listEntry_t *bodyBodyListEntry; + list_ForEach(bodyBodyListEntry, body) + { + localVar_body = user_convertToJSON(bodyBodyListEntry->data); + if(localVar_body == NULL) + { + goto end; + } + cJSON_AddItemToArray(localVarSingleItemJSON_body, localVar_body); + localVarBodyParameters = cJSON_Print(localVarItemJSON_body); + } + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 0) { - printf("%s\n", "successful operation"); - } - // No return type + if (apiClient->response_code == 0) { + printf("%s\n","successful operation"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); + cJSON_Delete(localVarItemJSON_body); + cJSON_Delete(localVarSingleItemJSON_body); + cJSON_Delete(localVar_body); + free(localVarBodyParameters); - - - - - free(localVarPath); - cJSON_Delete(localVarItemJSON_body); - cJSON_Delete(localVarSingleItemJSON_body); - cJSON_Delete(localVar_body); - free(localVarBodyParameters); } // Creates list of users with given input array // -void UserAPI_createUsersWithListInput(apiClient_t *apiClient, list_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +UserAPI_createUsersWithListInput(apiClient_t *apiClient ,list_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/createWithList") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/createWithList"); + // create the path + long sizeOfPath = strlen("/user/createWithList")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/createWithList"); - // Body Param - // notstring - cJSON *localVar_body; - cJSON *localVarItemJSON_body; - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - localVarItemJSON_body = cJSON_CreateObject(); - localVarSingleItemJSON_body = cJSON_AddArrayToObject( - localVarItemJSON_body, "body"); - if(localVarSingleItemJSON_body == NULL) { - // nonprimitive container + // Body Param + //notstring + cJSON *localVar_body; + cJSON *localVarItemJSON_body; + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + localVarItemJSON_body = cJSON_CreateObject(); + localVarSingleItemJSON_body = cJSON_AddArrayToObject(localVarItemJSON_body, "body"); + if (localVarSingleItemJSON_body == NULL) + { + // nonprimitive container - goto end; - } - } + goto end; + } + } - listEntry_t *bodyBodyListEntry; - list_ForEach(bodyBodyListEntry, body) - { - localVar_body = user_convertToJSON(bodyBodyListEntry->data); - if(localVar_body == NULL) { - goto end; - } - cJSON_AddItemToArray(localVarSingleItemJSON_body, - localVar_body); - localVarBodyParameters = cJSON_Print(localVarItemJSON_body); - } - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "POST"); + listEntry_t *bodyBodyListEntry; + list_ForEach(bodyBodyListEntry, body) + { + localVar_body = user_convertToJSON(bodyBodyListEntry->data); + if(localVar_body == NULL) + { + goto end; + } + cJSON_AddItemToArray(localVarSingleItemJSON_body, localVar_body); + localVarBodyParameters = cJSON_Print(localVarItemJSON_body); + } + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "POST"); - if(apiClient->response_code == 0) { - printf("%s\n", "successful operation"); - } - // No return type + if (apiClient->response_code == 0) { + printf("%s\n","successful operation"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); + cJSON_Delete(localVarItemJSON_body); + cJSON_Delete(localVarSingleItemJSON_body); + cJSON_Delete(localVar_body); + free(localVarBodyParameters); - - - - - free(localVarPath); - cJSON_Delete(localVarItemJSON_body); - cJSON_Delete(localVarSingleItemJSON_body); - cJSON_Delete(localVar_body); - free(localVarBodyParameters); } // Delete user // // This can only be done by the logged in user. // -void UserAPI_deleteUser(apiClient_t *apiClient, char *username) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +UserAPI_deleteUser(apiClient_t *apiClient ,char * username) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/{username}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/{username}"); + // create the path + long sizeOfPath = strlen("/user/{username}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/{username}"); - // Path Params - long sizeOfPathParams_username = strlen(username) + 3 + strlen( - "{ username }"); - if(username == NULL) { - goto end; - } - char *localVarToReplace_username = malloc(sizeOfPathParams_username); - sprintf(localVarToReplace_username, "{%s}", "username"); + // Path Params + long sizeOfPathParams_username = strlen(username)+3 + strlen("{ username }"); + if(username == NULL) { + goto end; + } + char* localVarToReplace_username = malloc(sizeOfPathParams_username); + sprintf(localVarToReplace_username, "{%s}", "username"); - localVarPath = strReplace(localVarPath, localVarToReplace_username, - username); + localVarPath = strReplace(localVarPath, localVarToReplace_username, username); - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "DELETE"); + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "DELETE"); - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid username supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "User not found"); - } - // No return type + if (apiClient->response_code == 400) { + printf("%s\n","Invalid username supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","User not found"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); + free(localVarToReplace_username); - - - - - free(localVarPath); - free(localVarToReplace_username); } // Get user by user name // -user_t *UserAPI_getUserByName(apiClient_t *apiClient, char *username) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +user_t* +UserAPI_getUserByName(apiClient_t *apiClient ,char * username) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/{username}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/{username}"); + // create the path + long sizeOfPath = strlen("/user/{username}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/{username}"); - // Path Params - long sizeOfPathParams_username = strlen(username) + 3 + strlen( - "{ username }"); - if(username == NULL) { - goto end; - } - char *localVarToReplace_username = malloc(sizeOfPathParams_username); - sprintf(localVarToReplace_username, "{%s}", "username"); + // Path Params + long sizeOfPathParams_username = strlen(username)+3 + strlen("{ username }"); + if(username == NULL) { + goto end; + } + char* localVarToReplace_username = malloc(sizeOfPathParams_username); + sprintf(localVarToReplace_username, "{%s}", "username"); - localVarPath = strReplace(localVarPath, localVarToReplace_username, - username); + localVarPath = strReplace(localVarPath, localVarToReplace_username, username); - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid username supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "User not found"); - } - // nonprimitive not container - cJSON *UserAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); - user_t *elementToReturn = user_parseFromJSON(UserAPIlocalVarJSON); - cJSON_Delete(UserAPIlocalVarJSON); - if(elementToReturn == NULL) { - // return 0; - } + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid username supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","User not found"); + } + //nonprimitive not container + cJSON *UserAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); + user_t *elementToReturn = user_parseFromJSON(UserAPIlocalVarJSON); + cJSON_Delete(UserAPIlocalVarJSON); + if(elementToReturn == NULL) { + // return 0; + } - // return type - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - - - - list_free(localVarHeaderType); - - free(localVarPath); - free(localVarToReplace_username); - return elementToReturn; + //return type + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + list_free(localVarHeaderType); + + free(localVarPath); + free(localVarToReplace_username); + return elementToReturn; end: - return NULL; + return NULL; + } // Logs user into the system // -char *UserAPI_loginUser(apiClient_t *apiClient, char *username, - char *password) { - list_t *localVarQueryParameters = list_create(); - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = list_create(); - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +char* +UserAPI_loginUser(apiClient_t *apiClient ,char * username ,char * password) +{ + list_t *localVarQueryParameters = list_create(); + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = list_create(); + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/login") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/login"); + // create the path + long sizeOfPath = strlen("/user/login")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/login"); - // query parameters - char *keyQuery_username; - char *valueQuery_username; - keyValuePair_t *keyPairQuery_username = 0; - if(username) { - keyQuery_username = strdup("username"); - valueQuery_username = strdup((username)); - keyPairQuery_username = keyValuePair_create(keyQuery_username, - valueQuery_username); - list_addElement(localVarQueryParameters, keyPairQuery_username); - } + // query parameters + char *keyQuery_username; + char * valueQuery_username; + keyValuePair_t *keyPairQuery_username = 0; + if (username) + { + keyQuery_username = strdup("username"); + valueQuery_username = strdup((username)); + keyPairQuery_username = keyValuePair_create(keyQuery_username, valueQuery_username); + list_addElement(localVarQueryParameters,keyPairQuery_username); + } - // query parameters - char *keyQuery_password; - char *valueQuery_password; - keyValuePair_t *keyPairQuery_password = 0; - if(password) { - keyQuery_password = strdup("password"); - valueQuery_password = strdup((password)); - keyPairQuery_password = keyValuePair_create(keyQuery_password, - valueQuery_password); - list_addElement(localVarQueryParameters, keyPairQuery_password); - } - list_addElement(localVarHeaderType, "application/xml"); // produces - list_addElement(localVarHeaderType, "application/json"); // produces - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + // query parameters + char *keyQuery_password; + char * valueQuery_password; + keyValuePair_t *keyPairQuery_password = 0; + if (password) + { + keyQuery_password = strdup("password"); + valueQuery_password = strdup((password)); + keyPairQuery_password = keyValuePair_create(keyQuery_password, valueQuery_password); + list_addElement(localVarQueryParameters,keyPairQuery_password); + } + list_addElement(localVarHeaderType,"application/xml"); //produces + list_addElement(localVarHeaderType,"application/json"); //produces + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 200) { - printf("%s\n", "successful operation"); - } - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid username/password supplied"); - } - // primitive reutrn type simple - char *elementToReturn = strdup((char *) apiClient->dataReceived); + if (apiClient->response_code == 200) { + printf("%s\n","successful operation"); + } + if (apiClient->response_code == 400) { + printf("%s\n","Invalid username/password supplied"); + } + //primitive reutrn type simple + char* elementToReturn = strdup((char*)apiClient->dataReceived); - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } - list_free(localVarQueryParameters); - - - list_free(localVarHeaderType); - - free(localVarPath); - free(keyQuery_username); - free(valueQuery_username); - keyValuePair_free(keyPairQuery_username); - free(keyQuery_password); - free(valueQuery_password); - keyValuePair_free(keyPairQuery_password); - return elementToReturn; + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + list_free(localVarQueryParameters); + + + list_free(localVarHeaderType); + + free(localVarPath); + free(keyQuery_username); + free(valueQuery_username); + keyValuePair_free(keyPairQuery_username); + free(keyQuery_password); + free(valueQuery_password); + keyValuePair_free(keyPairQuery_password); + return elementToReturn; end: - return NULL; + return NULL; + } // Logs out current logged in user session // -void UserAPI_logoutUser(apiClient_t *apiClient) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +UserAPI_logoutUser(apiClient_t *apiClient) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/logout") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/logout"); + // create the path + long sizeOfPath = strlen("/user/logout")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/logout"); - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "GET"); + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "GET"); - if(apiClient->response_code == 0) { - printf("%s\n", "successful operation"); - } - // No return type + if (apiClient->response_code == 0) { + printf("%s\n","successful operation"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); - - - - - free(localVarPath); } // Updated user // // This can only be done by the logged in user. // -void UserAPI_updateUser(apiClient_t *apiClient, char *username, user_t *body) { - list_t *localVarQueryParameters = NULL; - list_t *localVarHeaderParameters = NULL; - list_t *localVarFormParameters = NULL; - list_t *localVarHeaderType = NULL; - list_t *localVarContentType = NULL; - char *localVarBodyParameters = NULL; +void +UserAPI_updateUser(apiClient_t *apiClient ,char * username ,user_t * body) +{ + list_t *localVarQueryParameters = NULL; + list_t *localVarHeaderParameters = NULL; + list_t *localVarFormParameters = NULL; + list_t *localVarHeaderType = NULL; + list_t *localVarContentType = NULL; + char *localVarBodyParameters = NULL; - // create the path - long sizeOfPath = strlen("/user/{username}") + 1; - char *localVarPath = malloc(sizeOfPath); - snprintf(localVarPath, sizeOfPath, "/user/{username}"); + // create the path + long sizeOfPath = strlen("/user/{username}")+1; + char *localVarPath = malloc(sizeOfPath); + snprintf(localVarPath, sizeOfPath, "/user/{username}"); - // Path Params - long sizeOfPathParams_username = strlen(username) + 3 + strlen( - "{ username }"); - if(username == NULL) { - goto end; - } - char *localVarToReplace_username = malloc(sizeOfPathParams_username); - sprintf(localVarToReplace_username, "{%s}", "username"); + // Path Params + long sizeOfPathParams_username = strlen(username)+3 + strlen("{ username }"); + if(username == NULL) { + goto end; + } + char* localVarToReplace_username = malloc(sizeOfPathParams_username); + sprintf(localVarToReplace_username, "{%s}", "username"); - localVarPath = strReplace(localVarPath, localVarToReplace_username, - username); + localVarPath = strReplace(localVarPath, localVarToReplace_username, username); - // Body Param - cJSON *localVarSingleItemJSON_body; - if(body != NULL) { - // string - localVarSingleItemJSON_body = user_convertToJSON(body); - localVarBodyParameters = - cJSON_Print(localVarSingleItemJSON_body); - } - apiClient_invoke(apiClient, - localVarPath, - localVarQueryParameters, - localVarHeaderParameters, - localVarFormParameters, - localVarHeaderType, - localVarContentType, - localVarBodyParameters, - "PUT"); + // Body Param + cJSON *localVarSingleItemJSON_body; + if (body != NULL) + { + //string + localVarSingleItemJSON_body = user_convertToJSON(body); + localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body); + } + apiClient_invoke(apiClient, + localVarPath, + localVarQueryParameters, + localVarHeaderParameters, + localVarFormParameters, + localVarHeaderType, + localVarContentType, + localVarBodyParameters, + "PUT"); - if(apiClient->response_code == 400) { - printf("%s\n", "Invalid user supplied"); - } - if(apiClient->response_code == 404) { - printf("%s\n", "User not found"); - } - // No return type + if (apiClient->response_code == 400) { + printf("%s\n","Invalid user supplied"); + } + if (apiClient->response_code == 404) { + printf("%s\n","User not found"); + } + //No return type end: - if(apiClient->dataReceived) { - free(apiClient->dataReceived); - } + if (apiClient->dataReceived) { + free(apiClient->dataReceived); + } + + + + + + free(localVarPath); + free(localVarToReplace_username); + cJSON_Delete(localVarSingleItemJSON_body); + free(localVarBodyParameters); - - - - - free(localVarPath); - free(localVarToReplace_username); - cJSON_Delete(localVarSingleItemJSON_body); - free(localVarBodyParameters); } + diff --git a/samples/client/petstore/c/api/UserAPI.h b/samples/client/petstore/c/api/UserAPI.h index c9475c2e55d..57f04a72194 100644 --- a/samples/client/petstore/c/api/UserAPI.h +++ b/samples/client/petstore/c/api/UserAPI.h @@ -11,43 +11,53 @@ // // This can only be done by the logged in user. // -void UserAPI_createUser(apiClient_t *apiClient, user_t *body); +void +UserAPI_createUser(apiClient_t *apiClient ,user_t * body); // Creates list of users with given input array // -void UserAPI_createUsersWithArrayInput(apiClient_t *apiClient, list_t *body); +void +UserAPI_createUsersWithArrayInput(apiClient_t *apiClient ,list_t * body); // Creates list of users with given input array // -void UserAPI_createUsersWithListInput(apiClient_t *apiClient, list_t *body); +void +UserAPI_createUsersWithListInput(apiClient_t *apiClient ,list_t * body); // Delete user // // This can only be done by the logged in user. // -void UserAPI_deleteUser(apiClient_t *apiClient, char *username); +void +UserAPI_deleteUser(apiClient_t *apiClient ,char * username); // Get user by user name // -user_t *UserAPI_getUserByName(apiClient_t *apiClient, char *username); +user_t* +UserAPI_getUserByName(apiClient_t *apiClient ,char * username); // Logs user into the system // -char *UserAPI_loginUser(apiClient_t *apiClient, char *username, char *password); +char* +UserAPI_loginUser(apiClient_t *apiClient ,char * username ,char * password); // Logs out current logged in user session // -void UserAPI_logoutUser(apiClient_t *apiClient); +void +UserAPI_logoutUser(apiClient_t *apiClient); // Updated user // // This can only be done by the logged in user. // -void UserAPI_updateUser(apiClient_t *apiClient, char *username, user_t *body); +void +UserAPI_updateUser(apiClient_t *apiClient ,char * username ,user_t * body); + + diff --git a/samples/client/petstore/c/external/cJSON.c b/samples/client/petstore/c/external/cJSON.c index 78b3ecfec6f..cbdec4132f1 100644 --- a/samples/client/petstore/c/external/cJSON.c +++ b/samples/client/petstore/c/external/cJSON.c @@ -1,31 +1,30 @@ /* - Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. - */ + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ /* cJSON */ /* JSON parser in C. */ /* disable warnings about old C89 functions in MSVC */ -#if !defined(_CRT_SECURE_NO_DEPRECATE) && \ - defined(_MSC_VER) +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) #define _CRT_SECURE_NO_DEPRECATE #endif @@ -59,85 +58,85 @@ #include "cJSON.h" /* define our own boolean type */ -#define true ((cJSON_bool) 1) -#define false ((cJSON_bool) 0) +#define true ((cJSON_bool)1) +#define false ((cJSON_bool)0) typedef struct { - const unsigned char *json; - size_t position; + const unsigned char *json; + size_t position; } error; static error global_error = { NULL, 0 }; CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) { - return (const char *) (global_error.json + global_error.position); + return (const char*) (global_error.json + global_error.position); } -CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON * item) { - if(!cJSON_IsString(item)) { - return NULL; - } +CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item) { + if (!cJSON_IsString(item)) { + return NULL; + } - return item->valuestring; + return item->valuestring; } /* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ -#if (CJSON_VERSION_MAJOR != 1) || \ - (CJSON_VERSION_MINOR != 7) || \ - (CJSON_VERSION_PATCH != 7) - #error \ - cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 7) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. #endif -CJSON_PUBLIC(const char *) cJSON_Version(void) +CJSON_PUBLIC(const char*) cJSON_Version(void) { - static char version[15]; - sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, - CJSON_VERSION_PATCH); + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); - return version; + return version; } /* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ -static int case_insensitive_strcmp(const unsigned char *string1, - const unsigned char *string2) { - if((string1 == NULL) || - (string2 == NULL)) - { - return 1; - } +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } - if(string1 == string2) { - return 0; - } + if (string1 == string2) + { + return 0; + } - for( ; tolower(*string1) == tolower(*string2); - (void) string1++, string2++) - { - if(*string1 == '\0') { - return 0; - } - } + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } - return tolower(*string1) - tolower(*string2); + return tolower(*string1) - tolower(*string2); } -typedef struct internal_hooks { - void *(*allocate)(size_t size); - void (*deallocate)(void *pointer); - void *(*reallocate)(void *pointer, size_t size); +typedef struct internal_hooks +{ + void *(*allocate)(size_t size); + void (*deallocate)(void *pointer); + void *(*reallocate)(void *pointer, size_t size); } internal_hooks; #if defined(_MSC_VER) /* work around MSVC error C2322: '...' address of dillimport '...' is not static */ -static void *internal_malloc(size_t size) { - return malloc(size); +static void *internal_malloc(size_t size) +{ + return malloc(size); } -static void internal_free(void *pointer) { - free(pointer); +static void internal_free(void *pointer) +{ + free(pointer); } -static void *internal_realloc(void *pointer, size_t size) { - return realloc(pointer, size); +static void *internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); } #else #define internal_malloc malloc @@ -145,2711 +144,2789 @@ static void *internal_realloc(void *pointer, size_t size) { #define internal_realloc realloc #endif -static internal_hooks global_hooks = -{ internal_malloc, internal_free, internal_realloc }; +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; -static unsigned char *cJSON_strdup(const unsigned char *string, - const internal_hooks *const hooks) { - size_t length = 0; - unsigned char *copy = NULL; +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; - if(string == NULL) { - return NULL; - } + if (string == NULL) + { + return NULL; + } - length = strlen((const char *) string) + sizeof(""); - copy = (unsigned char *) hooks->allocate(length); - if(copy == NULL) { - return NULL; - } - memcpy(copy, string, length); + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); - return copy; + return copy; } -CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks * hooks) +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) { - if(hooks == NULL) { - /* Reset hooks */ - global_hooks.allocate = malloc; - global_hooks.deallocate = free; - global_hooks.reallocate = realloc; - return; - } + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } - global_hooks.allocate = malloc; - if(hooks->malloc_fn != NULL) { - global_hooks.allocate = hooks->malloc_fn; - } + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } - global_hooks.deallocate = free; - if(hooks->free_fn != NULL) { - global_hooks.deallocate = hooks->free_fn; - } + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } - /* use realloc only if both free and malloc are used */ - global_hooks.reallocate = NULL; - if((global_hooks.allocate == malloc) && - (global_hooks.deallocate == free)) - { - global_hooks.reallocate = realloc; - } + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } } /* Internal constructor. */ -static cJSON *cJSON_New_Item(const internal_hooks *const hooks) { - cJSON *node = (cJSON *) hooks->allocate(sizeof(cJSON)); - if(node) { - memset(node, '\0', sizeof(cJSON)); - } +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } - return node; + return node; } /* Delete a cJSON structure. */ -CJSON_PUBLIC(void) cJSON_Delete(cJSON * item) +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) { - cJSON *next = NULL; - while(item != NULL) { - next = item->next; - if(!(item->type & cJSON_IsReference) && - (item->child != NULL)) - { - cJSON_Delete(item->child); - } - if(!(item->type & cJSON_IsReference) && - (item->valuestring != NULL)) - { - global_hooks.deallocate(item->valuestring); - } - if(!(item->type & cJSON_StringIsConst) && - (item->string != NULL)) - { - global_hooks.deallocate(item->string); - } - global_hooks.deallocate(item); - item = next; - } + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + } + global_hooks.deallocate(item); + item = next; + } } /* get the decimal point character of the current locale */ -static unsigned char get_decimal_point(void) { +static unsigned char get_decimal_point(void) +{ #ifdef ENABLE_LOCALES - struct lconv *lconv = localeconv(); - return (unsigned char) lconv->decimal_point[0]; + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; #else - return '.'; + return '.'; #endif } -typedef struct { - const unsigned char *content; - size_t length; - size_t offset; - size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ - internal_hooks hooks; +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; } parse_buffer; /* check if the given size is left to read in a given parse buffer (starting with 1) */ -#define can_read(buffer, size) ((buffer != NULL) && \ - (((buffer)->offset + size) <= (buffer)->length)) +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) /* check if the buffer can be accessed at the given index (starting with 0) */ -#define can_access_at_index(buffer, index) ((buffer != NULL) && \ - (((buffer)->offset + index) < \ - (buffer)->length)) -#define cannot_access_at_index(buffer, \ - index) (!can_access_at_index(buffer, index)) +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) /* get a pointer to the buffer at the position */ #define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) /* Parse the input text to generate a number, and populate the result into item. */ -static cJSON_bool parse_number(cJSON *const item, - parse_buffer *const input_buffer) { - double number = 0; - unsigned char *after_end = NULL; - unsigned char number_c_string[64]; - unsigned char decimal_point = get_decimal_point(); - size_t i = 0; +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; - if((input_buffer == NULL) || - (input_buffer->content == NULL)) - { - return false; - } + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } - /* copy the number into a temporary buffer and replace '.' with the decimal point - * of the current locale (for strtod) - * This also takes care of '\0' not necessarily being available for marking the end of the input */ - for(i = 0; (i < (sizeof(number_c_string) - 1)) && - can_access_at_index(input_buffer, i); i++) - { - switch(buffer_at_offset(input_buffer)[i]) { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - case '+': - case '-': - case 'e': - case 'E': - number_c_string[i] = buffer_at_offset(input_buffer)[i]; - break; + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; - case '.': - number_c_string[i] = decimal_point; - break; + case '.': + number_c_string[i] = decimal_point; + break; - default: - goto loop_end; - } - } + default: + goto loop_end; + } + } loop_end: - number_c_string[i] = '\0'; + number_c_string[i] = '\0'; - number = strtod((const char *) number_c_string, (char **) &after_end); - if(number_c_string == after_end) { - return false; /* parse_error */ - } + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } - item->valuedouble = number; + item->valuedouble = number; - /* use saturation in case of overflow */ - if(number >= INT_MAX) { - item->valueint = INT_MAX; - } else if(number <= INT_MIN) { - item->valueint = INT_MIN; - } else { - item->valueint = (int) number; - } + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } - item->type = cJSON_Number; + item->type = cJSON_Number; - input_buffer->offset += (size_t) (after_end - number_c_string); - return true; + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; } /* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ -CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON * object, double number) +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) { - if(number >= INT_MAX) { - object->valueint = INT_MAX; - } else if(number <= INT_MIN) { - object->valueint = INT_MIN; - } else { - object->valueint = (int) number; - } + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } - return object->valuedouble = number; + return object->valuedouble = number; } -typedef struct { - unsigned char *buffer; - size_t length; - size_t offset; - size_t depth; /* current nesting depth (for formatted printing) */ - cJSON_bool noalloc; - cJSON_bool format; /* is this print a formatted print */ - internal_hooks hooks; +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; } printbuffer; /* realloc printbuffer if necessary to have at least "needed" bytes more */ -static unsigned char *ensure(printbuffer *const p, size_t needed) { - unsigned char *newbuffer = NULL; - size_t newsize = 0; +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; - if((p == NULL) || - (p->buffer == NULL)) - { - return NULL; - } + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } - if((p->length > 0) && - (p->offset >= p->length)) - { - /* make sure that offset is valid */ - return NULL; - } + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } - if(needed > INT_MAX) { - /* sizes bigger than INT_MAX are currently not supported */ - return NULL; - } + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } - needed += p->offset + 1; - if(needed <= p->length) { - return p->buffer + p->offset; - } + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } - if(p->noalloc) { - return NULL; - } + if (p->noalloc) { + return NULL; + } - /* calculate new buffer size */ - if(needed > (INT_MAX / 2)) { - /* overflow of int, use INT_MAX if possible */ - if(needed <= INT_MAX) { - newsize = INT_MAX; - } else { - return NULL; - } - } else { - newsize = needed * 2; - } + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } - if(p->hooks.reallocate != NULL) { - /* reallocate with realloc if available */ - newbuffer = (unsigned char *) p->hooks.reallocate(p->buffer, - newsize); - if(newbuffer == NULL) { - p->hooks.deallocate(p->buffer); - p->length = 0; - p->buffer = NULL; + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; - return NULL; - } - } else { - /* otherwise reallocate manually */ - newbuffer = (unsigned char *) p->hooks.allocate(newsize); - if(!newbuffer) { - p->hooks.deallocate(p->buffer); - p->length = 0; - p->buffer = NULL; + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; - return NULL; - } - if(newbuffer) { - memcpy(newbuffer, p->buffer, p->offset + 1); - } - p->hooks.deallocate(p->buffer); - } - p->length = newsize; - p->buffer = newbuffer; + return NULL; + } + if (newbuffer) + { + memcpy(newbuffer, p->buffer, p->offset + 1); + } + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; - return newbuffer + p->offset; + return newbuffer + p->offset; } /* calculate the new length of the string in a printbuffer and update the offset */ -static void update_offset(printbuffer *const buffer) { - const unsigned char *buffer_pointer = NULL; - if((buffer == NULL) || - (buffer->buffer == NULL)) - { - return; - } - buffer_pointer = buffer->buffer + buffer->offset; +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; - buffer->offset += strlen((const char *) buffer_pointer); + buffer->offset += strlen((const char*)buffer_pointer); } /* Render the number nicely from the given item into a string. */ -static cJSON_bool print_number(const cJSON *const item, - printbuffer *const output_buffer) { - unsigned char *output_pointer = NULL; - double d = item->valuedouble; - int length = 0; - size_t i = 0; - unsigned char number_buffer[26]; /* temporary buffer to print the number into */ - unsigned char decimal_point = get_decimal_point(); - double test; +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26]; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test; - if(output_buffer == NULL) { - return false; - } + if (output_buffer == NULL) + { + return false; + } - /* This checks for NaN and Infinity */ - if((d * 0) != 0) { - length = sprintf((char *) number_buffer, "null"); - } else { - /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ - length = sprintf((char *) number_buffer, "%1.15g", d); + /* This checks for NaN and Infinity */ + if ((d * 0) != 0) + { + length = sprintf((char*)number_buffer, "null"); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); - /* Check whether the original double can be recovered */ - if((sscanf((char *) number_buffer, "%lg", &test) != 1) || - ((double) test != d)) - { - /* If not, print with 17 decimal places of precision */ - length = sprintf((char *) number_buffer, "%1.17g", d); - } - } + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || ((double)test != d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } - /* sprintf failed or buffer overrun occured */ - if((length < 0) || - (length > (int) (sizeof(number_buffer) - 1))) - { - return false; - } + /* sprintf failed or buffer overrun occured */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } - /* reserve appropriate space in the output */ - output_pointer = ensure(output_buffer, (size_t) length + sizeof("")); - if(output_pointer == NULL) { - return false; - } + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } - /* copy the printed number to the output and replace locale - * dependent decimal point with '.' */ - for(i = 0; i < ((size_t) length); i++) { - if(number_buffer[i] == decimal_point) { - output_pointer[i] = '.'; - continue; - } + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } - output_pointer[i] = number_buffer[i]; - } - output_pointer[i] = '\0'; + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; - output_buffer->offset += (size_t) length; + output_buffer->offset += (size_t)length; - return true; + return true; } /* parse 4 digit hexadecimal number */ -static unsigned parse_hex4(const unsigned char *const input) { - unsigned int h = 0; - size_t i = 0; +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; - for(i = 0; i < 4; i++) { - /* parse digit */ - if((input[i] >= '0') && - (input[i] <= '9')) - { - h += (unsigned int) input[i] - '0'; - } else if((input[i] >= 'A') && - (input[i] <= 'F')) - { - h += (unsigned int) 10 + input[i] - 'A'; - } else if((input[i] >= 'a') && - (input[i] <= 'f')) - { - h += (unsigned int) 10 + input[i] - 'a'; - } else { /* invalid */ - return 0; - } + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } - if(i < 3) { - /* shift left to make place for the next nibble */ - h = h << 4; - } - } + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } - return h; + return h; } /* converts a UTF-16 literal to UTF-8 * A literal can be one or two sequences of the form \uXXXX */ -static unsigned char utf16_literal_to_utf8( - const unsigned char *const input_pointer, - const unsigned char *const input_end, unsigned char **output_pointer) { - long unsigned int codepoint = 0; - unsigned int first_code = 0; - const unsigned char *first_sequence = input_pointer; - unsigned char utf8_length = 0; - unsigned char utf8_position = 0; - unsigned char sequence_length = 0; - unsigned char first_byte_mark = 0; +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; - if((input_end - first_sequence) < 6) { - /* input ends unexpectedly */ - goto fail; - } + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } - /* get the first utf16 sequence */ - first_code = parse_hex4(first_sequence + 2); + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); - /* check that the code is valid */ - if(((first_code >= 0xDC00) && - (first_code <= 0xDFFF))) - { - goto fail; - } + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } - /* UTF16 surrogate pair */ - if((first_code >= 0xD800) && - (first_code <= 0xDBFF)) - { - const unsigned char *second_sequence = first_sequence + 6; - unsigned int second_code = 0; - sequence_length = 12; /* \uXXXX\uXXXX */ + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ - if((input_end - second_sequence) < 6) { - /* input ends unexpectedly */ - goto fail; - } + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } - if((second_sequence[0] != '\\') || - (second_sequence[1] != 'u')) - { - /* missing second half of the surrogate pair */ - goto fail; - } + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } - /* get the second utf16 sequence */ - second_code = parse_hex4(second_sequence + 2); - /* check that the code is valid */ - if((second_code < 0xDC00) || - (second_code > 0xDFFF)) - { - /* invalid second half of the surrogate pair */ - goto fail; - } + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } - /* calculate the unicode codepoint from the surrogate pair */ - codepoint = 0x10000 + - (((first_code & 0x3FF) << 10) | - (second_code & 0x3FF)); - } else { - sequence_length = 6; /* \uXXXX */ - codepoint = first_code; - } + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } - /* encode as UTF-8 - * takes at maximum 4 bytes to encode: - * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ - if(codepoint < 0x80) { - /* normal ascii, encoding 0xxxxxxx */ - utf8_length = 1; - } else if(codepoint < 0x800) { - /* two bytes, encoding 110xxxxx 10xxxxxx */ - utf8_length = 2; - first_byte_mark = 0xC0; /* 11000000 */ - } else if(codepoint < 0x10000) { - /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ - utf8_length = 3; - first_byte_mark = 0xE0; /* 11100000 */ - } else if(codepoint <= 0x10FFFF) { - /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ - utf8_length = 4; - first_byte_mark = 0xF0; /* 11110000 */ - } else { - /* invalid unicode codepoint */ - goto fail; - } + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } - /* encode as utf8 */ - for(utf8_position = - (unsigned char) (utf8_length - 1); utf8_position > 0; - utf8_position--) { - /* 10xxxxxx */ - (*output_pointer)[utf8_position] = - (unsigned char) ((codepoint | 0x80) & 0xBF); - codepoint >>= 6; - } - /* encode first byte */ - if(utf8_length > 1) { - (*output_pointer)[0] = - (unsigned char) ((codepoint | first_byte_mark) & 0xFF); - } else { - (*output_pointer)[0] = (unsigned char) (codepoint & 0x7F); - } + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } - *output_pointer += utf8_length; + *output_pointer += utf8_length; - return sequence_length; + return sequence_length; fail: - return 0; + return 0; } /* Parse the input text into an unescaped cinput, and populate item. */ -static cJSON_bool parse_string(cJSON *const item, - parse_buffer *const input_buffer) { - const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; - const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; - unsigned char *output_pointer = NULL; - unsigned char *output = NULL; +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; - /* not a string */ - if(buffer_at_offset(input_buffer)[0] != '\"') { - goto fail; - } + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } - { - /* calculate approximate size of the output (overestimate) */ - size_t allocation_length = 0; - size_t skipped_bytes = 0; - while(((size_t) (input_end - input_buffer->content) < - input_buffer->length) && - (*input_end != '\"')) - { - /* is escape sequence */ - if(input_end[0] == '\\') { - if((size_t) (input_end + 1 - - input_buffer->content) >= - input_buffer->length) { - /* prevent buffer overflow when last input character is a backslash */ - goto fail; - } - skipped_bytes++; - input_end++; - } - input_end++; - } - if(((size_t) (input_end - input_buffer->content) >= - input_buffer->length) || - (*input_end != '\"')) - { - goto fail; /* string ended unexpectedly */ - } + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } - /* This is at most how much we need for the output */ - allocation_length = - (size_t) (input_end - buffer_at_offset(input_buffer)) - - skipped_bytes; - output = (unsigned char *) input_buffer->hooks.allocate( - allocation_length + sizeof("")); - if(output == NULL) { - goto fail; /* allocation failure */ - } - } + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } - output_pointer = output; - /* loop through the string literal */ - while(input_pointer < input_end) { - if(*input_pointer != '\\') { - *output_pointer++ = *input_pointer++; - } - /* escape sequence */ - else { - unsigned char sequence_length = 2; - if((input_end - input_pointer) < 1) { - goto fail; - } + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } - switch(input_pointer[1]) { - case 'b': - *output_pointer++ = '\b'; - break; + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; - case 'f': - *output_pointer++ = '\f'; - break; + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; - case 'n': - *output_pointer++ = '\n'; - break; + default: + goto fail; + } + input_pointer += sequence_length; + } + } - case 'r': - *output_pointer++ = '\r'; - break; + /* zero terminate the output */ + *output_pointer = '\0'; - case 't': - *output_pointer++ = '\t'; - break; + item->type = cJSON_String; + item->valuestring = (char*)output; - case '\"': - case '\\': - case '/': - *output_pointer++ = input_pointer[1]; - break; + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; - /* UTF-16 literal */ - case 'u': - sequence_length = utf16_literal_to_utf8( - input_pointer, input_end, - &output_pointer); - if(sequence_length == 0) { - /* failed to convert UTF16-literal to UTF-8 */ - goto fail; - } - break; - - default: - goto fail; - } - input_pointer += sequence_length; - } - } - - /* zero terminate the output */ - *output_pointer = '\0'; - - item->type = cJSON_String; - item->valuestring = (char *) output; - - input_buffer->offset = (size_t) (input_end - input_buffer->content); - input_buffer->offset++; - - return true; + return true; fail: - if(output != NULL) { - input_buffer->hooks.deallocate(output); - } + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + } - if(input_pointer != NULL) { - input_buffer->offset = - (size_t) (input_pointer - input_buffer->content); - } + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } - return false; + return false; } /* Render the cstring provided to an escaped version that can be printed. */ -static cJSON_bool print_string_ptr(const unsigned char *const input, - printbuffer *const output_buffer) { - const unsigned char *input_pointer = NULL; - unsigned char *output = NULL; - unsigned char *output_pointer = NULL; - size_t output_length = 0; - /* numbers of additional characters needed for escaping */ - size_t escape_characters = 0; +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; - if(output_buffer == NULL) { - return false; - } + if (output_buffer == NULL) + { + return false; + } - /* empty string */ - if(input == NULL) { - output = ensure(output_buffer, sizeof("\"\"")); - if(output == NULL) { - return false; - } - strcpy((char *) output, "\"\""); + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); - return true; - } + return true; + } - /* set "flag" to 1 if something needs to be escaped */ - for(input_pointer = input; *input_pointer; input_pointer++) { - switch(*input_pointer) { - case '\"': - case '\\': - case '\b': - case '\f': - case '\n': - case '\r': - case '\t': - /* one character escape sequence */ - escape_characters++; - break; + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; - default: - if(*input_pointer < 32) { - /* UTF-16 escape sequence uXXXX */ - escape_characters += 5; - } - break; - } - } - output_length = (size_t) (input_pointer - input) + escape_characters; + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } - output = ensure(output_buffer, output_length + sizeof("\"\"")); - if(output == NULL) { - return false; - } + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; - /* no characters have to be escaped */ - if(escape_characters == 0) { - output[0] = '\"'; - memcpy(output + 1, input, output_length); - output[output_length + 1] = '\"'; - output[output_length + 2] = '\0'; + return true; + } - return true; - } + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; - output[0] = '\"'; - output_pointer = output + 1; - /* copy the string */ - for(input_pointer = input; *input_pointer != '\0'; - (void) input_pointer++, output_pointer++) { - if((*input_pointer > 31) && - (*input_pointer != '\"') && - (*input_pointer != '\\')) - { - /* normal character, copy */ - *output_pointer = *input_pointer; - } else { - /* character needs to be escaped */ - *output_pointer++ = '\\'; - switch(*input_pointer) { - case '\\': - *output_pointer = '\\'; - break; - - case '\"': - *output_pointer = '\"'; - break; - - case '\b': - *output_pointer = 'b'; - break; - - case '\f': - *output_pointer = 'f'; - break; - - case '\n': - *output_pointer = 'n'; - break; - - case '\r': - *output_pointer = 'r'; - break; - - case '\t': - *output_pointer = 't'; - break; - - default: - /* escape and print as unicode codepoint */ - sprintf((char *) output_pointer, "u%04x", - *input_pointer); - output_pointer += 4; - break; - } - } - } - output[output_length + 1] = '\"'; - output[output_length + 2] = '\0'; - - return true; + return true; } /* Invoke print_string_ptr (which is useful) on an item. */ -static cJSON_bool print_string(const cJSON *const item, printbuffer *const p) { - return print_string_ptr((unsigned char *) item->valuestring, p); +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); } /* Predeclare these prototypes. */ -static cJSON_bool parse_value(cJSON *const item, - parse_buffer *const input_buffer); -static cJSON_bool print_value(const cJSON *const item, - printbuffer *const output_buffer); -static cJSON_bool parse_array(cJSON *const item, - parse_buffer *const input_buffer); -static cJSON_bool print_array(const cJSON *const item, - printbuffer *const output_buffer); -static cJSON_bool parse_object(cJSON *const item, - parse_buffer *const input_buffer); -static cJSON_bool print_object(const cJSON *const item, - printbuffer *const output_buffer); +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); /* Utility to jump whitespace and cr/lf */ -static parse_buffer *buffer_skip_whitespace(parse_buffer *const buffer) { - if((buffer == NULL) || - (buffer->content == NULL)) - { - return NULL; - } +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } - while(can_access_at_index(buffer, 0) && - (buffer_at_offset(buffer)[0] <= 32)) - { - buffer->offset++; - } + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } - if(buffer->offset == buffer->length) { - buffer->offset--; - } + if (buffer->offset == buffer->length) + { + buffer->offset--; + } - return buffer; + return buffer; } /* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ -static parse_buffer *skip_utf8_bom(parse_buffer *const buffer) { - if((buffer == NULL) || - (buffer->content == NULL) || - (buffer->offset != 0)) - { - return NULL; - } +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } - if(can_access_at_index(buffer, 4) && - (strncmp((const char *) buffer_at_offset(buffer), "\xEF\xBB\xBF", - 3) == 0)) - { - buffer->offset += 3; - } + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } - return buffer; + return buffer; } /* Parse an object - create a new root, and populate. */ -CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, - const char **return_parse_end, - cJSON_bool require_null_terminated) +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) { - parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; - cJSON *item = NULL; + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; - /* reset error position */ - global_error.json = NULL; - global_error.position = 0; + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; - if(value == NULL) { - goto fail; - } + if (value == NULL) + { + goto fail; + } - buffer.content = (const unsigned char *) value; - buffer.length = strlen((const char *) value) + sizeof(""); - buffer.offset = 0; - buffer.hooks = global_hooks; + buffer.content = (const unsigned char*)value; + buffer.length = strlen((const char*)value) + sizeof(""); + buffer.offset = 0; + buffer.hooks = global_hooks; - item = cJSON_New_Item(&global_hooks); - if(item == NULL) { /* memory fail */ - goto fail; - } + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } - if(!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) { - /* parse failure. ep is set. */ - goto fail; - } + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } - /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ - if(require_null_terminated) { - buffer_skip_whitespace(&buffer); - if((buffer.offset >= buffer.length) || - (buffer_at_offset(&buffer)[0] != '\0') ) - { - goto fail; - } - } - if(return_parse_end) { - *return_parse_end = (const char *) buffer_at_offset(&buffer); - } + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } - return item; + return item; fail: - if(item != NULL) { - cJSON_Delete(item); - } + if (item != NULL) + { + cJSON_Delete(item); + } - if(value != NULL) { - error local_error; - local_error.json = (const unsigned char *) value; - local_error.position = 0; + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; - if(buffer.offset < buffer.length) { - local_error.position = buffer.offset; - } else if(buffer.length > 0) { - local_error.position = buffer.length - 1; - } + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } - if(return_parse_end != NULL) { - *return_parse_end = (const char *) local_error.json + - local_error.position; - } + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } - global_error = local_error; - } + global_error = local_error; + } - return NULL; + return NULL; } /* Default options for cJSON_Parse */ CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) { - return cJSON_ParseWithOpts(value, 0, 0); + return cJSON_ParseWithOpts(value, 0, 0); } #define cjson_min(a, b) ((a < b) ? a : b) -static unsigned char *print(const cJSON *const item, cJSON_bool format, - const internal_hooks *const hooks) { - static const size_t default_buffer_size = 256; - printbuffer buffer[1]; - unsigned char *printed = NULL; +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; - memset(buffer, 0, sizeof(buffer)); + memset(buffer, 0, sizeof(buffer)); - /* create buffer */ - buffer->buffer = (unsigned char *) hooks->allocate(default_buffer_size); - buffer->length = default_buffer_size; - buffer->format = format; - buffer->hooks = *hooks; - if(buffer->buffer == NULL) { - goto fail; - } + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } - /* print the value */ - if(!print_value(item, buffer)) { - goto fail; - } - update_offset(buffer); + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); - /* check if reallocate is available */ - if(hooks->reallocate != NULL) { - printed = (unsigned char *) hooks->reallocate(buffer->buffer, - buffer->offset + - 1); - if(printed == NULL) { - goto fail; - } - buffer->buffer = NULL; - } else { /* otherwise copy the JSON over to a new buffer */ - printed = (unsigned char *) hooks->allocate(buffer->offset + 1); - if(printed == NULL) { - goto fail; - } - memcpy(printed, buffer->buffer, - cjson_min(buffer->length, buffer->offset + 1)); - printed[buffer->offset] = '\0'; /* just to be sure */ + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ - /* free the buffer */ - hooks->deallocate(buffer->buffer); - } + /* free the buffer */ + hooks->deallocate(buffer->buffer); + } - return printed; + return printed; fail: - if(buffer->buffer != NULL) { - hooks->deallocate(buffer->buffer); - } + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + } - if(printed != NULL) { - hooks->deallocate(printed); - } + if (printed != NULL) + { + hooks->deallocate(printed); + } - return NULL; + return NULL; } /* Render a cJSON item/entity/structure to text. */ -CJSON_PUBLIC(char *) cJSON_Print(const cJSON * item) +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) { - return (char *) print(item, true, &global_hooks); + return (char*)print(item, true, &global_hooks); } -CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON * item) +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) { - return (char *) print(item, false, &global_hooks); + return (char*)print(item, false, &global_hooks); } -CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON * item, int prebuffer, - cJSON_bool fmt) +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) { - printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; - if(prebuffer < 0) { - return NULL; - } + if (prebuffer < 0) + { + return NULL; + } - p.buffer = (unsigned char *) global_hooks.allocate((size_t) prebuffer); - if(!p.buffer) { - return NULL; - } + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } - p.length = (size_t) prebuffer; - p.offset = 0; - p.noalloc = false; - p.format = fmt; - p.hooks = global_hooks; + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; - if(!print_value(item, &p)) { - global_hooks.deallocate(p.buffer); - return NULL; - } + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + return NULL; + } - return (char *) p.buffer; + return (char*)p.buffer; } -CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON * item, char *buf, - const int len, - const cJSON_bool fmt) +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt) { - printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; - if((len < 0) || - (buf == NULL)) - { - return false; - } + if ((len < 0) || (buf == NULL)) + { + return false; + } - p.buffer = (unsigned char *) buf; - p.length = (size_t) len; - p.offset = 0; - p.noalloc = true; - p.format = fmt; - p.hooks = global_hooks; + p.buffer = (unsigned char*)buf; + p.length = (size_t)len; + p.offset = 0; + p.noalloc = true; + p.format = fmt; + p.hooks = global_hooks; - return print_value(item, &p); + return print_value(item, &p); } /* Parser core - when encountering text, process appropriately. */ -static cJSON_bool parse_value(cJSON *const item, - parse_buffer *const input_buffer) { - if((input_buffer == NULL) || - (input_buffer->content == NULL)) - { - return false; /* no input */ - } +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } - /* parse the different types of values */ - /* null */ - if(can_read(input_buffer, 4) && - (strncmp((const char *) buffer_at_offset(input_buffer), "null", - 4) == 0)) - { - item->type = cJSON_NULL; - input_buffer->offset += 4; - return true; - } - /* false */ - if(can_read(input_buffer, 5) && - (strncmp((const char *) buffer_at_offset(input_buffer), "false", - 5) == 0)) - { - item->type = cJSON_False; - input_buffer->offset += 5; - return true; - } - /* true */ - if(can_read(input_buffer, 4) && - (strncmp((const char *) buffer_at_offset(input_buffer), "true", - 4) == 0)) - { - item->type = cJSON_True; - item->valueint = 1; - input_buffer->offset += 4; - return true; - } - /* string */ - if(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == '\"')) - { - return parse_string(item, input_buffer); - } - /* number */ - if(can_access_at_index(input_buffer, 0) && - ((buffer_at_offset(input_buffer)[0] == '-') || - ((buffer_at_offset(input_buffer)[0] >= '0') && - (buffer_at_offset(input_buffer)[0] <= '9')))) - { - return parse_number(item, input_buffer); - } - /* array */ - if(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == '[')) - { - return parse_array(item, input_buffer); - } - /* object */ - if(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == '{')) - { - return parse_object(item, input_buffer); - } + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } - return false; + return false; } /* Render a value to text. */ -static cJSON_bool print_value(const cJSON *const item, - printbuffer *const output_buffer) { - unsigned char *output = NULL; +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; - if((item == NULL) || - (output_buffer == NULL)) - { - return false; - } + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } - switch((item->type) & 0xFF) { - case cJSON_NULL: - output = ensure(output_buffer, 5); - if(output == NULL) { - return false; - } - strcpy((char *) output, "null"); - return true; + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; - case cJSON_False: - output = ensure(output_buffer, 6); - if(output == NULL) { - return false; - } - strcpy((char *) output, "false"); - return true; + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; - case cJSON_True: - output = ensure(output_buffer, 5); - if(output == NULL) { - return false; - } - strcpy((char *) output, "true"); - return true; + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; - case cJSON_Number: - return print_number(item, output_buffer); + case cJSON_Number: + return print_number(item, output_buffer); - case cJSON_Raw: - { - size_t raw_length = 0; - if(item->valuestring == NULL) { - return false; - } + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } - raw_length = strlen(item->valuestring) + sizeof(""); - output = ensure(output_buffer, raw_length); - if(output == NULL) { - return false; - } - memcpy(output, item->valuestring, raw_length); - return true; - } + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } - case cJSON_String: - return print_string(item, output_buffer); + case cJSON_String: + return print_string(item, output_buffer); - case cJSON_Array: - return print_array(item, output_buffer); + case cJSON_Array: + return print_array(item, output_buffer); - case cJSON_Object: - return print_object(item, output_buffer); + case cJSON_Object: + return print_object(item, output_buffer); - default: - return false; - } + default: + return false; + } } /* Build an array from input text. */ -static cJSON_bool parse_array(cJSON *const item, - parse_buffer *const input_buffer) { - cJSON *head = NULL; /* head of the linked list */ - cJSON *current_item = NULL; +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; - if(input_buffer->depth >= CJSON_NESTING_LIMIT) { - return false; /* to deeply nested */ - } - input_buffer->depth++; + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; - if(buffer_at_offset(input_buffer)[0] != '[') { - /* not an array */ - goto fail; - } + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } - input_buffer->offset++; - buffer_skip_whitespace(input_buffer); - if(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == ']')) - { - /* empty array */ - goto success; - } + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } - /* check if we skipped to the end of the buffer */ - if(cannot_access_at_index(input_buffer, 0)) { - input_buffer->offset--; - goto fail; - } + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } - /* step back to character in front of the first element */ - input_buffer->offset--; - /* loop through the comma separated array elements */ - do { - /* allocate next item */ - cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); - if(new_item == NULL) { - goto fail; /* allocation failure */ - } + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } - /* attach next item to list */ - if(head == NULL) { - /* start the linked list */ - current_item = head = new_item; - } else { - /* add to the end and advance */ - current_item->next = new_item; - new_item->prev = current_item; - current_item = new_item; - } + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } - /* parse next value */ - input_buffer->offset++; - buffer_skip_whitespace(input_buffer); - if(!parse_value(current_item, input_buffer)) { - goto fail; /* failed to parse value */ - } - buffer_skip_whitespace(input_buffer); - } while(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == ',')); + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); - if(cannot_access_at_index(input_buffer, 0) || - (buffer_at_offset(input_buffer)[0] != ']') ) - { - goto fail; /* expected end of array */ - } + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } success: - input_buffer->depth--; + input_buffer->depth--; - item->type = cJSON_Array; - item->child = head; + item->type = cJSON_Array; + item->child = head; - input_buffer->offset++; + input_buffer->offset++; - return true; + return true; fail: - if(head != NULL) { - cJSON_Delete(head); - } + if (head != NULL) + { + cJSON_Delete(head); + } - return false; + return false; } /* Render an array to text */ -static cJSON_bool print_array(const cJSON *const item, - printbuffer *const output_buffer) { - unsigned char *output_pointer = NULL; - size_t length = 0; - cJSON *current_element = item->child; +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; - if(output_buffer == NULL) { - return false; - } + if (output_buffer == NULL) + { + return false; + } - /* Compose the output array. */ - /* opening square bracket */ - output_pointer = ensure(output_buffer, 1); - if(output_pointer == NULL) { - return false; - } + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } - *output_pointer = '['; - output_buffer->offset++; - output_buffer->depth++; + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; - while(current_element != NULL) { - if(!print_value(current_element, output_buffer)) { - return false; - } - update_offset(output_buffer); - if(current_element->next) { - length = (size_t) (output_buffer->format ? 2 : 1); - output_pointer = ensure(output_buffer, length + 1); - if(output_pointer == NULL) { - return false; - } - *output_pointer++ = ','; - if(output_buffer->format) { - *output_pointer++ = ' '; - } - *output_pointer = '\0'; - output_buffer->offset += length; - } - current_element = current_element->next; - } + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } - output_pointer = ensure(output_buffer, 2); - if(output_pointer == NULL) { - return false; - } - *output_pointer++ = ']'; - *output_pointer = '\0'; - output_buffer->depth--; + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; - return true; + return true; } /* Build an object from the text. */ -static cJSON_bool parse_object(cJSON *const item, - parse_buffer *const input_buffer) { - cJSON *head = NULL; /* linked list head */ - cJSON *current_item = NULL; +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; - if(input_buffer->depth >= CJSON_NESTING_LIMIT) { - return false; /* to deeply nested */ - } - input_buffer->depth++; + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; - if(cannot_access_at_index(input_buffer, 0) || - (buffer_at_offset(input_buffer)[0] != '{')) - { - goto fail; /* not an object */ - } + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } - input_buffer->offset++; - buffer_skip_whitespace(input_buffer); - if(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == '}')) - { - goto success; /* empty object */ - } + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } - /* check if we skipped to the end of the buffer */ - if(cannot_access_at_index(input_buffer, 0)) { - input_buffer->offset--; - goto fail; - } + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } - /* step back to character in front of the first element */ - input_buffer->offset--; - /* loop through the comma separated array elements */ - do { - /* allocate next item */ - cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); - if(new_item == NULL) { - goto fail; /* allocation failure */ - } + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } - /* attach next item to list */ - if(head == NULL) { - /* start the linked list */ - current_item = head = new_item; - } else { - /* add to the end and advance */ - current_item->next = new_item; - new_item->prev = current_item; - current_item = new_item; - } + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } - /* parse the name of the child */ - input_buffer->offset++; - buffer_skip_whitespace(input_buffer); - if(!parse_string(current_item, input_buffer)) { - goto fail; /* faile to parse name */ - } - buffer_skip_whitespace(input_buffer); + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* faile to parse name */ + } + buffer_skip_whitespace(input_buffer); - /* swap valuestring and string, because we parsed the name */ - current_item->string = current_item->valuestring; - current_item->valuestring = NULL; + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; - if(cannot_access_at_index(input_buffer, 0) || - (buffer_at_offset(input_buffer)[0] != ':')) - { - goto fail; /* invalid object */ - } + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } - /* parse the value */ - input_buffer->offset++; - buffer_skip_whitespace(input_buffer); - if(!parse_value(current_item, input_buffer)) { - goto fail; /* failed to parse value */ - } - buffer_skip_whitespace(input_buffer); - } while(can_access_at_index(input_buffer, 0) && - (buffer_at_offset(input_buffer)[0] == ',')); + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); - if(cannot_access_at_index(input_buffer, 0) || - (buffer_at_offset(input_buffer)[0] != '}')) - { - goto fail; /* expected end of object */ - } + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } success: - input_buffer->depth--; + input_buffer->depth--; - item->type = cJSON_Object; - item->child = head; + item->type = cJSON_Object; + item->child = head; - input_buffer->offset++; - return true; + input_buffer->offset++; + return true; fail: - if(head != NULL) { - cJSON_Delete(head); - } + if (head != NULL) + { + cJSON_Delete(head); + } - return false; + return false; } /* Render an object to text. */ -static cJSON_bool print_object(const cJSON *const item, - printbuffer *const output_buffer) { - unsigned char *output_pointer = NULL; - size_t length = 0; - cJSON *current_item = item->child; +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; - if(output_buffer == NULL) { - return false; - } + if (output_buffer == NULL) + { + return false; + } - /* Compose the output: */ - length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ - output_pointer = ensure(output_buffer, length + 1); - if(output_pointer == NULL) { - return false; - } + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } - *output_pointer++ = '{'; - output_buffer->depth++; - if(output_buffer->format) { - *output_pointer++ = '\n'; - } - output_buffer->offset += length; + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; - while(current_item) { - if(output_buffer->format) { - size_t i; - output_pointer = ensure(output_buffer, - output_buffer->depth); - if(output_pointer == NULL) { - return false; - } - for(i = 0; i < output_buffer->depth; i++) { - *output_pointer++ = '\t'; - } - output_buffer->offset += output_buffer->depth; - } + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } - /* print key */ - if(!print_string_ptr((unsigned char *) current_item->string, - output_buffer)) { - return false; - } - update_offset(output_buffer); + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); - length = (size_t) (output_buffer->format ? 2 : 1); - output_pointer = ensure(output_buffer, length); - if(output_pointer == NULL) { - return false; - } - *output_pointer++ = ':'; - if(output_buffer->format) { - *output_pointer++ = '\t'; - } - output_buffer->offset += length; + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; - /* print value */ - if(!print_value(current_item, output_buffer)) { - return false; - } - update_offset(output_buffer); + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); - /* print comma if not last */ - length = - (size_t) ((output_buffer->format ? 1 : 0) + - (current_item->next ? 1 : 0)); - output_pointer = ensure(output_buffer, length + 1); - if(output_pointer == NULL) { - return false; - } - if(current_item->next) { - *output_pointer++ = ','; - } + /* print comma if not last */ + length = (size_t) ((output_buffer->format ? 1 : 0) + (current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } - if(output_buffer->format) { - *output_pointer++ = '\n'; - } - *output_pointer = '\0'; - output_buffer->offset += length; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; - current_item = current_item->next; - } + current_item = current_item->next; + } - output_pointer = - ensure(output_buffer, - output_buffer->format ? (output_buffer->depth + 1) : 2); - if(output_pointer == NULL) { - return false; - } - if(output_buffer->format) { - size_t i; - for(i = 0; i < (output_buffer->depth - 1); i++) { - *output_pointer++ = '\t'; - } - } - *output_pointer++ = '}'; - *output_pointer = '\0'; - output_buffer->depth--; + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; - return true; + return true; } /* Get Array size/item / object item. */ -CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON * array) +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) { - cJSON *child = NULL; - size_t size = 0; + cJSON *child = NULL; + size_t size = 0; - if(array == NULL) { - return 0; - } + if (array == NULL) + { + return 0; + } - child = array->child; + child = array->child; - while(child != NULL) { - size++; - child = child->next; - } + while(child != NULL) + { + size++; + child = child->next; + } - /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ - return (int) size; + return (int)size; } -static cJSON *get_array_item(const cJSON *array, size_t index) { - cJSON *current_child = NULL; - - if(array == NULL) { - return NULL; - } - - current_child = array->child; - while((current_child != NULL) && - (index > 0)) - { - index--; - current_child = current_child->next; - } - - return current_child; -} - -CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON * array, int index) +static cJSON* get_array_item(const cJSON *array, size_t index) { - if(index < 0) { - return NULL; - } + cJSON *current_child = NULL; - return get_array_item(array, (size_t) index); + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; } -static cJSON *get_object_item(const cJSON *const object, const char *const name, - const cJSON_bool case_sensitive) { - cJSON *current_element = NULL; - - if((object == NULL) || - (name == NULL)) - { - return NULL; - } - - current_element = object->child; - if(case_sensitive) { - while((current_element != NULL) && - (strcmp(name, current_element->string) != 0)) - { - current_element = current_element->next; - } - } else { - while((current_element != NULL) && - (case_insensitive_strcmp((const unsigned char *) name, - (const unsigned char *) ( - current_element->string)) - != 0)) - { - current_element = current_element->next; - } - } - - return current_element; -} - -CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, - const char *const string) +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) { - return get_object_item(object, string, false); + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); } -CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive( - const cJSON * const object, const char *const string) +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) { - return get_object_item(object, string, true); + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + return current_element; } -CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON * object, - const char *string) +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) { - return cJSON_GetObjectItem(object, string) ? 1 : 0; + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; } /* Utility for array list handling. */ -static void suffix_object(cJSON *prev, cJSON *item) { - prev->next = item; - item->prev = prev; +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; } /* Utility for handling references. */ -static cJSON *create_reference(const cJSON *item, - const internal_hooks *const hooks) { - cJSON *reference = NULL; - if(item == NULL) { - return NULL; - } +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } - reference = cJSON_New_Item(hooks); - if(reference == NULL) { - return NULL; - } + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } - memcpy(reference, item, sizeof(cJSON)); - reference->string = NULL; - reference->type |= cJSON_IsReference; - reference->next = reference->prev = NULL; - return reference; + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; } -static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) { - cJSON *child = NULL; +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; - if((item == NULL) || - (array == NULL)) - { - return false; - } + if ((item == NULL) || (array == NULL)) + { + return false; + } - child = array->child; + child = array->child; - if(child == NULL) { - /* list is empty, start new one */ - array->child = item; - } else { - /* append to the end */ - while(child->next) { - child = child->next; - } - suffix_object(child, item); - } + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + } + else + { + /* append to the end */ + while (child->next) + { + child = child->next; + } + suffix_object(child, item); + } - return true; + return true; } /* Add item to array/object. */ -CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON * array, cJSON * item) +CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item) { - add_item_to_array(array, item); + add_item_to_array(array, item); } -#if defined(__clang__) || \ - (defined(__GNUC__) && \ - ((__GNUC__ > 4) || \ - ((__GNUC__ == 4) && \ - (__GNUC_MINOR__ > 5)))) +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) #pragma GCC diagnostic push #endif #ifdef __GNUC__ #pragma GCC diagnostic ignored "-Wcast-qual" #endif /* helper function to cast away const */ -static void *cast_away_const(const void *string) { - return (void *) string; +static void* cast_away_const(const void* string) +{ + return (void*)string; } -#if defined(__clang__) || \ - (defined(__GNUC__) && \ - ((__GNUC__ > 4) || \ - ((__GNUC__ == 4) && \ - (__GNUC_MINOR__ > 5)))) +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) #pragma GCC diagnostic pop #endif -static cJSON_bool add_item_to_object(cJSON *const object, - const char *const string, - cJSON *const item, - const internal_hooks *const hooks, - const cJSON_bool constant_key) +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) { - char *new_key = NULL; - int new_type = cJSON_Invalid; + char *new_key = NULL; + int new_type = cJSON_Invalid; - if((object == NULL) || - (string == NULL) || - (item == NULL)) - { - return false; - } + if ((object == NULL) || (string == NULL) || (item == NULL)) + { + return false; + } - if(constant_key) { - new_key = (char *) cast_away_const(string); - new_type = item->type | cJSON_StringIsConst; - } else { - new_key = (char *) cJSON_strdup((const unsigned char *) string, - hooks); - if(new_key == NULL) { - return false; - } + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } - new_type = item->type & ~cJSON_StringIsConst; - } + new_type = item->type & ~cJSON_StringIsConst; + } - if(!(item->type & cJSON_StringIsConst) && - (item->string != NULL)) - { - hooks->deallocate(item->string); - } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } - item->string = new_key; - item->type = new_type; + item->string = new_key; + item->type = new_type; - return add_item_to_array(object, item); + return add_item_to_array(object, item); } -CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON * object, const char *string, - cJSON * item) +CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) { - add_item_to_object(object, string, item, &global_hooks, false); + add_item_to_object(object, string, item, &global_hooks, false); } /* Add an item to an object with constant string as key */ -CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON * object, const char *string, - cJSON * item) +CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) { - add_item_to_object(object, string, item, &global_hooks, true); + add_item_to_object(object, string, item, &global_hooks, true); } -CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON * array, cJSON * item) +CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) { - if(array == NULL) { - return; - } + if (array == NULL) + { + return; + } - add_item_to_array(array, create_reference(item, &global_hooks)); + add_item_to_array(array, create_reference(item, &global_hooks)); } -CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON * object, - const char *string, - cJSON * item) +CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) { - if((object == NULL) || - (string == NULL)) - { - return; - } + if ((object == NULL) || (string == NULL)) + { + return; + } - add_item_to_object(object, string, create_reference(item, - &global_hooks), &global_hooks, - false); + add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); } -CJSON_PUBLIC(cJSON *) cJSON_AddNullToObject(cJSON * const object, - const char *const name) +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) { - cJSON *null = cJSON_CreateNull(); - if(add_item_to_object(object, name, null, &global_hooks, false)) { - return null; - } + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } - cJSON_Delete(null); - return NULL; + cJSON_Delete(null); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddTrueToObject(cJSON * const object, - const char *const name) +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) { - cJSON *true_item = cJSON_CreateTrue(); - if(add_item_to_object(object, name, true_item, &global_hooks, false)) { - return true_item; - } + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } - cJSON_Delete(true_item); - return NULL; + cJSON_Delete(true_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddFalseToObject(cJSON * const object, - const char *const name) +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) { - cJSON *false_item = cJSON_CreateFalse(); - if(add_item_to_object(object, name, false_item, &global_hooks, false)) { - return false_item; - } + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } - cJSON_Delete(false_item); - return NULL; + cJSON_Delete(false_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddBoolToObject(cJSON * const object, - const char *const name, - const cJSON_bool boolean) +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) { - cJSON *bool_item = cJSON_CreateBool(boolean); - if(add_item_to_object(object, name, bool_item, &global_hooks, false)) { - return bool_item; - } + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } - cJSON_Delete(bool_item); - return NULL; + cJSON_Delete(bool_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddNumberToObject(cJSON * const object, - const char *const name, - const double number) +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) { - cJSON *number_item = cJSON_CreateNumber(number); - if(add_item_to_object(object, name, number_item, &global_hooks, - false)) { - return number_item; - } + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } - cJSON_Delete(number_item); - return NULL; + cJSON_Delete(number_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddStringToObject(cJSON * const object, - const char *const name, - const char *const string) +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) { - cJSON *string_item = cJSON_CreateString(string); - if(add_item_to_object(object, name, string_item, &global_hooks, - false)) { - return string_item; - } + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } - cJSON_Delete(string_item); - return NULL; + cJSON_Delete(string_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddRawToObject(cJSON * const object, - const char *const name, - const char *const raw) +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) { - cJSON *raw_item = cJSON_CreateRaw(raw); - if(add_item_to_object(object, name, raw_item, &global_hooks, false)) { - return raw_item; - } + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } - cJSON_Delete(raw_item); - return NULL; + cJSON_Delete(raw_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddObjectToObject(cJSON * const object, - const char *const name) +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) { - cJSON *object_item = cJSON_CreateObject(); - if(add_item_to_object(object, name, object_item, &global_hooks, - false)) { - return object_item; - } + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } - cJSON_Delete(object_item); - return NULL; + cJSON_Delete(object_item); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_AddArrayToObject(cJSON * const object, - const char *const name) +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) { - cJSON *array = cJSON_CreateArray(); - if(add_item_to_object(object, name, array, &global_hooks, false)) { - return array; - } + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } - cJSON_Delete(array); - return NULL; + cJSON_Delete(array); + return NULL; } -CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON * parent, - cJSON * const item) +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) { - if((parent == NULL) || - (item == NULL)) - { - return NULL; - } + if ((parent == NULL) || (item == NULL)) + { + return NULL; + } - if(item->prev != NULL) { - /* not the first element */ - item->prev->next = item->next; - } - if(item->next != NULL) { - /* not the last element */ - item->next->prev = item->prev; - } + if (item->prev != NULL) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } - if(item == parent->child) { - /* first element */ - parent->child = item->next; - } - /* make sure the detached item doesn't point anywhere anymore */ - item->prev = NULL; - item->next = NULL; + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; - return item; + return item; } -CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON * array, int which) +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) { - if(which < 0) { - return NULL; - } + if (which < 0) + { + return NULL; + } - return cJSON_DetachItemViaPointer(array, - get_array_item(array, - (size_t) which)); + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); } -CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON * array, int which) +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) { - cJSON_Delete(cJSON_DetachItemFromArray(array, which)); + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); } -CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON * object, - const char *string) +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) { - cJSON *to_detach = cJSON_GetObjectItem(object, string); + cJSON *to_detach = cJSON_GetObjectItem(object, string); - return cJSON_DetachItemViaPointer(object, to_detach); + return cJSON_DetachItemViaPointer(object, to_detach); } -CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON * object, - const char *string) +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) { - cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); - return cJSON_DetachItemViaPointer(object, to_detach); + return cJSON_DetachItemViaPointer(object, to_detach); } -CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON * object, - const char *string) +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) { - cJSON_Delete(cJSON_DetachItemFromObject(object, string)); + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); } -CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON * object, - const char *string) +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) { - cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); } /* Replace array/object items with new ones. */ -CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON * array, int which, - cJSON * newitem) +CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) { - cJSON *after_inserted = NULL; + cJSON *after_inserted = NULL; - if(which < 0) { - return; - } + if (which < 0) + { + return; + } - after_inserted = get_array_item(array, (size_t) which); - if(after_inserted == NULL) { - add_item_to_array(array, newitem); - return; - } + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + add_item_to_array(array, newitem); + return; + } - newitem->next = after_inserted; - newitem->prev = after_inserted->prev; - after_inserted->prev = newitem; - if(after_inserted == array->child) { - array->child = newitem; - } else { - newitem->prev->next = newitem; - } + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } } -CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, - cJSON * const item, - cJSON * replacement) +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) { - if((parent == NULL) || - (replacement == NULL) || - (item == NULL)) - { - return false; - } + if ((parent == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } - if(replacement == item) { - return true; - } + if (replacement == item) + { + return true; + } - replacement->next = item->next; - replacement->prev = item->prev; + replacement->next = item->next; + replacement->prev = item->prev; - if(replacement->next != NULL) { - replacement->next->prev = replacement; - } - if(replacement->prev != NULL) { - replacement->prev->next = replacement; - } - if(parent->child == item) { - parent->child = replacement; - } + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (parent->child == item) + { + parent->child = replacement; + } - item->next = NULL; - item->prev = NULL; - cJSON_Delete(item); + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); - return true; + return true; } -CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON * array, int which, - cJSON * newitem) +CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) { - if(which < 0) { - return; - } + if (which < 0) + { + return; + } - cJSON_ReplaceItemViaPointer(array, get_array_item(array, - (size_t) which), - newitem); + cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); } -static cJSON_bool replace_item_in_object(cJSON *object, const char *string, - cJSON *replacement, - cJSON_bool case_sensitive) { - if((replacement == NULL) || - (string == NULL)) - { - return false; - } +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } - /* replace the name in the replacement */ - if(!(replacement->type & cJSON_StringIsConst) && - (replacement->string != NULL)) - { - cJSON_free(replacement->string); - } - replacement->string = (char *) cJSON_strdup( - (const unsigned char *) string, &global_hooks); - replacement->type &= ~cJSON_StringIsConst; + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + replacement->type &= ~cJSON_StringIsConst; - cJSON_ReplaceItemViaPointer(object, - get_object_item(object, string, - case_sensitive), - replacement); + cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); - return true; + return true; } -CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON * object, const char *string, - cJSON * newitem) +CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) { - replace_item_in_object(object, string, newitem, false); + replace_item_in_object(object, string, newitem, false); } -CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON * object, - const char *string, - cJSON * newitem) +CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) { - replace_item_in_object(object, string, newitem, true); + replace_item_in_object(object, string, newitem, true); } /* Create basic types: */ CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_NULL; - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_True; - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_False; - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool b) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = b ? cJSON_True : cJSON_False; - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = b ? cJSON_True : cJSON_False; + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_Number; - item->valuedouble = num; + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; - /* use saturation in case of overflow */ - if(num >= INT_MAX) { - item->valueint = INT_MAX; - } else if(num <= INT_MIN) { - item->valueint = INT_MIN; - } else { - item->valueint = (int) num; - } - } + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_String; - item->valuestring = (char *) cJSON_strdup( - (const unsigned char *) string, &global_hooks); - if(!item->valuestring) { - cJSON_Delete(item); - return NULL; - } - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item != NULL) { - item->type = cJSON_String | cJSON_IsReference; - item->valuestring = (char *) cast_away_const(string); - } + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } - return item; + return item; } -CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON * child) +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item != NULL) { - item->type = cJSON_Object | cJSON_IsReference; - item->child = (cJSON *) cast_away_const(child); - } + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } - return item; + return item; } -CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON * child) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item != NULL) { - item->type = cJSON_Array | cJSON_IsReference; - item->child = (cJSON *) cast_away_const(child); - } +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_Raw; - item->valuestring = (char *) cJSON_strdup( - (const unsigned char *) raw, &global_hooks); - if(!item->valuestring) { - cJSON_Delete(item); - return NULL; - } - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_Array; - } + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } - return item; + return item; } CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) { - cJSON *item = cJSON_New_Item(&global_hooks); - if(item) { - item->type = cJSON_Object; - } + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } - return item; + return item; } /* Create Arrays: */ CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) { - size_t i = 0; - cJSON *n = NULL; - cJSON *p = NULL; - cJSON *a = NULL; + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; - if((count < 0) || - (numbers == NULL)) - { - return NULL; - } + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } - a = cJSON_CreateArray(); - for(i = 0; a && - (i < (size_t) count); i++) - { - n = cJSON_CreateNumber(numbers[i]); - if(!n) { - cJSON_Delete(a); - return NULL; - } - if(!i) { - a->child = n; - } else { - suffix_object(p, n); - } - p = n; - } + a = cJSON_CreateArray(); + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } - return a; + return a; } CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) { - size_t i = 0; - cJSON *n = NULL; - cJSON *p = NULL; - cJSON *a = NULL; + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; - if((count < 0) || - (numbers == NULL)) - { - return NULL; - } + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } - a = cJSON_CreateArray(); + a = cJSON_CreateArray(); - for(i = 0; a && - (i < (size_t) count); i++) - { - n = cJSON_CreateNumber((double) numbers[i]); - if(!n) { - cJSON_Delete(a); - return NULL; - } - if(!i) { - a->child = n; - } else { - suffix_object(p, n); - } - p = n; - } + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } - return a; + return a; } CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) { - size_t i = 0; - cJSON *n = NULL; - cJSON *p = NULL; - cJSON *a = NULL; + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; - if((count < 0) || - (numbers == NULL)) - { - return NULL; - } + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } - a = cJSON_CreateArray(); + a = cJSON_CreateArray(); - for(i = 0; a && - (i < (size_t) count); i++) - { - n = cJSON_CreateNumber(numbers[i]); - if(!n) { - cJSON_Delete(a); - return NULL; - } - if(!i) { - a->child = n; - } else { - suffix_object(p, n); - } - p = n; - } + for(i = 0;a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } - return a; + return a; } CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count) { - size_t i = 0; - cJSON *n = NULL; - cJSON *p = NULL; - cJSON *a = NULL; + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; - if((count < 0) || - (strings == NULL)) - { - return NULL; - } + if ((count < 0) || (strings == NULL)) + { + return NULL; + } - a = cJSON_CreateArray(); + a = cJSON_CreateArray(); - for(i = 0; a && - (i < (size_t) count); i++) - { - n = cJSON_CreateString(strings[i]); - if(!n) { - cJSON_Delete(a); - return NULL; - } - if(!i) { - a->child = n; - } else { - suffix_object(p, n); - } - p = n; - } + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } - return a; + return a; } /* Duplication */ -CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON * item, cJSON_bool recurse) +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) { - cJSON *newitem = NULL; - cJSON *child = NULL; - cJSON *next = NULL; - cJSON *newchild = NULL; + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; - /* Bail on bad ptr */ - if(!item) { - goto fail; - } - /* Create new item */ - newitem = cJSON_New_Item(&global_hooks); - if(!newitem) { - goto fail; - } - /* Copy over all vars */ - newitem->type = item->type & (~cJSON_IsReference); - newitem->valueint = item->valueint; - newitem->valuedouble = item->valuedouble; - if(item->valuestring) { - newitem->valuestring = (char *) cJSON_strdup( - (unsigned char *) item->valuestring, &global_hooks); - if(!newitem->valuestring) { - goto fail; - } - } - if(item->string) { - newitem->string = - (item->type & - cJSON_StringIsConst) ? item->string : (char *) - cJSON_strdup(( - unsigned - char *) item->string, - &global_hooks); - if(!newitem->string) { - goto fail; - } - } - /* If non-recursive, then we're done! */ - if(!recurse) { - return newitem; - } - /* Walk the ->next chain for the child. */ - child = item->child; - while(child != NULL) { - newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ - if(!newchild) { - goto fail; - } - if(next != NULL) { - /* If newitem->child already set, then crosswire ->prev and ->next and move on */ - next->next = newchild; - newchild->prev = next; - next = newchild; - } else { - /* Set newitem->child and move to it */ - newitem->child = newchild; - next = newchild; - } - child = child->next; - } + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } - return newitem; + return newitem; fail: - if(newitem != NULL) { - cJSON_Delete(newitem); - } + if (newitem != NULL) + { + cJSON_Delete(newitem); + } - return NULL; + return NULL; } CJSON_PUBLIC(void) cJSON_Minify(char *json) { - unsigned char *into = (unsigned char *) json; + unsigned char *into = (unsigned char*)json; - if(json == NULL) { - return; - } + if (json == NULL) + { + return; + } - while(*json) { - if(*json == ' ') { - json++; - } else if(*json == '\t') { - /* Whitespace characters. */ - json++; - } else if(*json == '\r') { - json++; - } else if(*json == '\n') { - json++; - } else if((*json == '/') && - (json[1] == '/')) - { - /* double-slash comments, to end of line. */ - while(*json && - (*json != '\n')) - { - json++; - } - } else if((*json == '/') && - (json[1] == '*')) - { - /* multiline comments. */ - while(*json && - !((*json == '*') && - (json[1] == '/'))) - { - json++; - } - json += 2; - } else if(*json == '\"') { - /* string literals, which are \" sensitive. */ - *into++ = (unsigned char) *json++; - while(*json && - (*json != '\"')) - { - if(*json == '\\') { - *into++ = (unsigned char) *json++; - } - *into++ = (unsigned char) *json++; - } - *into++ = (unsigned char) *json++; - } else { - /* All other characters. */ - *into++ = (unsigned char) *json++; - } - } + while (*json) + { + if (*json == ' ') + { + json++; + } + else if (*json == '\t') + { + /* Whitespace characters. */ + json++; + } + else if (*json == '\r') + { + json++; + } + else if (*json=='\n') + { + json++; + } + else if ((*json == '/') && (json[1] == '/')) + { + /* double-slash comments, to end of line. */ + while (*json && (*json != '\n')) + { + json++; + } + } + else if ((*json == '/') && (json[1] == '*')) + { + /* multiline comments. */ + while (*json && !((*json == '*') && (json[1] == '/'))) + { + json++; + } + json += 2; + } + else if (*json == '\"') + { + /* string literals, which are \" sensitive. */ + *into++ = (unsigned char)*json++; + while (*json && (*json != '\"')) + { + if (*json == '\\') + { + *into++ = (unsigned char)*json++; + } + *into++ = (unsigned char)*json++; + } + *into++ = (unsigned char)*json++; + } + else + { + /* All other characters. */ + *into++ = (unsigned char)*json++; + } + } - /* and null-terminate. */ - *into = '\0'; + /* and null-terminate. */ + *into = '\0'; } CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_Invalid; + return (item->type & 0xFF) == cJSON_Invalid; } CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_False; + return (item->type & 0xFF) == cJSON_False; } CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xff) == cJSON_True; + return (item->type & 0xff) == cJSON_True; } CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & (cJSON_True | cJSON_False)) != 0; + return (item->type & (cJSON_True | cJSON_False)) != 0; } CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_NULL; + return (item->type & 0xFF) == cJSON_NULL; } CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_Number; + return (item->type & 0xFF) == cJSON_Number; } CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_String; + return (item->type & 0xFF) == cJSON_String; } CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_Array; + return (item->type & 0xFF) == cJSON_Array; } CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_Object; + return (item->type & 0xFF) == cJSON_Object; } CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) { - if(item == NULL) { - return false; - } + if (item == NULL) + { + return false; + } - return (item->type & 0xFF) == cJSON_Raw; + return (item->type & 0xFF) == cJSON_Raw; } -CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, - const cJSON * const b, - const cJSON_bool case_sensitive) +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) { - if((a == NULL) || - (b == NULL) || - ((a->type & 0xFF) != (b->type & 0xFF)) || - cJSON_IsInvalid(a)) - { - return false; - } + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a)) + { + return false; + } - /* check if type is valid */ - switch(a->type & 0xFF) { - case cJSON_False: - case cJSON_True: - case cJSON_NULL: - case cJSON_Number: - case cJSON_String: - case cJSON_Raw: - case cJSON_Array: - case cJSON_Object: - break; + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; - default: - return false; - } + default: + return false; + } - /* identical objects are equal */ - if(a == b) { - return true; - } + /* identical objects are equal */ + if (a == b) + { + return true; + } - switch(a->type & 0xFF) { - /* in these cases and equal type is enough */ - case cJSON_False: - case cJSON_True: - case cJSON_NULL: - return true; + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; - case cJSON_Number: - if(a->valuedouble == b->valuedouble) { - return true; - } - return false; + case cJSON_Number: + if (a->valuedouble == b->valuedouble) + { + return true; + } + return false; - case cJSON_String: - case cJSON_Raw: - if((a->valuestring == NULL) || - (b->valuestring == NULL)) - { - return false; - } - if(strcmp(a->valuestring, b->valuestring) == 0) { - return true; - } + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } - return false; + return false; - case cJSON_Array: - { - cJSON *a_element = a->child; - cJSON *b_element = b->child; + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; - for( ; (a_element != NULL) && - (b_element != NULL); ) - { - if(!cJSON_Compare(a_element, b_element, - case_sensitive)) { - return false; - } + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } - a_element = a_element->next; - b_element = b_element->next; - } + a_element = a_element->next; + b_element = b_element->next; + } - /* one of the arrays is longer than the other */ - if(a_element != b_element) { - return false; - } + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } - return true; - } + return true; + } - case cJSON_Object: - { - cJSON *a_element = NULL; - cJSON *b_element = NULL; - cJSON_ArrayForEach(a_element, a) - { - /* TODO This has O(n^2) runtime, which is horrible! */ - b_element = get_object_item(b, a_element->string, - case_sensitive); - if(b_element == NULL) { - return false; - } + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } - if(!cJSON_Compare(a_element, b_element, - case_sensitive)) { - return false; - } - } + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } - /* doing this twice, once on a and b to prevent true comparison if a subset of b - * TODO: Do this the proper way, this is just a fix for now */ - cJSON_ArrayForEach(b_element, b) - { - a_element = get_object_item(a, b_element->string, - case_sensitive); - if(a_element == NULL) { - return false; - } + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } - if(!cJSON_Compare(b_element, a_element, - case_sensitive)) { - return false; - } - } + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } - return true; - } + return true; + } - default: - return false; - } + default: + return false; + } } CJSON_PUBLIC(void *) cJSON_malloc(size_t size) { - return global_hooks.allocate(size); + return global_hooks.allocate(size); } CJSON_PUBLIC(void) cJSON_free(void *object) { - global_hooks.deallocate(object); + global_hooks.deallocate(object); } diff --git a/samples/client/petstore/c/external/cJSON.h b/samples/client/petstore/c/external/cJSON.h index f35925db6ff..6e0bde93204 100644 --- a/samples/client/petstore/c/external/cJSON.h +++ b/samples/client/petstore/c/external/cJSON.h @@ -1,24 +1,24 @@ /* - Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. - */ + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ #ifndef cJSON__h #define cJSON__h @@ -37,94 +37,87 @@ extern "C" /* cJSON Types: */ #define cJSON_Invalid (0) -#define cJSON_False (1 << 0) -#define cJSON_True (1 << 1) -#define cJSON_NULL (1 << 2) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) #define cJSON_Number (1 << 3) #define cJSON_String (1 << 4) -#define cJSON_Array (1 << 5) +#define cJSON_Array (1 << 5) #define cJSON_Object (1 << 6) -#define cJSON_Raw (1 << 7) /* raw json */ +#define cJSON_Raw (1 << 7) /* raw json */ #define cJSON_IsReference 256 #define cJSON_StringIsConst 512 /* The cJSON structure: */ -typedef struct cJSON { - /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ - struct cJSON *next; - struct cJSON *prev; - /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ - struct cJSON *child; +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; - /* The type of the item, as above. */ - int type; + /* The type of the item, as above. */ + int type; - /* The item's string, if type==cJSON_String and type == cJSON_Raw */ - char *valuestring; - /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ - int valueint; - /* The item's number, if type==cJSON_Number */ - double valuedouble; + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; - /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ - char *string; + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; } cJSON; -typedef struct cJSON_Hooks { - void *(*malloc_fn)(size_t sz); - void (*free_fn)(void *ptr); +typedef struct cJSON_Hooks +{ + void *(*malloc_fn)(size_t sz); + void (*free_fn)(void *ptr); } cJSON_Hooks; typedef int cJSON_bool; -#if !defined(__WINDOWS__) && \ - (defined(WIN32) || \ - defined(WIN64) || \ - defined(_MSC_VER) || \ - defined(_WIN32)) +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) #define __WINDOWS__ #endif #ifdef __WINDOWS__ /* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 2 define options: - CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols - CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) - CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol - For *nix builds that support visibility attribute, you can define similar behavior by +For *nix builds that support visibility attribute, you can define similar behavior by - setting default visibility to hidden by adding - -fvisibility=hidden (for gcc) - or - -xldscope=hidden (for sun cc) - to CFLAGS +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS - then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does - */ +*/ /* export symbols by default, this is necessary for copy pasting the C and header file */ -#if !defined(CJSON_HIDE_SYMBOLS) && \ - !defined(CJSON_IMPORT_SYMBOLS) && \ - !defined(CJSON_EXPORT_SYMBOLS) +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) #define CJSON_EXPORT_SYMBOLS #endif #if defined(CJSON_HIDE_SYMBOLS) -#define CJSON_PUBLIC(type) type __stdcall +#define CJSON_PUBLIC(type) type __stdcall #elif defined(CJSON_EXPORT_SYMBOLS) -#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall +#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall #elif defined(CJSON_IMPORT_SYMBOLS) -#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall +#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall #endif #else /* !WIN32 */ -#if (defined(__GNUC__) || \ - defined(__SUNPRO_CC) || \ - defined(__SUNPRO_C)) && \ - defined(CJSON_API_VISIBILITY) -#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type #else #define CJSON_PUBLIC(type) type #endif @@ -137,51 +130,43 @@ typedef int cJSON_bool; #endif /* returns the version of cJSON as a string */ -CJSON_PUBLIC(const char *) cJSON_Version(void); +CJSON_PUBLIC(const char*) cJSON_Version(void); /* Supply malloc, realloc and free functions to cJSON */ -CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks * hooks); +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); /* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ /* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); /* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ /* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ -CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, - const char **return_parse_end, - cJSON_bool require_null_terminated); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); /* Render a cJSON entity to text for transfer/storage. */ -CJSON_PUBLIC(char *) cJSON_Print(const cJSON * item); +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); /* Render a cJSON entity to text for transfer/storage without any formatting. */ -CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON * item); +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); /* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ -CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON * item, int prebuffer, - cJSON_bool fmt); +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); /* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ /* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ -CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON * item, char *buffer, - const int length, - const cJSON_bool format); +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); /* Delete a cJSON entity and all subentities. */ -CJSON_PUBLIC(void) cJSON_Delete(cJSON * c); +CJSON_PUBLIC(void) cJSON_Delete(cJSON *c); /* Returns the number of items in an array (or object). */ -CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON * array); +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); /* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ -CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON * array, int index); +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); /* Get item "string" from object. Case insensitive. */ -CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, - const char *const string); -CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive( - const cJSON * const object, const char *const string); -CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON * object, - const char *string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); /* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); /* Check if the item is a string and return its valuestring */ -CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON * item); +CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item); /* These functions check the type of an item */ CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); @@ -212,8 +197,8 @@ CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); /* Create an object/arrray that only references it's elements so * they will not be freed by cJSON_Delete */ -CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON * child); -CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON * child); +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); /* These utilities create an Array of count items. */ CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); @@ -222,109 +207,64 @@ CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count); /* Append item to the specified array/object. */ -CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON * array, cJSON * item); -CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON * object, const char *string, - cJSON * item); +CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); /* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before * writing to `item->string` */ -CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON * object, const char *string, - cJSON * item); +CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); /* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ -CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON * array, cJSON * item); -CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON * object, - const char *string, - cJSON * item); +CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); /* Remove/Detatch items from Arrays/Objects. */ -CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON * parent, - cJSON * const item); -CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON * array, int which); -CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON * array, int which); -CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON * object, - const char *string); -CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON * object, - const char *string); -CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON * object, - const char *string); -CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON * object, - const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); /* Update array items. */ -CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON * array, int which, - cJSON * newitem); /* Shifts pre-existing items to the right. */ -CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, - cJSON * const item, - cJSON * replacement); -CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON * array, int which, - cJSON * newitem); -CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON * object, const char *string, - cJSON * newitem); -CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON * object, - const char *string, - cJSON * newitem); +CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); /* Duplicate a cJSON item */ -CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON * item, cJSON_bool recurse); +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); /* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will - need to be released. With recurse!=0, it will duplicate any children connected to the item. - The item->next and ->prev pointers are always zero on return from Duplicate. */ +need to be released. With recurse!=0, it will duplicate any children connected to the item. +The item->next and ->prev pointers are always zero on return from Duplicate. */ /* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ -CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, - const cJSON * const b, - const cJSON_bool case_sensitive); +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); CJSON_PUBLIC(void) cJSON_Minify(char *json); /* Helper functions for creating and adding items to an object at the same time. * They return the added item or NULL on failure. */ -CJSON_PUBLIC(cJSON *) cJSON_AddNullToObject(cJSON * const object, - const char *const name); -CJSON_PUBLIC(cJSON *) cJSON_AddTrueToObject(cJSON * const object, - const char *const name); -CJSON_PUBLIC(cJSON *) cJSON_AddFalseToObject(cJSON * const object, - const char *const name); -CJSON_PUBLIC(cJSON *) cJSON_AddBoolToObject(cJSON * const object, - const char *const name, - const cJSON_bool boolean); -CJSON_PUBLIC(cJSON *) cJSON_AddNumberToObject(cJSON * const object, - const char *const name, - const double number); -CJSON_PUBLIC(cJSON *) cJSON_AddStringToObject(cJSON * const object, - const char *const name, - const char *const string); -CJSON_PUBLIC(cJSON *) cJSON_AddRawToObject(cJSON * const object, - const char *const name, - const char *const raw); -CJSON_PUBLIC(cJSON *) cJSON_AddObjectToObject(cJSON * const object, - const char *const name); -CJSON_PUBLIC(cJSON *) cJSON_AddArrayToObject(cJSON * const object, - const char *const name); +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); /* When assigning an integer value, it needs to be propagated to valuedouble too. */ -#define cJSON_SetIntValue(object, \ - number) ((object) ? (object)->valueint = \ - (object)->valuedouble = \ - (number) : (number)) +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) /* helper for the cJSON_SetNumberValue macro */ -CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON * object, double number); -#define cJSON_SetNumberValue(object, \ - number) ((object != \ - NULL) ? cJSON_SetNumberHelper(object, \ - ( \ - double) \ - number) : ( \ - number)) +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) /* Macro for iterating over an array or object */ -#define cJSON_ArrayForEach(element, array) for(element = \ - (array != \ - NULL) ? (array)->child : \ - NULL; \ - element != NULL; \ - element = element->next) +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) /* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ CJSON_PUBLIC(void *) cJSON_malloc(size_t size); diff --git a/samples/client/petstore/c/include/apiClient.h b/samples/client/petstore/c/include/apiClient.h index a000be9df12..aea3ec93738 100644 --- a/samples/client/petstore/c/include/apiClient.h +++ b/samples/client/petstore/c/include/apiClient.h @@ -10,27 +10,24 @@ #include "../include/keyValuePair.h" typedef struct apiClient_t { - char *basePath; - void *dataReceived; - long response_code; - list_t *apiKeys; - char *accessToken; + char *basePath; + void *dataReceived; + long response_code; + list_t *apiKeys; + char *accessToken; } apiClient_t; -typedef struct binary_t { - uint8_t *data; - unsigned int len; +typedef struct binary_t +{ + uint8_t* data; + unsigned int len; } binary_t; -apiClient_t *apiClient_create(); +apiClient_t* apiClient_create(); void apiClient_free(apiClient_t *apiClient); -void apiClient_invoke(apiClient_t *apiClient, char *operationParameter, - list_t *queryParameters, list_t *headerParameters, - list_t *formParameters, list_t *headerType, - list_t *contentType, char *bodyParameters, - char *requestType); +void apiClient_invoke(apiClient_t *apiClient,char* operationParameter, list_t *queryParameters, list_t *headerParameters, list_t *formParameters,list_t *headerType,list_t *contentType, char *bodyParameters, char *requestType); char *strReplace(char *orig, char *rep, char *with); diff --git a/samples/client/petstore/c/include/keyValuePair.h b/samples/client/petstore/c/include/keyValuePair.h index 710b46f30e3..90f92e71f66 100644 --- a/samples/client/petstore/c/include/keyValuePair.h +++ b/samples/client/petstore/c/include/keyValuePair.h @@ -1,11 +1,11 @@ #ifndef _keyValuePair_H_ #define _keyValuePair_H_ -#include +#include typedef struct keyValuePair_t { - char *key; - void *value; + char* key; + void* value; } keyValuePair_t; keyValuePair_t *keyValuePair_create(char *key, void *value); diff --git a/samples/client/petstore/c/include/list.h b/samples/client/petstore/c/include/list.h index ae35304139c..7d98d7f306b 100644 --- a/samples/client/petstore/c/include/list.h +++ b/samples/client/petstore/c/include/list.h @@ -9,40 +9,31 @@ typedef struct list_t list_t; typedef struct listEntry_t listEntry_t; struct listEntry_t { - listEntry_t *nextListEntry; - listEntry_t *prevListEntry; - void *data; + listEntry_t* nextListEntry; + listEntry_t* prevListEntry; + void* data; }; typedef struct list_t { - listEntry_t *firstEntry; - listEntry_t *lastEntry; + listEntry_t *firstEntry; + listEntry_t *lastEntry; - long count; + long count; } list_t; -#define list_ForEach(element, list) for(element = \ - (list != \ - NULL) ? (list)->firstEntry : \ - NULL; \ - element != NULL; \ - element = element->nextListEntry) +#define list_ForEach(element, list) for(element = (list != NULL) ? (list)->firstEntry : NULL; element != NULL; element = element->nextListEntry) -list_t *list_create(); -void list_free(list_t *listToFree); +list_t* list_create(); +void list_free(list_t* listToFree); -void list_addElement(list_t *list, void *dataToAddInList); -listEntry_t *list_getElementAt(list_t *list, long indexOfElement); -listEntry_t *list_getWithIndex(list_t *list, int index); -void list_removeElement(list_t *list, listEntry_t *elementToRemove); +void list_addElement(list_t* list, void* dataToAddInList); +listEntry_t* list_getElementAt(list_t *list, long indexOfElement); +listEntry_t* list_getWithIndex(list_t* list, int index); +void list_removeElement(list_t* list, listEntry_t* elementToRemove); -void list_iterateThroughListForward(list_t *list, void (*operationToPerform)( - listEntry_t *, - void *), void *additionalDataNeededForCallbackFunction); -void list_iterateThroughListBackward(list_t *list, void (*operationToPerform)( - listEntry_t *, - void *), void *additionalDataNeededForCallbackFunction); +void list_iterateThroughListForward(list_t* list, void (*operationToPerform)(listEntry_t*, void*), void *additionalDataNeededForCallbackFunction); +void list_iterateThroughListBackward(list_t* list, void (*operationToPerform)(listEntry_t*, void*), void *additionalDataNeededForCallbackFunction); -void listEntry_printAsInt(listEntry_t *listEntry, void *additionalData); +void listEntry_printAsInt(listEntry_t* listEntry, void *additionalData); void listEntry_free(listEntry_t *listEntry, void *additionalData); #endif // INCLUDE_LIST_H diff --git a/samples/client/petstore/c/model/api_response.c b/samples/client/petstore/c/model/api_response.c index 3201624063c..c7d728c2f89 100644 --- a/samples/client/petstore/c/model/api_response.c +++ b/samples/client/petstore/c/model/api_response.c @@ -5,104 +5,104 @@ -api_response_t *api_response_create(int code, char *type, char *message) { - api_response_t *api_response_local_var = malloc(sizeof(api_response_t)); - if(!api_response_local_var) { - return NULL; - } - api_response_local_var->code = code; - api_response_local_var->type = type; - api_response_local_var->message = message; +api_response_t *api_response_create( + int code, + char *type, + char *message + ) { + api_response_t *api_response_local_var = malloc(sizeof(api_response_t)); + if (!api_response_local_var) { + return NULL; + } + api_response_local_var->code = code; + api_response_local_var->type = type; + api_response_local_var->message = message; - return api_response_local_var; + return api_response_local_var; } void api_response_free(api_response_t *api_response) { - listEntry_t *listEntry; - free(api_response->type); - free(api_response->message); - free(api_response); + listEntry_t *listEntry; + free(api_response->type); + free(api_response->message); + free(api_response); } cJSON *api_response_convertToJSON(api_response_t *api_response) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - // api_response->code - if(api_response->code) { - if(cJSON_AddNumberToObject(item, "code", - api_response->code) == NULL) - { - goto fail; // Numeric - } - } + // api_response->code + if(api_response->code) { + if(cJSON_AddNumberToObject(item, "code", api_response->code) == NULL) { + goto fail; //Numeric + } + } - // api_response->type - if(api_response->type) { - if(cJSON_AddStringToObject(item, "type", - api_response->type) == NULL) - { - goto fail; // String - } - } + // api_response->type + if(api_response->type) { + if(cJSON_AddStringToObject(item, "type", api_response->type) == NULL) { + goto fail; //String + } + } - // api_response->message - if(api_response->message) { - if(cJSON_AddStringToObject(item, "message", - api_response->message) == NULL) - { - goto fail; // String - } - } + // api_response->message + if(api_response->message) { + if(cJSON_AddStringToObject(item, "message", api_response->message) == NULL) { + goto fail; //String + } + } - return item; + return item; fail: - if(item) { - cJSON_Delete(item); - } - return NULL; + if (item) { + cJSON_Delete(item); + } + return NULL; } -api_response_t *api_response_parseFromJSON(cJSON *api_responseJSON) { - api_response_t *api_response_local_var = NULL; +api_response_t *api_response_parseFromJSON(cJSON *api_responseJSON){ - // api_response->code - cJSON *code = - cJSON_GetObjectItemCaseSensitive(api_responseJSON, "code"); - if(code) { - if(!cJSON_IsNumber(code)) { - goto end; // Numeric - } - } + api_response_t *api_response_local_var = NULL; - // api_response->type - cJSON *type = - cJSON_GetObjectItemCaseSensitive(api_responseJSON, "type"); - if(type) { - if(!cJSON_IsString(type)) { - goto end; // String - } - } + // api_response->code + cJSON *code = cJSON_GetObjectItemCaseSensitive(api_responseJSON, "code"); + if (code) { + if(!cJSON_IsNumber(code)) + { + goto end; //Numeric + } + } - // api_response->message - cJSON *message = cJSON_GetObjectItemCaseSensitive(api_responseJSON, - "message"); - if(message) { - if(!cJSON_IsString(message)) { - goto end; // String - } - } + // api_response->type + cJSON *type = cJSON_GetObjectItemCaseSensitive(api_responseJSON, "type"); + if (type) { + if(!cJSON_IsString(type)) + { + goto end; //String + } + } + + // api_response->message + cJSON *message = cJSON_GetObjectItemCaseSensitive(api_responseJSON, "message"); + if (message) { + if(!cJSON_IsString(message)) + { + goto end; //String + } + } - api_response_local_var = api_response_create( - code ? code->valuedouble : 0, - type ? strdup(type->valuestring) : NULL, - message ? strdup(message->valuestring) : NULL - ); + api_response_local_var = api_response_create ( + code ? code->valuedouble : 0, + type ? strdup(type->valuestring) : NULL, + message ? strdup(message->valuestring) : NULL + ); - return api_response_local_var; + return api_response_local_var; end: - return NULL; + return NULL; + } diff --git a/samples/client/petstore/c/model/api_response.h b/samples/client/petstore/c/model/api_response.h index 73e92795eec..0b0866e3d5a 100644 --- a/samples/client/petstore/c/model/api_response.h +++ b/samples/client/petstore/c/model/api_response.h @@ -15,12 +15,17 @@ typedef struct api_response_t { - int code; // numeric - char *type; // string - char *message; // string + int code; //numeric + char *type; // string + char *message; // string + } api_response_t; -api_response_t *api_response_create(int code, char *type, char *message); +api_response_t *api_response_create( + int code, + char *type, + char *message +); void api_response_free(api_response_t *api_response); @@ -29,3 +34,4 @@ api_response_t *api_response_parseFromJSON(cJSON *api_responseJSON); cJSON *api_response_convertToJSON(api_response_t *api_response); #endif /* _api_response_H_ */ + diff --git a/samples/client/petstore/c/model/category.c b/samples/client/petstore/c/model/category.c index fe44d0afc96..518ccaee869 100644 --- a/samples/client/petstore/c/model/category.c +++ b/samples/client/petstore/c/model/category.c @@ -5,78 +5,83 @@ -category_t *category_create(long id, char *name) { - category_t *category_local_var = malloc(sizeof(category_t)); - if(!category_local_var) { - return NULL; - } - category_local_var->id = id; - category_local_var->name = name; +category_t *category_create( + long id, + char *name + ) { + category_t *category_local_var = malloc(sizeof(category_t)); + if (!category_local_var) { + return NULL; + } + category_local_var->id = id; + category_local_var->name = name; - return category_local_var; + return category_local_var; } void category_free(category_t *category) { - listEntry_t *listEntry; - free(category->name); - free(category); + listEntry_t *listEntry; + free(category->name); + free(category); } cJSON *category_convertToJSON(category_t *category) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - // category->id - if(category->id) { - if(cJSON_AddNumberToObject(item, "id", category->id) == NULL) { - goto fail; // Numeric - } - } + // category->id + if(category->id) { + if(cJSON_AddNumberToObject(item, "id", category->id) == NULL) { + goto fail; //Numeric + } + } - // category->name - if(category->name) { - if(cJSON_AddStringToObject(item, "name", - category->name) == NULL) - { - goto fail; // String - } - } + // category->name + if(category->name) { + if(cJSON_AddStringToObject(item, "name", category->name) == NULL) { + goto fail; //String + } + } - return item; + return item; fail: - if(item) { - cJSON_Delete(item); - } - return NULL; + if (item) { + cJSON_Delete(item); + } + return NULL; } -category_t *category_parseFromJSON(cJSON *categoryJSON) { - category_t *category_local_var = NULL; +category_t *category_parseFromJSON(cJSON *categoryJSON){ - // category->id - cJSON *id = cJSON_GetObjectItemCaseSensitive(categoryJSON, "id"); - if(id) { - if(!cJSON_IsNumber(id)) { - goto end; // Numeric - } - } + category_t *category_local_var = NULL; - // category->name - cJSON *name = cJSON_GetObjectItemCaseSensitive(categoryJSON, "name"); - if(name) { - if(!cJSON_IsString(name)) { - goto end; // String - } - } + // category->id + cJSON *id = cJSON_GetObjectItemCaseSensitive(categoryJSON, "id"); + if (id) { + if(!cJSON_IsNumber(id)) + { + goto end; //Numeric + } + } + + // category->name + cJSON *name = cJSON_GetObjectItemCaseSensitive(categoryJSON, "name"); + if (name) { + if(!cJSON_IsString(name)) + { + goto end; //String + } + } - category_local_var = category_create( - id ? id->valuedouble : 0, - name ? strdup(name->valuestring) : NULL - ); + category_local_var = category_create ( + id ? id->valuedouble : 0, + name ? strdup(name->valuestring) : NULL + ); - return category_local_var; + return category_local_var; end: - return NULL; + return NULL; + } diff --git a/samples/client/petstore/c/model/category.h b/samples/client/petstore/c/model/category.h index 27c9387e2f5..e63a04e096c 100644 --- a/samples/client/petstore/c/model/category.h +++ b/samples/client/petstore/c/model/category.h @@ -15,11 +15,15 @@ typedef struct category_t { - long id; // numeric - char *name; // string + long id; //numeric + char *name; // string + } category_t; -category_t *category_create(long id, char *name); +category_t *category_create( + long id, + char *name +); void category_free(category_t *category); @@ -28,3 +32,4 @@ category_t *category_parseFromJSON(cJSON *categoryJSON); cJSON *category_convertToJSON(category_t *category); #endif /* _category_H_ */ + diff --git a/samples/client/petstore/c/model/object.c b/samples/client/petstore/c/model/object.c index 410c31b6c6b..d106693842f 100644 --- a/samples/client/petstore/c/model/object.c +++ b/samples/client/petstore/c/model/object.c @@ -4,28 +4,28 @@ #include "object.h" object_t *object_create() { - object_t *object = malloc(sizeof(object_t)); + object_t *object = malloc(sizeof(object_t)); - return object; + return object; } void object_free(object_t *object) { - free(object); + free (object); } cJSON *object_convertToJSON(object_t *object) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - return item; + return item; fail: - cJSON_Delete(item); - return NULL; + cJSON_Delete(item); + return NULL; } -object_t *object_parseFromJSON(char *jsonString) { - object_t *object = NULL; +object_t *object_parseFromJSON(char *jsonString){ + object_t *object = NULL; - return object; + return object; end: - return NULL; + return NULL; } diff --git a/samples/client/petstore/c/model/object.h b/samples/client/petstore/c/model/object.h index 1dad2093fed..6b1a77fc508 100644 --- a/samples/client/petstore/c/model/object.h +++ b/samples/client/petstore/c/model/object.h @@ -12,7 +12,7 @@ typedef struct object_t { - void *temporary; + void *temporary; } object_t; object_t *object_create(); diff --git a/samples/client/petstore/c/model/order.c b/samples/client/petstore/c/model/order.c index de4c3db1959..5aafbecba35 100644 --- a/samples/client/petstore/c/model/order.c +++ b/samples/client/petstore/c/model/order.c @@ -4,182 +4,184 @@ #include "order.h" -char *statusorder_ToString(status_e status) { - char *statusArray[] = { "placed", "approved", "delivered" }; - return statusArray[status]; -} + char* statusorder_ToString(status_e status){ + char *statusArray[] = { "placed","approved","delivered" }; + return statusArray[status]; + } -status_e statusorder_FromString(char *status) { - int stringToReturn = 0; - char *statusArray[] = { "placed", "approved", "delivered" }; - size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]); - while(stringToReturn < sizeofArray) { - if(strcmp(status, statusArray[stringToReturn]) == 0) { - return stringToReturn; - } - stringToReturn++; - } - return 0; -} + status_e statusorder_FromString(char* status){ + int stringToReturn = 0; + char *statusArray[] = { "placed","approved","delivered" }; + size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]); + while(stringToReturn < sizeofArray) { + if(strcmp(status, statusArray[stringToReturn]) == 0) { + return stringToReturn; + } + stringToReturn++; + } + return 0; + } -order_t *order_create(long id, long petId, int quantity, char *shipDate, - status_e status, int complete) { - order_t *order_local_var = malloc(sizeof(order_t)); - if(!order_local_var) { - return NULL; - } - order_local_var->id = id; - order_local_var->petId = petId; - order_local_var->quantity = quantity; - order_local_var->shipDate = shipDate; - order_local_var->status = status; - order_local_var->complete = complete; +order_t *order_create( + long id, + long petId, + int quantity, + char *shipDate, + status_e status, + int complete + ) { + order_t *order_local_var = malloc(sizeof(order_t)); + if (!order_local_var) { + return NULL; + } + order_local_var->id = id; + order_local_var->petId = petId; + order_local_var->quantity = quantity; + order_local_var->shipDate = shipDate; + order_local_var->status = status; + order_local_var->complete = complete; - return order_local_var; + return order_local_var; } void order_free(order_t *order) { - listEntry_t *listEntry; - free(order->shipDate); - free(order); + listEntry_t *listEntry; + free(order->shipDate); + free(order); } cJSON *order_convertToJSON(order_t *order) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - // order->id - if(order->id) { - if(cJSON_AddNumberToObject(item, "id", order->id) == NULL) { - goto fail; // Numeric - } - } + // order->id + if(order->id) { + if(cJSON_AddNumberToObject(item, "id", order->id) == NULL) { + goto fail; //Numeric + } + } - // order->petId - if(order->petId) { - if(cJSON_AddNumberToObject(item, "petId", - order->petId) == NULL) - { - goto fail; // Numeric - } - } + // order->petId + if(order->petId) { + if(cJSON_AddNumberToObject(item, "petId", order->petId) == NULL) { + goto fail; //Numeric + } + } - // order->quantity - if(order->quantity) { - if(cJSON_AddNumberToObject(item, "quantity", - order->quantity) == NULL) - { - goto fail; // Numeric - } - } + // order->quantity + if(order->quantity) { + if(cJSON_AddNumberToObject(item, "quantity", order->quantity) == NULL) { + goto fail; //Numeric + } + } - // order->shipDate - if(order->shipDate) { - if(cJSON_AddStringToObject(item, "shipDate", - order->shipDate) == NULL) - { - goto fail; // Date-Time - } - } + // order->shipDate + if(order->shipDate) { + if(cJSON_AddStringToObject(item, "shipDate", order->shipDate) == NULL) { + goto fail; //Date-Time + } + } - // order->status - - if(cJSON_AddStringToObject(item, "status", - statusorder_ToString(order->status)) == NULL) - { - goto fail; // Enum - } + // order->status + + if(cJSON_AddStringToObject(item, "status", statusorder_ToString(order->status)) == NULL) + { + goto fail; //Enum + } + + // order->complete + if(order->complete) { + if(cJSON_AddBoolToObject(item, "complete", order->complete) == NULL) { + goto fail; //Bool + } + } - // order->complete - if(order->complete) { - if(cJSON_AddBoolToObject(item, "complete", - order->complete) == NULL) - { - goto fail; // Bool - } - } - - return item; + return item; fail: - if(item) { - cJSON_Delete(item); - } - return NULL; + if (item) { + cJSON_Delete(item); + } + return NULL; } -order_t *order_parseFromJSON(cJSON *orderJSON) { - order_t *order_local_var = NULL; +order_t *order_parseFromJSON(cJSON *orderJSON){ - // order->id - cJSON *id = cJSON_GetObjectItemCaseSensitive(orderJSON, "id"); - if(id) { - if(!cJSON_IsNumber(id)) { - goto end; // Numeric - } - } + order_t *order_local_var = NULL; - // order->petId - cJSON *petId = cJSON_GetObjectItemCaseSensitive(orderJSON, "petId"); - if(petId) { - if(!cJSON_IsNumber(petId)) { - goto end; // Numeric - } - } + // order->id + cJSON *id = cJSON_GetObjectItemCaseSensitive(orderJSON, "id"); + if (id) { + if(!cJSON_IsNumber(id)) + { + goto end; //Numeric + } + } - // order->quantity - cJSON *quantity = - cJSON_GetObjectItemCaseSensitive(orderJSON, "quantity"); - if(quantity) { - if(!cJSON_IsNumber(quantity)) { - goto end; // Numeric - } - } + // order->petId + cJSON *petId = cJSON_GetObjectItemCaseSensitive(orderJSON, "petId"); + if (petId) { + if(!cJSON_IsNumber(petId)) + { + goto end; //Numeric + } + } - // order->shipDate - cJSON *shipDate = - cJSON_GetObjectItemCaseSensitive(orderJSON, "shipDate"); - if(shipDate) { - if(!cJSON_IsString(shipDate)) { - goto end; // DateTime - } - } + // order->quantity + cJSON *quantity = cJSON_GetObjectItemCaseSensitive(orderJSON, "quantity"); + if (quantity) { + if(!cJSON_IsNumber(quantity)) + { + goto end; //Numeric + } + } - // order->status - cJSON *status = cJSON_GetObjectItemCaseSensitive(orderJSON, "status"); - status_e statusVariable; - if(status) { - if(!cJSON_IsString(status)) { - goto end; // Enum - } - statusVariable = statusorder_FromString(status->valuestring); - } + // order->shipDate + cJSON *shipDate = cJSON_GetObjectItemCaseSensitive(orderJSON, "shipDate"); + if (shipDate) { + if(!cJSON_IsString(shipDate)) + { + goto end; //DateTime + } + } - // order->complete - cJSON *complete = - cJSON_GetObjectItemCaseSensitive(orderJSON, "complete"); - if(complete) { - if(!cJSON_IsBool(complete)) { - goto end; // Bool - } - } + // order->status + cJSON *status = cJSON_GetObjectItemCaseSensitive(orderJSON, "status"); + status_e statusVariable; + if (status) { + if(!cJSON_IsString(status)) + { + goto end; //Enum + } + statusVariable = statusorder_FromString(status->valuestring); + } + + // order->complete + cJSON *complete = cJSON_GetObjectItemCaseSensitive(orderJSON, "complete"); + if (complete) { + if(!cJSON_IsBool(complete)) + { + goto end; //Bool + } + } - order_local_var = order_create( - id ? id->valuedouble : 0, - petId ? petId->valuedouble : 0, - quantity ? quantity->valuedouble : 0, - shipDate ? strdup(shipDate->valuestring) : NULL, - status ? statusVariable : -1, - complete ? complete->valueint : 0 - ); + order_local_var = order_create ( + id ? id->valuedouble : 0, + petId ? petId->valuedouble : 0, + quantity ? quantity->valuedouble : 0, + shipDate ? strdup(shipDate->valuestring) : NULL, + status ? statusVariable : -1, + complete ? complete->valueint : 0 + ); - return order_local_var; + return order_local_var; end: - return NULL; + return NULL; + } diff --git a/samples/client/petstore/c/model/order.h b/samples/client/petstore/c/model/order.h index ef99a5da98c..e7f814e1fa1 100644 --- a/samples/client/petstore/c/model/order.h +++ b/samples/client/petstore/c/model/order.h @@ -12,24 +12,31 @@ #include "../include/list.h" #include "../include/keyValuePair.h" -typedef enum { placed, approved, delivered } status_e; + typedef enum { placed, approved, delivered } status_e; -char *status_ToString(status_e status); + char* status_ToString(status_e status); -status_e status_FromString(char *status); + status_e status_FromString(char* status); typedef struct order_t { - long id; // numeric - long petId; // numeric - int quantity; // numeric - char *shipDate; // date time - status_e status; // enum - int complete; // boolean + long id; //numeric + long petId; //numeric + int quantity; //numeric + char *shipDate; //date time + status_e status; //enum + int complete; //boolean + } order_t; -order_t *order_create(long id, long petId, int quantity, char *shipDate, - status_e status, int complete); +order_t *order_create( + long id, + long petId, + int quantity, + char *shipDate, + status_e status, + int complete +); void order_free(order_t *order); @@ -38,3 +45,4 @@ order_t *order_parseFromJSON(cJSON *orderJSON); cJSON *order_convertToJSON(order_t *order); #endif /* _order_H_ */ + diff --git a/samples/client/petstore/c/model/pet.c b/samples/client/petstore/c/model/pet.c index 73b6c4e28f4..b25b785cc6b 100644 --- a/samples/client/petstore/c/model/pet.c +++ b/samples/client/petstore/c/model/pet.c @@ -4,247 +4,251 @@ #include "pet.h" -char *statuspet_ToString(status_e status) { - char *statusArray[] = { "available", "pending", "sold" }; - return statusArray[status]; -} + char* statuspet_ToString(status_e status){ + char *statusArray[] = { "available","pending","sold" }; + return statusArray[status]; + } -status_e statuspet_FromString(char *status) { - int stringToReturn = 0; - char *statusArray[] = { "available", "pending", "sold" }; - size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]); - while(stringToReturn < sizeofArray) { - if(strcmp(status, statusArray[stringToReturn]) == 0) { - return stringToReturn; - } - stringToReturn++; - } - return 0; -} + status_e statuspet_FromString(char* status){ + int stringToReturn = 0; + char *statusArray[] = { "available","pending","sold" }; + size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]); + while(stringToReturn < sizeofArray) { + if(strcmp(status, statusArray[stringToReturn]) == 0) { + return stringToReturn; + } + stringToReturn++; + } + return 0; + } -pet_t *pet_create(long id, category_t *category, char *name, list_t *photoUrls, - list_t *tags, status_e status) { - pet_t *pet_local_var = malloc(sizeof(pet_t)); - if(!pet_local_var) { - return NULL; - } - pet_local_var->id = id; - pet_local_var->category = category; - pet_local_var->name = name; - pet_local_var->photoUrls = photoUrls; - pet_local_var->tags = tags; - pet_local_var->status = status; +pet_t *pet_create( + long id, + category_t *category, + char *name, + list_t *photoUrls, + list_t *tags, + status_e status + ) { + pet_t *pet_local_var = malloc(sizeof(pet_t)); + if (!pet_local_var) { + return NULL; + } + pet_local_var->id = id; + pet_local_var->category = category; + pet_local_var->name = name; + pet_local_var->photoUrls = photoUrls; + pet_local_var->tags = tags; + pet_local_var->status = status; - return pet_local_var; + return pet_local_var; } void pet_free(pet_t *pet) { - listEntry_t *listEntry; - category_free(pet->category); - free(pet->name); - list_ForEach(listEntry, pet->photoUrls) { - free(listEntry->data); - } - list_free(pet->photoUrls); - list_ForEach(listEntry, pet->tags) { - tag_free(listEntry->data); - } - list_free(pet->tags); - free(pet); + listEntry_t *listEntry; + category_free(pet->category); + free(pet->name); + list_ForEach(listEntry, pet->photoUrls) { + free(listEntry->data); + } + list_free(pet->photoUrls); + list_ForEach(listEntry, pet->tags) { + tag_free(listEntry->data); + } + list_free(pet->tags); + free(pet); } cJSON *pet_convertToJSON(pet_t *pet) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - // pet->id - if(pet->id) { - if(cJSON_AddNumberToObject(item, "id", pet->id) == NULL) { - goto fail; // Numeric - } - } + // pet->id + if(pet->id) { + if(cJSON_AddNumberToObject(item, "id", pet->id) == NULL) { + goto fail; //Numeric + } + } - // pet->category - if(pet->category) { - cJSON *category_local_JSON = category_convertToJSON( - pet->category); - if(category_local_JSON == NULL) { - goto fail; // model - } - cJSON_AddItemToObject(item, "category", category_local_JSON); - if(item->child == NULL) { - goto fail; - } - } + // pet->category + if(pet->category) { + cJSON *category_local_JSON = category_convertToJSON(pet->category); + if(category_local_JSON == NULL) { + goto fail; //model + } + cJSON_AddItemToObject(item, "category", category_local_JSON); + if(item->child == NULL) { + goto fail; + } + } - // pet->name - if(!pet->name) { - goto fail; - } - - if(cJSON_AddStringToObject(item, "name", pet->name) == NULL) { - goto fail; // String - } + // pet->name + if (!pet->name) { + goto fail; + } + + if(cJSON_AddStringToObject(item, "name", pet->name) == NULL) { + goto fail; //String + } - // pet->photoUrls - if(!pet->photoUrls) { - goto fail; - } + // pet->photoUrls + if (!pet->photoUrls) { + goto fail; + } + + cJSON *photo_urls = cJSON_AddArrayToObject(item, "photoUrls"); + if(photo_urls == NULL) { + goto fail; //primitive container + } - cJSON *photo_urls = cJSON_AddArrayToObject(item, "photoUrls"); - if(photo_urls == NULL) { - goto fail; // primitive container - } - - listEntry_t *photo_urlsListEntry; - list_ForEach(photo_urlsListEntry, pet->photoUrls) { - if(cJSON_AddStringToObject(photo_urls, "", - (char *) photo_urlsListEntry->data) - == NULL) - { - goto fail; - } - } + listEntry_t *photo_urlsListEntry; + list_ForEach(photo_urlsListEntry, pet->photoUrls) { + if(cJSON_AddStringToObject(photo_urls, "", (char*)photo_urlsListEntry->data) == NULL) + { + goto fail; + } + } - // pet->tags - if(pet->tags) { - cJSON *tags = cJSON_AddArrayToObject(item, "tags"); - if(tags == NULL) { - goto fail; // nonprimitive container - } + // pet->tags + if(pet->tags) { + cJSON *tags = cJSON_AddArrayToObject(item, "tags"); + if(tags == NULL) { + goto fail; //nonprimitive container + } - listEntry_t *tagsListEntry; - if(pet->tags) { - list_ForEach(tagsListEntry, pet->tags) { - cJSON *itemLocal = tag_convertToJSON( - tagsListEntry->data); - if(itemLocal == NULL) { - goto fail; - } - cJSON_AddItemToArray(tags, itemLocal); - } - } - } + listEntry_t *tagsListEntry; + if (pet->tags) { + list_ForEach(tagsListEntry, pet->tags) { + cJSON *itemLocal = tag_convertToJSON(tagsListEntry->data); + if(itemLocal == NULL) { + goto fail; + } + cJSON_AddItemToArray(tags, itemLocal); + } + } + } - // pet->status + // pet->status + + if(cJSON_AddStringToObject(item, "status", statuspet_ToString(pet->status)) == NULL) + { + goto fail; //Enum + } + - if(cJSON_AddStringToObject(item, "status", - statuspet_ToString(pet->status)) == NULL) - { - goto fail; // Enum - } - - - return item; + return item; fail: - if(item) { - cJSON_Delete(item); - } - return NULL; + if (item) { + cJSON_Delete(item); + } + return NULL; } -pet_t *pet_parseFromJSON(cJSON *petJSON) { - pet_t *pet_local_var = NULL; +pet_t *pet_parseFromJSON(cJSON *petJSON){ - // pet->id - cJSON *id = cJSON_GetObjectItemCaseSensitive(petJSON, "id"); - if(id) { - if(!cJSON_IsNumber(id)) { - goto end; // Numeric - } - } + pet_t *pet_local_var = NULL; - // pet->category - cJSON *category = cJSON_GetObjectItemCaseSensitive(petJSON, "category"); - category_t *category_local_nonprim = NULL; - if(category) { - category_local_nonprim = category_parseFromJSON(category); // nonprimitive - } + // pet->id + cJSON *id = cJSON_GetObjectItemCaseSensitive(petJSON, "id"); + if (id) { + if(!cJSON_IsNumber(id)) + { + goto end; //Numeric + } + } - // pet->name - cJSON *name = cJSON_GetObjectItemCaseSensitive(petJSON, "name"); - if(!name) { - goto end; - } + // pet->category + cJSON *category = cJSON_GetObjectItemCaseSensitive(petJSON, "category"); + category_t *category_local_nonprim = NULL; + if (category) { + category_local_nonprim = category_parseFromJSON(category); //nonprimitive + } + + // pet->name + cJSON *name = cJSON_GetObjectItemCaseSensitive(petJSON, "name"); + if (!name) { + goto end; + } + + + if(!cJSON_IsString(name)) + { + goto end; //String + } + + // pet->photoUrls + cJSON *photoUrls = cJSON_GetObjectItemCaseSensitive(petJSON, "photoUrls"); + if (!photoUrls) { + goto end; + } + + list_t *photo_urlsList; + + cJSON *photo_urls_local; + if(!cJSON_IsArray(photoUrls)) { + goto end;//primitive container + } + photo_urlsList = list_create(); + + cJSON_ArrayForEach(photo_urls_local, photoUrls) + { + if(!cJSON_IsString(photo_urls_local)) + { + goto end; + } + list_addElement(photo_urlsList , strdup(photo_urls_local->valuestring)); + } + + // pet->tags + cJSON *tags = cJSON_GetObjectItemCaseSensitive(petJSON, "tags"); + list_t *tagsList; + if (tags) { + cJSON *tags_local_nonprimitive; + if(!cJSON_IsArray(tags)){ + goto end; //nonprimitive container + } + + tagsList = list_create(); + + cJSON_ArrayForEach(tags_local_nonprimitive,tags ) + { + if(!cJSON_IsObject(tags_local_nonprimitive)){ + goto end; + } + tag_t *tagsItem = tag_parseFromJSON(tags_local_nonprimitive); + + list_addElement(tagsList, tagsItem); + } + } + + // pet->status + cJSON *status = cJSON_GetObjectItemCaseSensitive(petJSON, "status"); + status_e statusVariable; + if (status) { + if(!cJSON_IsString(status)) + { + goto end; //Enum + } + statusVariable = statuspet_FromString(status->valuestring); + } - if(!cJSON_IsString(name)) { - goto end; // String - } + pet_local_var = pet_create ( + id ? id->valuedouble : 0, + category ? category_local_nonprim : NULL, + strdup(name->valuestring), + photo_urlsList, + tags ? tagsList : NULL, + status ? statusVariable : -1 + ); - // pet->photoUrls - cJSON *photoUrls = - cJSON_GetObjectItemCaseSensitive(petJSON, "photoUrls"); - if(!photoUrls) { - goto end; - } - - list_t *photo_urlsList; - - cJSON *photo_urls_local; - if(!cJSON_IsArray(photoUrls)) { - goto end; // primitive container - } - photo_urlsList = list_create(); - - cJSON_ArrayForEach(photo_urls_local, photoUrls) - { - if(!cJSON_IsString(photo_urls_local)) { - goto end; - } - list_addElement(photo_urlsList, - strdup(photo_urls_local->valuestring)); - } - - // pet->tags - cJSON *tags = cJSON_GetObjectItemCaseSensitive(petJSON, "tags"); - list_t *tagsList; - if(tags) { - cJSON *tags_local_nonprimitive; - if(!cJSON_IsArray(tags)) { - goto end; // nonprimitive container - } - - tagsList = list_create(); - - cJSON_ArrayForEach(tags_local_nonprimitive, tags) - { - if(!cJSON_IsObject(tags_local_nonprimitive)) { - goto end; - } - tag_t *tagsItem = tag_parseFromJSON( - tags_local_nonprimitive); - - list_addElement(tagsList, tagsItem); - } - } - - // pet->status - cJSON *status = cJSON_GetObjectItemCaseSensitive(petJSON, "status"); - status_e statusVariable; - if(status) { - if(!cJSON_IsString(status)) { - goto end; // Enum - } - statusVariable = statuspet_FromString(status->valuestring); - } - - - pet_local_var = pet_create( - id ? id->valuedouble : 0, - category ? category_local_nonprim : NULL, - strdup(name->valuestring), - photo_urlsList, - tags ? tagsList : NULL, - status ? statusVariable : -1 - ); - - return pet_local_var; + return pet_local_var; end: - return NULL; + return NULL; + } diff --git a/samples/client/petstore/c/model/pet.h b/samples/client/petstore/c/model/pet.h index da5b3df5e7a..a29280648d8 100644 --- a/samples/client/petstore/c/model/pet.h +++ b/samples/client/petstore/c/model/pet.h @@ -14,24 +14,31 @@ #include "category.h" #include "tag.h" -typedef enum { available, pending, sold } status_e; + typedef enum { available, pending, sold } status_e; -char *status_ToString(status_e status); + char* status_ToString(status_e status); -status_e status_FromString(char *status); + status_e status_FromString(char* status); typedef struct pet_t { - long id; // numeric - category_t *category; // model - char *name; // string - list_t *photoUrls; // primitive container - list_t *tags; // nonprimitive container - status_e status; // enum + long id; //numeric + category_t *category; //model + char *name; // string + list_t *photoUrls; //primitive container + list_t *tags; //nonprimitive container + status_e status; //enum + } pet_t; -pet_t *pet_create(long id, category_t *category, char *name, list_t *photoUrls, - list_t *tags, status_e status); +pet_t *pet_create( + long id, + category_t *category, + char *name, + list_t *photoUrls, + list_t *tags, + status_e status +); void pet_free(pet_t *pet); @@ -40,3 +47,4 @@ pet_t *pet_parseFromJSON(cJSON *petJSON); cJSON *pet_convertToJSON(pet_t *pet); #endif /* _pet_H_ */ + diff --git a/samples/client/petstore/c/model/tag.c b/samples/client/petstore/c/model/tag.c index ca6c9e9184e..63450378b9f 100644 --- a/samples/client/petstore/c/model/tag.c +++ b/samples/client/petstore/c/model/tag.c @@ -5,76 +5,83 @@ -tag_t *tag_create(long id, char *name) { - tag_t *tag_local_var = malloc(sizeof(tag_t)); - if(!tag_local_var) { - return NULL; - } - tag_local_var->id = id; - tag_local_var->name = name; +tag_t *tag_create( + long id, + char *name + ) { + tag_t *tag_local_var = malloc(sizeof(tag_t)); + if (!tag_local_var) { + return NULL; + } + tag_local_var->id = id; + tag_local_var->name = name; - return tag_local_var; + return tag_local_var; } void tag_free(tag_t *tag) { - listEntry_t *listEntry; - free(tag->name); - free(tag); + listEntry_t *listEntry; + free(tag->name); + free(tag); } cJSON *tag_convertToJSON(tag_t *tag) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - // tag->id - if(tag->id) { - if(cJSON_AddNumberToObject(item, "id", tag->id) == NULL) { - goto fail; // Numeric - } - } + // tag->id + if(tag->id) { + if(cJSON_AddNumberToObject(item, "id", tag->id) == NULL) { + goto fail; //Numeric + } + } - // tag->name - if(tag->name) { - if(cJSON_AddStringToObject(item, "name", tag->name) == NULL) { - goto fail; // String - } - } + // tag->name + if(tag->name) { + if(cJSON_AddStringToObject(item, "name", tag->name) == NULL) { + goto fail; //String + } + } - return item; + return item; fail: - if(item) { - cJSON_Delete(item); - } - return NULL; + if (item) { + cJSON_Delete(item); + } + return NULL; } -tag_t *tag_parseFromJSON(cJSON *tagJSON) { - tag_t *tag_local_var = NULL; +tag_t *tag_parseFromJSON(cJSON *tagJSON){ - // tag->id - cJSON *id = cJSON_GetObjectItemCaseSensitive(tagJSON, "id"); - if(id) { - if(!cJSON_IsNumber(id)) { - goto end; // Numeric - } - } + tag_t *tag_local_var = NULL; - // tag->name - cJSON *name = cJSON_GetObjectItemCaseSensitive(tagJSON, "name"); - if(name) { - if(!cJSON_IsString(name)) { - goto end; // String - } - } + // tag->id + cJSON *id = cJSON_GetObjectItemCaseSensitive(tagJSON, "id"); + if (id) { + if(!cJSON_IsNumber(id)) + { + goto end; //Numeric + } + } + + // tag->name + cJSON *name = cJSON_GetObjectItemCaseSensitive(tagJSON, "name"); + if (name) { + if(!cJSON_IsString(name)) + { + goto end; //String + } + } - tag_local_var = tag_create( - id ? id->valuedouble : 0, - name ? strdup(name->valuestring) : NULL - ); + tag_local_var = tag_create ( + id ? id->valuedouble : 0, + name ? strdup(name->valuestring) : NULL + ); - return tag_local_var; + return tag_local_var; end: - return NULL; + return NULL; + } diff --git a/samples/client/petstore/c/model/tag.h b/samples/client/petstore/c/model/tag.h index 235f7b2ea45..26f70686658 100644 --- a/samples/client/petstore/c/model/tag.h +++ b/samples/client/petstore/c/model/tag.h @@ -15,11 +15,15 @@ typedef struct tag_t { - long id; // numeric - char *name; // string + long id; //numeric + char *name; // string + } tag_t; -tag_t *tag_create(long id, char *name); +tag_t *tag_create( + long id, + char *name +); void tag_free(tag_t *tag); @@ -28,3 +32,4 @@ tag_t *tag_parseFromJSON(cJSON *tagJSON); cJSON *tag_convertToJSON(tag_t *tag); #endif /* _tag_H_ */ + diff --git a/samples/client/petstore/c/model/user.c b/samples/client/petstore/c/model/user.c index a12f59bb3d4..b480c68203f 100644 --- a/samples/client/petstore/c/model/user.c +++ b/samples/client/petstore/c/model/user.c @@ -5,209 +5,208 @@ -user_t *user_create(long id, char *username, char *firstName, char *lastName, - char *email, char *password, char *phone, int userStatus) { - user_t *user_local_var = malloc(sizeof(user_t)); - if(!user_local_var) { - return NULL; - } - user_local_var->id = id; - user_local_var->username = username; - user_local_var->firstName = firstName; - user_local_var->lastName = lastName; - user_local_var->email = email; - user_local_var->password = password; - user_local_var->phone = phone; - user_local_var->userStatus = userStatus; +user_t *user_create( + long id, + char *username, + char *firstName, + char *lastName, + char *email, + char *password, + char *phone, + int userStatus + ) { + user_t *user_local_var = malloc(sizeof(user_t)); + if (!user_local_var) { + return NULL; + } + user_local_var->id = id; + user_local_var->username = username; + user_local_var->firstName = firstName; + user_local_var->lastName = lastName; + user_local_var->email = email; + user_local_var->password = password; + user_local_var->phone = phone; + user_local_var->userStatus = userStatus; - return user_local_var; + return user_local_var; } void user_free(user_t *user) { - listEntry_t *listEntry; - free(user->username); - free(user->firstName); - free(user->lastName); - free(user->email); - free(user->password); - free(user->phone); - free(user); + listEntry_t *listEntry; + free(user->username); + free(user->firstName); + free(user->lastName); + free(user->email); + free(user->password); + free(user->phone); + free(user); } cJSON *user_convertToJSON(user_t *user) { - cJSON *item = cJSON_CreateObject(); + cJSON *item = cJSON_CreateObject(); - // user->id - if(user->id) { - if(cJSON_AddNumberToObject(item, "id", user->id) == NULL) { - goto fail; // Numeric - } - } + // user->id + if(user->id) { + if(cJSON_AddNumberToObject(item, "id", user->id) == NULL) { + goto fail; //Numeric + } + } - // user->username - if(user->username) { - if(cJSON_AddStringToObject(item, "username", - user->username) == NULL) - { - goto fail; // String - } - } + // user->username + if(user->username) { + if(cJSON_AddStringToObject(item, "username", user->username) == NULL) { + goto fail; //String + } + } - // user->firstName - if(user->firstName) { - if(cJSON_AddStringToObject(item, "firstName", - user->firstName) == NULL) - { - goto fail; // String - } - } + // user->firstName + if(user->firstName) { + if(cJSON_AddStringToObject(item, "firstName", user->firstName) == NULL) { + goto fail; //String + } + } - // user->lastName - if(user->lastName) { - if(cJSON_AddStringToObject(item, "lastName", - user->lastName) == NULL) - { - goto fail; // String - } - } + // user->lastName + if(user->lastName) { + if(cJSON_AddStringToObject(item, "lastName", user->lastName) == NULL) { + goto fail; //String + } + } - // user->email - if(user->email) { - if(cJSON_AddStringToObject(item, "email", - user->email) == NULL) - { - goto fail; // String - } - } + // user->email + if(user->email) { + if(cJSON_AddStringToObject(item, "email", user->email) == NULL) { + goto fail; //String + } + } - // user->password - if(user->password) { - if(cJSON_AddStringToObject(item, "password", - user->password) == NULL) - { - goto fail; // String - } - } + // user->password + if(user->password) { + if(cJSON_AddStringToObject(item, "password", user->password) == NULL) { + goto fail; //String + } + } - // user->phone - if(user->phone) { - if(cJSON_AddStringToObject(item, "phone", - user->phone) == NULL) - { - goto fail; // String - } - } + // user->phone + if(user->phone) { + if(cJSON_AddStringToObject(item, "phone", user->phone) == NULL) { + goto fail; //String + } + } - // user->userStatus - if(user->userStatus) { - if(cJSON_AddNumberToObject(item, "userStatus", - user->userStatus) == NULL) - { - goto fail; // Numeric - } - } + // user->userStatus + if(user->userStatus) { + if(cJSON_AddNumberToObject(item, "userStatus", user->userStatus) == NULL) { + goto fail; //Numeric + } + } - return item; + return item; fail: - if(item) { - cJSON_Delete(item); - } - return NULL; + if (item) { + cJSON_Delete(item); + } + return NULL; } -user_t *user_parseFromJSON(cJSON *userJSON) { - user_t *user_local_var = NULL; +user_t *user_parseFromJSON(cJSON *userJSON){ - // user->id - cJSON *id = cJSON_GetObjectItemCaseSensitive(userJSON, "id"); - if(id) { - if(!cJSON_IsNumber(id)) { - goto end; // Numeric - } - } + user_t *user_local_var = NULL; - // user->username - cJSON *username = - cJSON_GetObjectItemCaseSensitive(userJSON, "username"); - if(username) { - if(!cJSON_IsString(username)) { - goto end; // String - } - } + // user->id + cJSON *id = cJSON_GetObjectItemCaseSensitive(userJSON, "id"); + if (id) { + if(!cJSON_IsNumber(id)) + { + goto end; //Numeric + } + } - // user->firstName - cJSON *firstName = cJSON_GetObjectItemCaseSensitive(userJSON, - "firstName"); - if(firstName) { - if(!cJSON_IsString(firstName)) { - goto end; // String - } - } + // user->username + cJSON *username = cJSON_GetObjectItemCaseSensitive(userJSON, "username"); + if (username) { + if(!cJSON_IsString(username)) + { + goto end; //String + } + } - // user->lastName - cJSON *lastName = - cJSON_GetObjectItemCaseSensitive(userJSON, "lastName"); - if(lastName) { - if(!cJSON_IsString(lastName)) { - goto end; // String - } - } + // user->firstName + cJSON *firstName = cJSON_GetObjectItemCaseSensitive(userJSON, "firstName"); + if (firstName) { + if(!cJSON_IsString(firstName)) + { + goto end; //String + } + } - // user->email - cJSON *email = cJSON_GetObjectItemCaseSensitive(userJSON, "email"); - if(email) { - if(!cJSON_IsString(email)) { - goto end; // String - } - } + // user->lastName + cJSON *lastName = cJSON_GetObjectItemCaseSensitive(userJSON, "lastName"); + if (lastName) { + if(!cJSON_IsString(lastName)) + { + goto end; //String + } + } - // user->password - cJSON *password = - cJSON_GetObjectItemCaseSensitive(userJSON, "password"); - if(password) { - if(!cJSON_IsString(password)) { - goto end; // String - } - } + // user->email + cJSON *email = cJSON_GetObjectItemCaseSensitive(userJSON, "email"); + if (email) { + if(!cJSON_IsString(email)) + { + goto end; //String + } + } - // user->phone - cJSON *phone = cJSON_GetObjectItemCaseSensitive(userJSON, "phone"); - if(phone) { - if(!cJSON_IsString(phone)) { - goto end; // String - } - } + // user->password + cJSON *password = cJSON_GetObjectItemCaseSensitive(userJSON, "password"); + if (password) { + if(!cJSON_IsString(password)) + { + goto end; //String + } + } - // user->userStatus - cJSON *userStatus = cJSON_GetObjectItemCaseSensitive(userJSON, - "userStatus"); - if(userStatus) { - if(!cJSON_IsNumber(userStatus)) { - goto end; // Numeric - } - } + // user->phone + cJSON *phone = cJSON_GetObjectItemCaseSensitive(userJSON, "phone"); + if (phone) { + if(!cJSON_IsString(phone)) + { + goto end; //String + } + } + + // user->userStatus + cJSON *userStatus = cJSON_GetObjectItemCaseSensitive(userJSON, "userStatus"); + if (userStatus) { + if(!cJSON_IsNumber(userStatus)) + { + goto end; //Numeric + } + } - user_local_var = user_create( - id ? id->valuedouble : 0, - username ? strdup(username->valuestring) : NULL, - firstName ? strdup(firstName->valuestring) : NULL, - lastName ? strdup(lastName->valuestring) : NULL, - email ? strdup(email->valuestring) : NULL, - password ? strdup(password->valuestring) : NULL, - phone ? strdup(phone->valuestring) : NULL, - userStatus ? userStatus->valuedouble : 0 - ); + user_local_var = user_create ( + id ? id->valuedouble : 0, + username ? strdup(username->valuestring) : NULL, + firstName ? strdup(firstName->valuestring) : NULL, + lastName ? strdup(lastName->valuestring) : NULL, + email ? strdup(email->valuestring) : NULL, + password ? strdup(password->valuestring) : NULL, + phone ? strdup(phone->valuestring) : NULL, + userStatus ? userStatus->valuedouble : 0 + ); - return user_local_var; + return user_local_var; end: - return NULL; + return NULL; + } diff --git a/samples/client/petstore/c/model/user.h b/samples/client/petstore/c/model/user.h index dfb704efb26..954bc64a128 100644 --- a/samples/client/petstore/c/model/user.h +++ b/samples/client/petstore/c/model/user.h @@ -15,18 +15,27 @@ typedef struct user_t { - long id; // numeric - char *username; // string - char *firstName; // string - char *lastName; // string - char *email; // string - char *password; // string - char *phone; // string - int userStatus; // numeric + long id; //numeric + char *username; // string + char *firstName; // string + char *lastName; // string + char *email; // string + char *password; // string + char *phone; // string + int userStatus; //numeric + } user_t; -user_t *user_create(long id, char *username, char *firstName, char *lastName, - char *email, char *password, char *phone, int userStatus); +user_t *user_create( + long id, + char *username, + char *firstName, + char *lastName, + char *email, + char *password, + char *phone, + int userStatus +); void user_free(user_t *user); @@ -35,3 +44,4 @@ user_t *user_parseFromJSON(cJSON *userJSON); cJSON *user_convertToJSON(user_t *user); #endif /* _user_H_ */ + diff --git a/samples/client/petstore/c/src/apiClient.c b/samples/client/petstore/c/src/apiClient.c index eb569bd27a3..492b0563203 100644 --- a/samples/client/petstore/c/src/apiClient.c +++ b/samples/client/petstore/c/src/apiClient.c @@ -10,451 +10,448 @@ size_t writeDataCallback(void *buffer, size_t size, size_t nmemb, void *userp); apiClient_t *apiClient_create() { - curl_global_init(CURL_GLOBAL_ALL); - apiClient_t *apiClient = malloc(sizeof(apiClient_t)); - apiClient->basePath = "http://petstore.swagger.io/v2"; - apiClient->dataReceived = NULL; - apiClient->response_code = 0; - apiClient->apiKeys = NULL; - apiClient->accessToken = NULL; + curl_global_init(CURL_GLOBAL_ALL); + apiClient_t *apiClient = malloc(sizeof(apiClient_t)); + apiClient->basePath = "http://petstore.swagger.io/v2"; + apiClient->dataReceived = NULL; + apiClient->response_code = 0; + apiClient->apiKeys = NULL; + apiClient->accessToken = NULL; - return apiClient; + return apiClient; } void apiClient_free(apiClient_t *apiClient) { - if(apiClient->accessToken) { - list_free(apiClient->apiKeys); - } - if(apiClient->accessToken) { - free(apiClient->accessToken); - } - free(apiClient); - curl_global_cleanup(); + if(apiClient->accessToken) { + list_free(apiClient->apiKeys); + } + if(apiClient->accessToken) { + free(apiClient->accessToken); + } + free(apiClient); + curl_global_cleanup(); } void replaceSpaceWithPlus(char *stringToProcess) { - for(int i = 0; i < strlen(stringToProcess); i++) { - if(stringToProcess[i] == ' ') { - stringToProcess[i] = '+'; - } - } + for(int i = 0; i < strlen(stringToProcess); i++) { + if(stringToProcess[i] == ' ') { + stringToProcess[i] = '+'; + } + } } -char *assembleTargetUrl(char *basePath, char *operationParameter, - list_t *queryParameters) { - int neededBufferSizeForQueryParameters = 0; - listEntry_t *listEntry; +char *assembleTargetUrl(char *basePath, + char *operationParameter, + list_t *queryParameters) { + int neededBufferSizeForQueryParameters = 0; + listEntry_t *listEntry; - if(queryParameters != NULL) { - list_ForEach(listEntry, queryParameters) { - keyValuePair_t *pair = listEntry->data; - neededBufferSizeForQueryParameters += - strlen(pair->key) + strlen(pair->value); - } + if(queryParameters != NULL) { + list_ForEach(listEntry, queryParameters) { + keyValuePair_t *pair = listEntry->data; + neededBufferSizeForQueryParameters += + strlen(pair->key) + strlen(pair->value); + } - neededBufferSizeForQueryParameters += - (queryParameters->count * 2); // each keyValuePair is separated by a = and a & except the last, but this makes up for the ? at the beginning - } + neededBufferSizeForQueryParameters += + (queryParameters->count * 2); // each keyValuePair is separated by a = and a & except the last, but this makes up for the ? at the beginning + } - int operationParameterLength = 0; - int basePathLength = strlen(basePath); - bool slashNeedsToBeAppendedToBasePath = false; + int operationParameterLength = 0; + int basePathLength = strlen(basePath); + bool slashNeedsToBeAppendedToBasePath = false; - if(operationParameter != NULL) { - operationParameterLength = (1 + strlen(operationParameter)); - } - if(basePath[strlen(basePath) - 1] != '/') { - slashNeedsToBeAppendedToBasePath = true; - basePathLength++; - } + if(operationParameter != NULL) { + operationParameterLength = (1 + strlen(operationParameter)); + } + if(basePath[strlen(basePath) - 1] != '/') { + slashNeedsToBeAppendedToBasePath = true; + basePathLength++; + } - char *targetUrl = - malloc( - neededBufferSizeForQueryParameters + basePathLength + operationParameterLength + - 1); + char *targetUrl = + malloc( + neededBufferSizeForQueryParameters + basePathLength + operationParameterLength + + 1); - strcpy(targetUrl, basePath); + strcpy(targetUrl, basePath); - if(operationParameter != NULL) { - strcat(targetUrl, operationParameter); - } + if(operationParameter != NULL) { + strcat(targetUrl, operationParameter); + } - if(queryParameters != NULL) { - strcat(targetUrl, "?"); - list_ForEach(listEntry, queryParameters) { - keyValuePair_t *pair = listEntry->data; - replaceSpaceWithPlus(pair->key); - strcat(targetUrl, pair->key); - strcat(targetUrl, "="); - replaceSpaceWithPlus(pair->value); - strcat(targetUrl, pair->value); - if(listEntry->nextListEntry != NULL) { - strcat(targetUrl, "&"); - } - } - } + if(queryParameters != NULL) { + strcat(targetUrl, "?"); + list_ForEach(listEntry, queryParameters) { + keyValuePair_t *pair = listEntry->data; + replaceSpaceWithPlus(pair->key); + strcat(targetUrl, pair->key); + strcat(targetUrl, "="); + replaceSpaceWithPlus(pair->value); + strcat(targetUrl, pair->value); + if(listEntry->nextListEntry != NULL) { + strcat(targetUrl, "&"); + } + } + } - return targetUrl; + return targetUrl; } char *assembleHeaderField(char *key, char *value) { - char *header = malloc(strlen(key) + strlen(value) + 3); + char *header = malloc(strlen(key) + strlen(value) + 3); - strcpy(header, key), - strcat(header, ": "); - strcat(header, value); + strcpy(header, key), + strcat(header, ": "); + strcat(header, value); - return header; + return header; } void postData(CURL *handle, char *bodyParameters) { - curl_easy_setopt(handle, CURLOPT_POSTFIELDS, bodyParameters); - curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE_LARGE, - strlen(bodyParameters)); + curl_easy_setopt(handle, CURLOPT_POSTFIELDS, bodyParameters); + curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE_LARGE, + strlen(bodyParameters)); } int lengthOfKeyPair(keyValuePair_t *keyPair) { - long length = 0; - if((keyPair->key != NULL) && - (keyPair->value != NULL) ) - { - length = strlen(keyPair->key) + strlen(keyPair->value); - return length; - } - return 0; + long length = 0; + if((keyPair->key != NULL) && + (keyPair->value != NULL) ) + { + length = strlen(keyPair->key) + strlen(keyPair->value); + return length; + } + return 0; } -void apiClient_invoke(apiClient_t *apiClient, char *operationParameter, - list_t *queryParameters, list_t *headerParameters, - list_t *formParameters, list_t *headerType, - list_t *contentType, char *bodyParameters, - char *requestType) { - CURL *handle = curl_easy_init(); - CURLcode res; +void apiClient_invoke(apiClient_t *apiClient, + char *operationParameter, + list_t *queryParameters, + list_t *headerParameters, + list_t *formParameters, + list_t *headerType, + list_t *contentType, + char *bodyParameters, + char *requestType) { + CURL *handle = curl_easy_init(); + CURLcode res; - if(handle) { - listEntry_t *listEntry; - curl_mime *mime = NULL; - struct curl_slist *headers = NULL; - char *buffContent = NULL; - char *buffHeader = NULL; - binary_t *fileVar = NULL; - char *formString = NULL; + if(handle) { + listEntry_t *listEntry; + curl_mime *mime = NULL; + struct curl_slist *headers = NULL; + char *buffContent = NULL; + char *buffHeader = NULL; + binary_t *fileVar = NULL; + char *formString = NULL; - if(headerType != NULL) { - list_ForEach(listEntry, headerType) { - if(strstr((char *) listEntry->data, - "xml") == NULL) - { - buffHeader = malloc(strlen( - "Accept: ") + - strlen((char *) - listEntry-> - data) + 1); - sprintf(buffHeader, "%s%s", "Accept: ", - (char *) listEntry->data); - headers = curl_slist_append(headers, - buffHeader); - free(buffHeader); - } - } - } - if(contentType != NULL) { - list_ForEach(listEntry, contentType) { - if(strstr((char *) listEntry->data, - "xml") == NULL) - { - buffContent = - malloc(strlen( - "Content-Type: ") + strlen( - (char *) - listEntry->data) + - 1); - sprintf(buffContent, "%s%s", - "Content-Type: ", - (char *) listEntry->data); - headers = curl_slist_append(headers, - buffContent); - } - } - } else { - headers = curl_slist_append(headers, - "Content-Type: application/json"); - } + if(headerType != NULL) { + list_ForEach(listEntry, headerType) { + if(strstr((char *) listEntry->data, + "xml") == NULL) + { + buffHeader = malloc(strlen( + "Accept: ") + + strlen((char *) + listEntry-> + data) + 1); + sprintf(buffHeader, "%s%s", "Accept: ", + (char *) listEntry->data); + headers = curl_slist_append(headers, + buffHeader); + free(buffHeader); + } + } + } + if(contentType != NULL) { + list_ForEach(listEntry, contentType) { + if(strstr((char *) listEntry->data, + "xml") == NULL) + { + buffContent = + malloc(strlen( + "Content-Type: ") + strlen( + (char *) + listEntry->data) + + 1); + sprintf(buffContent, "%s%s", + "Content-Type: ", + (char *) listEntry->data); + headers = curl_slist_append(headers, + buffContent); + } + } + } else { + headers = curl_slist_append(headers, + "Content-Type: application/json"); + } - if(requestType != NULL) { - curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, - requestType); - } + if(requestType != NULL) { + curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, + requestType); + } - if(formParameters != NULL) { - if(strstr(buffContent, - "application/x-www-form-urlencoded") != NULL) - { - long parameterLength = 0; - long keyPairLength = 0; - list_ForEach(listEntry, formParameters) { - keyValuePair_t *keyPair = - listEntry->data; + if(formParameters != NULL) { + if(strstr(buffContent, + "application/x-www-form-urlencoded") != NULL) + { + long parameterLength = 0; + long keyPairLength = 0; + list_ForEach(listEntry, formParameters) { + keyValuePair_t *keyPair = + listEntry->data; - keyPairLength = - lengthOfKeyPair(keyPair) + 1; + keyPairLength = + lengthOfKeyPair(keyPair) + 1; - if(listEntry->nextListEntry != NULL) { - parameterLength++; - } - parameterLength = parameterLength + - keyPairLength; - } + if(listEntry->nextListEntry != NULL) { + parameterLength++; + } + parameterLength = parameterLength + + keyPairLength; + } - formString = malloc(parameterLength + 1); - memset(formString, 0, parameterLength + 1); + formString = malloc(parameterLength + 1); + memset(formString, 0, parameterLength + 1); - list_ForEach(listEntry, formParameters) { - keyValuePair_t *keyPair = - listEntry->data; - if((keyPair->key != NULL) && - (keyPair->value != NULL) ) - { - strcat(formString, - keyPair->key); - strcat(formString, "="); - strcat(formString, - keyPair->value); - if(listEntry->nextListEntry != - NULL) - { - strcat(formString, "&"); - } - } - } - curl_easy_setopt(handle, CURLOPT_POSTFIELDS, - formString); - } - if(strstr(buffContent, "multipart/form-data") != NULL) { - mime = curl_mime_init(handle); - list_ForEach(listEntry, formParameters) { - keyValuePair_t *keyValuePair = - listEntry->data; + list_ForEach(listEntry, formParameters) { + keyValuePair_t *keyPair = + listEntry->data; + if((keyPair->key != NULL) && + (keyPair->value != NULL) ) + { + strcat(formString, + keyPair->key); + strcat(formString, "="); + strcat(formString, + keyPair->value); + if(listEntry->nextListEntry != + NULL) + { + strcat(formString, "&"); + } + } + } + curl_easy_setopt(handle, CURLOPT_POSTFIELDS, + formString); + } + if(strstr(buffContent, "multipart/form-data") != NULL) { + mime = curl_mime_init(handle); + list_ForEach(listEntry, formParameters) { + keyValuePair_t *keyValuePair = + listEntry->data; - if((keyValuePair->key != NULL) && - (keyValuePair->value != NULL) ) - { - curl_mimepart *part = - curl_mime_addpart(mime); + if((keyValuePair->key != NULL) && + (keyValuePair->value != NULL) ) + { + curl_mimepart *part = + curl_mime_addpart(mime); - curl_mime_name(part, - keyValuePair->key); + curl_mime_name(part, + keyValuePair->key); - if(strcmp(keyValuePair->key, - "file") == 0) - { - memcpy(&fileVar, - keyValuePair->value, - sizeof(fileVar)); - curl_mime_data(part, - fileVar->data, - fileVar->len); - curl_mime_filename(part, - "image.png"); - } else { - curl_mime_data(part, - keyValuePair->value, - CURL_ZERO_TERMINATED); - } - } - } - curl_easy_setopt(handle, CURLOPT_MIMEPOST, - mime); - } - } + if(strcmp(keyValuePair->key, + "file") == 0) + { + memcpy(&fileVar, + keyValuePair->value, + sizeof(fileVar)); + curl_mime_data(part, + fileVar->data, + fileVar->len); + curl_mime_filename(part, + "image.png"); + } else { + curl_mime_data(part, + keyValuePair->value, + CURL_ZERO_TERMINATED); + } + } + } + curl_easy_setopt(handle, CURLOPT_MIMEPOST, + mime); + } + } - list_ForEach(listEntry, headerParameters) { - keyValuePair_t *keyValuePair = listEntry->data; - if((keyValuePair->key != NULL) && - (keyValuePair->value != NULL) ) - { - char *headerValueToWrite = assembleHeaderField( - keyValuePair->key, keyValuePair->value); - curl_slist_append(headers, headerValueToWrite); - free(headerValueToWrite); - } - } - // this would only be generated for apiKey authentication - if(apiClient->apiKeys != NULL) { - list_ForEach(listEntry, apiClient->apiKeys) { - keyValuePair_t *apiKey = listEntry->data; - if((apiKey->key != NULL) && - (apiKey->value != NULL) ) - { - char *headerValueToWrite = - assembleHeaderField( - apiKey->key, - apiKey->value); - curl_slist_append(headers, - headerValueToWrite); - free(headerValueToWrite); - } - } - } + list_ForEach(listEntry, headerParameters) { + keyValuePair_t *keyValuePair = listEntry->data; + if((keyValuePair->key != NULL) && + (keyValuePair->value != NULL) ) + { + char *headerValueToWrite = assembleHeaderField( + keyValuePair->key, keyValuePair->value); + curl_slist_append(headers, headerValueToWrite); + free(headerValueToWrite); + } + } + // this would only be generated for apiKey authentication + if (apiClient->apiKeys != NULL) + { + list_ForEach(listEntry, apiClient->apiKeys) { + keyValuePair_t *apiKey = listEntry->data; + if((apiKey->key != NULL) && + (apiKey->value != NULL) ) + { + char *headerValueToWrite = assembleHeaderField( + apiKey->key, apiKey->value); + curl_slist_append(headers, headerValueToWrite); + free(headerValueToWrite); + } + } + } - char *targetUrl = - assembleTargetUrl(apiClient->basePath, - operationParameter, - queryParameters); + char *targetUrl = + assembleTargetUrl(apiClient->basePath, + operationParameter, + queryParameters); - curl_easy_setopt(handle, CURLOPT_URL, targetUrl); - curl_easy_setopt(handle, - CURLOPT_WRITEFUNCTION, - writeDataCallback); - curl_easy_setopt(handle, - CURLOPT_WRITEDATA, - &apiClient->dataReceived); - curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers); - curl_easy_setopt(handle, CURLOPT_VERBOSE, 0); // to get curl debug msg 0: to disable, 1L:to enable + curl_easy_setopt(handle, CURLOPT_URL, targetUrl); + curl_easy_setopt(handle, + CURLOPT_WRITEFUNCTION, + writeDataCallback); + curl_easy_setopt(handle, + CURLOPT_WRITEDATA, + &apiClient->dataReceived); + curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(handle, CURLOPT_VERBOSE, 0); // to get curl debug msg 0: to disable, 1L:to enable - // this would only be generated for OAuth2 authentication - if(apiClient->accessToken != NULL) { - // curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BEARER); - curl_easy_setopt(handle, - CURLOPT_XOAUTH2_BEARER, - apiClient->accessToken); - } + // this would only be generated for OAuth2 authentication + if(apiClient->accessToken != NULL) { + // curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BEARER); + curl_easy_setopt(handle, + CURLOPT_XOAUTH2_BEARER, + apiClient->accessToken); + } - if(bodyParameters != NULL) { - postData(handle, bodyParameters); - } + if(bodyParameters != NULL) { + postData(handle, bodyParameters); + } - res = curl_easy_perform(handle); + res = curl_easy_perform(handle); - curl_slist_free_all(headers); + curl_slist_free_all(headers); - free(targetUrl); + free(targetUrl); - if(contentType != NULL) { - free(buffContent); - } + if(contentType != NULL) { + free(buffContent); + } - if(res == CURLE_OK) { - curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, - &apiClient->response_code); - } else { - char *url, *ip, *scheme; - long port; - curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url); - curl_easy_getinfo(handle, CURLINFO_PRIMARY_IP, &ip); - curl_easy_getinfo(handle, CURLINFO_PRIMARY_PORT, &port); - curl_easy_getinfo(handle, CURLINFO_SCHEME, &scheme); - fprintf(stderr, - "curl_easy_perform() failed\n\nURL: %s\nIP: %s\nPORT: %li\nSCHEME: %s\nStrERROR: %s\n", url, ip, port, scheme, - curl_easy_strerror(res)); - } + if(res == CURLE_OK) { + curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &apiClient->response_code); + } else { + char *url,*ip,*scheme; + long port; + curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url); + curl_easy_getinfo(handle, CURLINFO_PRIMARY_IP, &ip); + curl_easy_getinfo(handle, CURLINFO_PRIMARY_PORT, &port); + curl_easy_getinfo(handle, CURLINFO_SCHEME, &scheme); + fprintf(stderr, "curl_easy_perform() failed\n\nURL: %s\nIP: %s\nPORT: %li\nSCHEME: %s\nStrERROR: %s\n",url,ip,port,scheme, + curl_easy_strerror(res)); + } - curl_easy_cleanup(handle); - if(formParameters != NULL) { - free(formString); - curl_mime_free(mime); - } - } + curl_easy_cleanup(handle); + if(formParameters != NULL) { + free(formString); + curl_mime_free(mime); + } + } } size_t writeDataCallback(void *buffer, size_t size, size_t nmemb, void *userp) { - *(char **) userp = strdup(buffer); + *(char **) userp = strdup(buffer); - return size * nmemb; + return size * nmemb; } char *strReplace(char *orig, char *rep, char *with) { - char *result; // the return string - char *ins; // the next insert point - char *tmp; // varies - int lenRep; // length of rep (the string to remove) - int lenWith; // length of with (the string to replace rep with) - int lenFront; // distance between rep and end of last rep - int count; // number of replacements + char *result; // the return string + char *ins; // the next insert point + char *tmp; // varies + int lenRep; // length of rep (the string to remove) + int lenWith; // length of with (the string to replace rep with) + int lenFront; // distance between rep and end of last rep + int count; // number of replacements - // sanity checks and initialization - if(!orig || - !rep) - { - return NULL; - } - lenRep = strlen(rep); - if(lenRep == 0) { - return NULL; // empty rep causes infinite loop during count - } - if(!with) { - with = ""; - } - lenWith = strlen(with); + // sanity checks and initialization + if(!orig || !rep) + { + return NULL; + } + lenRep = strlen(rep); + if(lenRep == 0) { + return NULL; // empty rep causes infinite loop during count + } + if(!with) { + with = ""; + } + lenWith = strlen(with); - // count the number of replacements needed - ins = orig; - for(count = 0; tmp = strstr(ins, rep); ++count) { - ins = tmp + lenRep; - } + // count the number of replacements needed + ins = orig; + for(count = 0; tmp = strstr(ins, rep); ++count) { + ins = tmp + lenRep; + } - tmp = result = malloc(strlen(orig) + (lenWith - lenRep) * count + 1); + tmp = result = malloc(strlen(orig) + (lenWith - lenRep) * count + 1); - if(!result) { - return NULL; - } - char *originalPointer = orig; // copying original pointer to free the memory - // first time through the loop, all the variable are set correctly - // from here on, - // tmp points to the end of the result string - // ins points to the next occurrence of rep in orig - // orig points to the remainder of orig after "end of rep" - while(count--) { - ins = strstr(orig, rep); - lenFront = ins - orig; - tmp = strncpy(tmp, orig, lenFront) + lenFront; - tmp = strcpy(tmp, with) + lenWith; - orig += lenFront + lenRep; // move to next "end of rep" - } - strcpy(tmp, orig); - free(originalPointer); - return result; + if(!result) { + return NULL; + } + char *originalPointer = orig; // copying original pointer to free the memory + // first time through the loop, all the variable are set correctly + // from here on, + // tmp points to the end of the result string + // ins points to the next occurrence of rep in orig + // orig points to the remainder of orig after "end of rep" + while(count--) { + ins = strstr(orig, rep); + lenFront = ins - orig; + tmp = strncpy(tmp, orig, lenFront) + lenFront; + tmp = strcpy(tmp, with) + lenWith; + orig += lenFront + lenRep; // move to next "end of rep" + } + strcpy(tmp, orig); + free(originalPointer); + return result; } -char *sbi_base64encode(const void *b64_encode_this, - int encode_this_many_bytes) { +char *sbi_base64encode (const void *b64_encode_this, int encode_this_many_bytes){ #ifdef OPENSSL - BIO *b64_bio, *mem_bio; // Declares two OpenSSL BIOs: a base64 filter and a memory BIO. - BUF_MEM *mem_bio_mem_ptr; // Pointer to a "memory BIO" structure holding our base64 data. - b64_bio = BIO_new(BIO_f_base64()); // Initialize our base64 filter BIO. - mem_bio = BIO_new(BIO_s_mem()); // Initialize our memory sink BIO. - BIO_push(b64_bio, mem_bio); // Link the BIOs by creating a filter-sink BIO chain. - BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); // No newlines every 64 characters or less. - BIO_write(b64_bio, b64_encode_this, encode_this_many_bytes); // Records base64 encoded data. - BIO_flush(b64_bio); // Flush data. Necessary for b64 encoding, because of pad characters. - BIO_get_mem_ptr(mem_bio, &mem_bio_mem_ptr); // Store address of mem_bio's memory structure. - BIO_set_close(mem_bio, BIO_NOCLOSE); // Permit access to mem_ptr after BIOs are destroyed. - BIO_free_all(b64_bio); // Destroys all BIOs in chain, starting with b64 (i.e. the 1st one). - BUF_MEM_grow(mem_bio_mem_ptr, (*mem_bio_mem_ptr).length + 1); // Makes space for end null. - (*mem_bio_mem_ptr).data[(*mem_bio_mem_ptr).length] = '\0'; // Adds null-terminator to tail. - return (*mem_bio_mem_ptr).data; // Returns base-64 encoded data. (See: "buf_mem_st" struct). + BIO *b64_bio, *mem_bio; //Declares two OpenSSL BIOs: a base64 filter and a memory BIO. + BUF_MEM *mem_bio_mem_ptr; //Pointer to a "memory BIO" structure holding our base64 data. + b64_bio = BIO_new(BIO_f_base64()); //Initialize our base64 filter BIO. + mem_bio = BIO_new(BIO_s_mem()); //Initialize our memory sink BIO. + BIO_push(b64_bio, mem_bio); //Link the BIOs by creating a filter-sink BIO chain. + BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); //No newlines every 64 characters or less. + BIO_write(b64_bio, b64_encode_this, encode_this_many_bytes); //Records base64 encoded data. + BIO_flush(b64_bio); //Flush data. Necessary for b64 encoding, because of pad characters. + BIO_get_mem_ptr(mem_bio, &mem_bio_mem_ptr); //Store address of mem_bio's memory structure. + BIO_set_close(mem_bio, BIO_NOCLOSE); //Permit access to mem_ptr after BIOs are destroyed. + BIO_free_all(b64_bio); //Destroys all BIOs in chain, starting with b64 (i.e. the 1st one). + BUF_MEM_grow(mem_bio_mem_ptr, (*mem_bio_mem_ptr).length + 1); //Makes space for end null. + (*mem_bio_mem_ptr).data[(*mem_bio_mem_ptr).length] = '\0'; //Adds null-terminator to tail. + return (*mem_bio_mem_ptr).data; //Returns base-64 encoded data. (See: "buf_mem_st" struct). #endif } -char *sbi_base64decode(const void *b64_decode_this, - int decode_this_many_bytes) { +char *sbi_base64decode (const void *b64_decode_this, int decode_this_many_bytes){ #ifdef OPENSSL - BIO *b64_bio, *mem_bio; // Declares two OpenSSL BIOs: a base64 filter and a memory BIO. - char *base64_decoded = calloc( (decode_this_many_bytes * 3) / 4 + 1, - sizeof(char) ); // +1 = null. - b64_bio = BIO_new(BIO_f_base64()); // Initialize our base64 filter BIO. - mem_bio = BIO_new(BIO_s_mem()); // Initialize our memory source BIO. - BIO_write(mem_bio, b64_decode_this, decode_this_many_bytes); // Base64 data saved in source. - BIO_push(b64_bio, mem_bio); // Link the BIOs by creating a filter-source BIO chain. - BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); // Don't require trailing newlines. - int decoded_byte_index = 0; // Index where the next base64_decoded byte should be written. - while(0 < BIO_read(b64_bio, base64_decoded + decoded_byte_index, 1) ) { // Read byte-by-byte. - decoded_byte_index++; // Increment the index until read of BIO decoded data is complete. - } // Once we're done reading decoded data, BIO_read returns -1 even though there's no error. - BIO_free_all(b64_bio); // Destroys all BIOs in chain, starting with b64 (i.e. the 1st one). - return base64_decoded; // Returns base-64 decoded data with trailing null terminator. + BIO *b64_bio, *mem_bio; //Declares two OpenSSL BIOs: a base64 filter and a memory BIO. + char *base64_decoded = calloc( (decode_this_many_bytes*3)/4+1, sizeof(char) ); //+1 = null. + b64_bio = BIO_new(BIO_f_base64()); //Initialize our base64 filter BIO. + mem_bio = BIO_new(BIO_s_mem()); //Initialize our memory source BIO. + BIO_write(mem_bio, b64_decode_this, decode_this_many_bytes); //Base64 data saved in source. + BIO_push(b64_bio, mem_bio); //Link the BIOs by creating a filter-source BIO chain. + BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); //Don't require trailing newlines. + int decoded_byte_index = 0; //Index where the next base64_decoded byte should be written. + while ( 0 < BIO_read(b64_bio, base64_decoded+decoded_byte_index, 1) ){ //Read byte-by-byte. + decoded_byte_index++; //Increment the index until read of BIO decoded data is complete. + } //Once we're done reading decoded data, BIO_read returns -1 even though there's no error. + BIO_free_all(b64_bio); //Destroys all BIOs in chain, starting with b64 (i.e. the 1st one). + return base64_decoded; //Returns base-64 decoded data with trailing null terminator. #endif } diff --git a/samples/client/petstore/c/src/apiKey.c b/samples/client/petstore/c/src/apiKey.c index a7e000eb3b1..2bf8fc3e9d0 100644 --- a/samples/client/petstore/c/src/apiKey.c +++ b/samples/client/petstore/c/src/apiKey.c @@ -3,12 +3,12 @@ #include "../include/keyValuePair.h" keyValuePair_t *keyValuePair_create(char *key, void *value) { - keyValuePair_t *keyValuePair = malloc(sizeof(keyValuePair_t)); - keyValuePair->key = key; - keyValuePair->value = value; - return keyValuePair; + keyValuePair_t *keyValuePair = malloc(sizeof(keyValuePair_t)); + keyValuePair->key = key; + keyValuePair->value = value; + return keyValuePair; } void keyValuePair_free(keyValuePair_t *keyValuePair) { - free(keyValuePair); + free(keyValuePair); } diff --git a/samples/client/petstore/c/src/list.c b/samples/client/petstore/c/src/list.c index dc3f78dab76..73eee13c24d 100644 --- a/samples/client/petstore/c/src/list.c +++ b/samples/client/petstore/c/src/list.c @@ -4,161 +4,163 @@ #include "../include/list.h" static listEntry_t *listEntry_create(void *data) { - listEntry_t *createdListEntry = malloc(sizeof(listEntry_t)); - if(createdListEntry == NULL) { - // TODO Malloc Failure - return NULL; - } - createdListEntry->data = data; + listEntry_t *createdListEntry = malloc(sizeof(listEntry_t)); + if(createdListEntry == NULL) { + // TODO Malloc Failure + return NULL; + } + createdListEntry->data = data; - return createdListEntry; + return createdListEntry; } void listEntry_free(listEntry_t *listEntry, void *additionalData) { - free(listEntry); + free(listEntry); } void listEntry_printAsInt(listEntry_t *listEntry, void *additionalData) { - printf("%i\n", *((int *) (listEntry->data))); + printf("%i\n", *((int *) (listEntry->data))); } list_t *list_create() { - list_t *createdList = malloc(sizeof(list_t)); - if(createdList == NULL) { - // TODO Malloc Failure - return NULL; - } - createdList->firstEntry = NULL; - createdList->lastEntry = NULL; - createdList->count = 0; + list_t *createdList = malloc(sizeof(list_t)); + if(createdList == NULL) { + // TODO Malloc Failure + return NULL; + } + createdList->firstEntry = NULL; + createdList->lastEntry = NULL; + createdList->count = 0; - return createdList; + return createdList; } -void list_iterateThroughListForward(list_t *list, void (*operationToPerform)( - listEntry_t *, - void *callbackFunctionUsedData), +void list_iterateThroughListForward(list_t *list, + void (*operationToPerform)( + listEntry_t *, + void *callbackFunctionUsedData), void *additionalDataNeededForCallbackFunction) { - listEntry_t *currentListEntry = list->firstEntry; - listEntry_t *nextListEntry; + listEntry_t *currentListEntry = list->firstEntry; + listEntry_t *nextListEntry; - if(currentListEntry == NULL) { - return; - } + if(currentListEntry == NULL) { + return; + } - nextListEntry = currentListEntry->nextListEntry; + nextListEntry = currentListEntry->nextListEntry; - operationToPerform(currentListEntry, - additionalDataNeededForCallbackFunction); - currentListEntry = nextListEntry; + operationToPerform(currentListEntry, + additionalDataNeededForCallbackFunction); + currentListEntry = nextListEntry; - while(currentListEntry != NULL) { - nextListEntry = currentListEntry->nextListEntry; - operationToPerform(currentListEntry, - additionalDataNeededForCallbackFunction); - currentListEntry = nextListEntry; - } + while(currentListEntry != NULL) { + nextListEntry = currentListEntry->nextListEntry; + operationToPerform(currentListEntry, + additionalDataNeededForCallbackFunction); + currentListEntry = nextListEntry; + } } -void list_iterateThroughListBackward(list_t *list, void (*operationToPerform)( - listEntry_t *, - void *callbackFunctionUsedData), +void list_iterateThroughListBackward(list_t *list, + void (*operationToPerform)( + listEntry_t *, + void *callbackFunctionUsedData), void *additionalDataNeededForCallbackFunction) { - listEntry_t *currentListEntry = list->lastEntry; - listEntry_t *nextListEntry = currentListEntry->prevListEntry; + listEntry_t *currentListEntry = list->lastEntry; + listEntry_t *nextListEntry = currentListEntry->prevListEntry; - if(currentListEntry == NULL) { - return; - } + if(currentListEntry == NULL) { + return; + } - operationToPerform(currentListEntry, - additionalDataNeededForCallbackFunction); - currentListEntry = nextListEntry; + operationToPerform(currentListEntry, + additionalDataNeededForCallbackFunction); + currentListEntry = nextListEntry; - while(currentListEntry != NULL) { - nextListEntry = currentListEntry->prevListEntry; - operationToPerform(currentListEntry, - additionalDataNeededForCallbackFunction); - currentListEntry = nextListEntry; - } + while(currentListEntry != NULL) { + nextListEntry = currentListEntry->prevListEntry; + operationToPerform(currentListEntry, + additionalDataNeededForCallbackFunction); + currentListEntry = nextListEntry; + } } void list_free(list_t *list) { - list_iterateThroughListForward(list, listEntry_free, NULL); - free(list); + list_iterateThroughListForward(list, listEntry_free, NULL); + free(list); } void list_addElement(list_t *list, void *dataToAddInList) { - listEntry_t *newListEntry = listEntry_create(dataToAddInList); - if(newListEntry == NULL) { - // TODO Malloc Failure - return; - } - if(list->firstEntry == NULL) { - list->firstEntry = newListEntry; - list->lastEntry = newListEntry; + listEntry_t *newListEntry = listEntry_create(dataToAddInList); + if(newListEntry == NULL) { + // TODO Malloc Failure + return; + } + if(list->firstEntry == NULL) { + list->firstEntry = newListEntry; + list->lastEntry = newListEntry; - newListEntry->prevListEntry = NULL; - newListEntry->nextListEntry = NULL; + newListEntry->prevListEntry = NULL; + newListEntry->nextListEntry = NULL; - list->count++; + list->count++; - return; - } + return; + } - list->lastEntry->nextListEntry = newListEntry; - newListEntry->prevListEntry = list->lastEntry; - newListEntry->nextListEntry = NULL; - list->lastEntry = newListEntry; + list->lastEntry->nextListEntry = newListEntry; + newListEntry->prevListEntry = list->lastEntry; + newListEntry->nextListEntry = NULL; + list->lastEntry = newListEntry; - list->count++; + list->count++; } void list_removeElement(list_t *list, listEntry_t *elementToRemove) { - listEntry_t *elementBeforeElementToRemove = - elementToRemove->prevListEntry; - listEntry_t *elementAfterElementToRemove = - elementToRemove->nextListEntry; + listEntry_t *elementBeforeElementToRemove = + elementToRemove->prevListEntry; + listEntry_t *elementAfterElementToRemove = + elementToRemove->nextListEntry; - if(elementBeforeElementToRemove != NULL) { - elementBeforeElementToRemove->nextListEntry = - elementAfterElementToRemove; - } else { - list->firstEntry = elementAfterElementToRemove; - } + if(elementBeforeElementToRemove != NULL) { + elementBeforeElementToRemove->nextListEntry = + elementAfterElementToRemove; + } else { + list->firstEntry = elementAfterElementToRemove; + } - if(elementAfterElementToRemove != NULL) { - elementAfterElementToRemove->prevListEntry = - elementBeforeElementToRemove; - } else { - list->lastEntry = elementBeforeElementToRemove; - } + if(elementAfterElementToRemove != NULL) { + elementAfterElementToRemove->prevListEntry = + elementBeforeElementToRemove; + } else { + list->lastEntry = elementBeforeElementToRemove; + } - listEntry_free(elementToRemove, NULL); + listEntry_free(elementToRemove, NULL); - list->count--; + list->count--; } listEntry_t *list_getElementAt(list_t *list, long indexOfElement) { - listEntry_t *currentListEntry; + listEntry_t *currentListEntry; - if((list->count / 2) > indexOfElement) { - currentListEntry = list->firstEntry; + if((list->count / 2) > indexOfElement) { + currentListEntry = list->firstEntry; - for(int i = 0; i < indexOfElement; i++) { - currentListEntry = currentListEntry->nextListEntry; - } + for(int i = 0; i < indexOfElement; i++) { + currentListEntry = currentListEntry->nextListEntry; + } - return currentListEntry; - } else { - currentListEntry = list->lastEntry; + return currentListEntry; + } else { + currentListEntry = list->lastEntry; - for(int i = 1; i < (list->count - indexOfElement); i++) { - currentListEntry = currentListEntry->prevListEntry; - } + for(int i = 1; i < (list->count - indexOfElement); i++) { + currentListEntry = currentListEntry->prevListEntry; + } - return currentListEntry; - } + return currentListEntry; + } }