loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

C additional properties fix #4289 (#4349)

Browse Source 
* Correction to C support for additional_properties

* TAB to SPACE in one file
This commit is contained in:
Michele Albano 2019-11-27 10:15:47 +01:00 committed by William Cheng
parent e09417d25c
commit 96c1bda608
31 changed files with 4959 additions and 4833 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
modules/openapi-generator/src/main/resources/C-libcurl/model-body.mustache vendored
View File

@ -189,15 +189,15 @@ return 0;
{{/isContainer}} {{/isContainer}}
{{/vars}} {{/vars}}
) { ) {
{{classname}}_t *{{classname}}_local_var = malloc(sizeof({{classname}}_t)); {{classname}}_t *{{classname}}_local_var = malloc(sizeof({{classname}}_t));
if (!{{classname}}_local_var) { if (!{{classname}}_local_var) {
return NULL; return NULL;
} }
{{#vars}} {{#vars}}
{{classname}}_local_var->{{{baseName}}} = {{{baseName}}}; {{classname}}_local_var->{{{baseName}}} = {{{baseName}}};
{{/vars}} {{/vars}}
return {{classname}}_local_var; return {{classname}}_local_var;
} }
@ -241,36 +241,36 @@ void {{classname}}_free({{classname}}_t *{{classname}}) {
{{#isContainer}} {{#isContainer}}
{{#isListContainer}} {{#isListContainer}}
{{#isPrimitiveType}} {{#isPrimitiveType}}
list_ForEach(listEntry, {{classname}}->{{baseName}}) { list_ForEach(listEntry, {{classname}}->{{baseName}}) {
free(listEntry->data); free(listEntry->data);
} }
list_free({{classname}}->{{baseName}}); list_free({{classname}}->{{baseName}});
{{/isPrimitiveType}} {{/isPrimitiveType}}
{{^isPrimitiveType}} {{^isPrimitiveType}}
list_ForEach(listEntry, {{classname}}->{{baseName}}) { list_ForEach(listEntry, {{classname}}->{{baseName}}) {
{{complexType}}_free(listEntry->data); {{complexType}}_free(listEntry->data);
} }
list_free({{classname}}->{{baseName}}); list_free({{classname}}->{{baseName}});
{{/isPrimitiveType}} {{/isPrimitiveType}}
{{/isListContainer}} {{/isListContainer}}
{{#isMapContainer}} {{#isMapContainer}}
list_ForEach(listEntry, {{classname}}->{{baseName}}) { list_ForEach(listEntry, {{classname}}->{{baseName}}) {
keyValuePair_t *localMapKeyPair = (keyValuePair_t*) listEntry->data; keyValuePair_t *localKeyValue = (keyValuePair_t*) listEntry->data;
free (localKeyValue->key); free (localKeyValue->key);
free (localKeyValue->value); free (localKeyValue->value);
} }
list_free({{classname}}->{{baseName}}); list_free({{classname}}->{{baseName}});
{{/isMapContainer}} {{/isMapContainer}}
{{/isContainer}} {{/isContainer}}
{{/vars}} {{/vars}}
free({{classname}}); free({{classname}});
} }
cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) { cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
{{#vars}} {{#vars}}
// {{{classname}}}->{{{baseName}}} // {{{classname}}}->{{{baseName}}}
{{#required}} {{#required}}
{{^isEnum}} {{^isEnum}}
if (!{{{classname}}}->{{{baseName}}}) { if (!{{{classname}}}->{{{baseName}}}) {
@ -279,8 +279,8 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
{{/isEnum}} {{/isEnum}}
{{/required}} {{/required}}
{{^required}}{{^isEnum}}if({{{classname}}}->{{{baseName}}}) { {{/isEnum}}{{/required}} {{^required}}{{^isEnum}}if({{{classname}}}->{{{baseName}}}) { {{/isEnum}}{{/required}}
{{^isContainer}} {{^isContainer}}
{{#isPrimitiveType}} {{#isPrimitiveType}}
{{#isNumeric}} {{#isNumeric}}
if(cJSON_AddNumberToObject(item, "{{{baseName}}}", {{{classname}}}->{{{baseName}}}) == NULL) { if(cJSON_AddNumberToObject(item, "{{{baseName}}}", {{{classname}}}->{{{baseName}}}) == NULL) {
goto fail; //Numeric goto fail; //Numeric
@ -328,8 +328,8 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
goto fail; //Date-Time goto fail; //Date-Time
} }
{{/isDateTime}} {{/isDateTime}}
{{/isPrimitiveType}} {{/isPrimitiveType}}
{{^isPrimitiveType}} {{^isPrimitiveType}}
{{#isModel}} {{#isModel}}
{{#isEnum}} {{#isEnum}}
cJSON *{{{baseName}}}_enum_local_JSON = {{datatypeWithEnum}}_convertToJSON({{{classname}}}->{{{baseName}}}); cJSON *{{{baseName}}}_enum_local_JSON = {{datatypeWithEnum}}_convertToJSON({{{classname}}}->{{{baseName}}});
@ -372,17 +372,17 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
goto fail; goto fail;
} }
{{/isFreeFormObject}} {{/isFreeFormObject}}
{{/isPrimitiveType}} {{/isPrimitiveType}}
{{/isContainer}} {{/isContainer}}
{{#isContainer}} {{#isContainer}}
{{#isListContainer}} {{#isListContainer}}
{{#isPrimitiveType}} {{#isPrimitiveType}}
cJSON *{{{name}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}"); cJSON *{{{name}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}");
if({{{name}}} == NULL) { if({{{name}}} == NULL) {
goto fail; //primitive container goto fail; //primitive container
} }
listEntry_t *{{{name}}}ListEntry; listEntry_t *{{{name}}}ListEntry;
list_ForEach({{{name}}}ListEntry, {{{classname}}}->{{{baseName}}}) { list_ForEach({{{name}}}ListEntry, {{{classname}}}->{{{baseName}}}) {
{{#items}} {{#items}}
{{#isString}} {{#isString}}
@ -399,8 +399,8 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
{{/isString}} {{/isString}}
{{/items}} {{/items}}
} }
{{/isPrimitiveType}} {{/isPrimitiveType}}
{{^isPrimitiveType}} {{^isPrimitiveType}}
cJSON *{{{baseName}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}"); cJSON *{{{baseName}}} = cJSON_AddArrayToObject(item, "{{{baseName}}}");
if({{{baseName}}} == NULL) { if({{{baseName}}} == NULL) {
goto fail; //nonprimitive container goto fail; //nonprimitive container
@ -416,15 +416,15 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
cJSON_AddItemToArray({{{baseName}}}, itemLocal); cJSON_AddItemToArray({{{baseName}}}, itemLocal);
} }
} }
{{/isPrimitiveType}} {{/isPrimitiveType}}
{{/isListContainer}} {{/isListContainer}}
{{#isMapContainer}} {{#isMapContainer}}
cJSON *{{{baseName}}} = cJSON_AddObjectToObject(item, "{{{baseName}}}"); cJSON *{{{baseName}}} = cJSON_AddObjectToObject(item, "{{{baseName}}}");
if({{{baseName}}} == NULL) { if({{{baseName}}} == NULL) {
goto fail; //primitive map container goto fail; //primitive map container
} }
cJSON *localMapObject = cJSON_CreateObject(); //Memory free to be implemented in user code cJSON *localMapObject = cJSON_CreateObject(); //Memory free to be implemented in user code
listEntry_t *{{{baseName}}}ListEntry; listEntry_t *{{{baseName}}}ListEntry;
if ({{{classname}}}->{{{baseName}}}) { if ({{{classname}}}->{{{baseName}}}) {
list_ForEach({{{baseName}}}ListEntry, {{{classname}}}->{{{baseName}}}) { list_ForEach({{{baseName}}}ListEntry, {{{classname}}}->{{{baseName}}}) {
keyValuePair_t *localKeyValue = (keyValuePair_t*){{{baseName}}}ListEntry->data; keyValuePair_t *localKeyValue = (keyValuePair_t*){{{baseName}}}ListEntry->data;
@ -445,19 +445,19 @@ cJSON *{{classname}}_convertToJSON({{classname}}_t *{{classname}}) {
cJSON_AddItemToObject({{{baseName}}},"", localMapObject); cJSON_AddItemToObject({{{baseName}}},"", localMapObject);
} }
} }
{{/isMapContainer}} {{/isMapContainer}}
{{/isContainer}} {{/isContainer}}
{{^required}} {{^required}}
{{^isEnum}} } {{/isEnum}} {{^isEnum}} } {{/isEnum}}
{{/required}} {{/required}}
{{/vars}} {{/vars}}
return item; return item;
fail: fail:
if (item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
{{classname}}_t *{{classname}}_parseFromJSON(cJSON *{{classname}}JSON){ {{classname}}_t *{{classname}}_parseFromJSON(cJSON *{{classname}}JSON){
@ -526,8 +526,8 @@ fail:
char* decoded = base64decode({{{baseName}}}->valuestring, strlen({{{baseName}}}->valuestring)); char* decoded = base64decode({{{baseName}}}->valuestring, strlen({{{baseName}}}->valuestring));
decoded_str_{{{baseName}}}->data = malloc(strlen(decoded) - 1); decoded_str_{{{baseName}}}->data = malloc(strlen(decoded) - 1);
if (!decoded_str_{{{baseName}}}->data) { if (!decoded_str_{{{baseName}}}->data) {
goto end; goto end;
} }
memcpy(decoded_str_{{{baseName}}}->data,decoded,(strlen(decoded)-1)); memcpy(decoded_str_{{{baseName}}}->data,decoded,(strlen(decoded)-1));
decoded_str_{{{baseName}}}->len = strlen(decoded) - 1; decoded_str_{{{baseName}}}->len = strlen(decoded) - 1;
{{/isBinary}} {{/isBinary}}

2
samples/client/petstore/c/.openapi-generator/VERSION
View File

@ -1 +1 @@
4.2.1-SNAPSHOT 4.2.2-SNAPSHOT

45
samples/client/petstore/c/CMakeLists.txt
View File

@ -63,27 +63,28 @@ install(TARGETS ${pkgName} DESTINATION ${CMAKE_INSTALL_PREFIX})
set(SRCS "") set(SRCS "")
set(HDRS "") 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 ## This section shows how to use the above compiled libary to compile the source files
set(HDRS ## 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 ##set header files
foreach(SOURCE_FILE ${SRCS}) #set(HDRS
# 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 ## loop over all files in SRCS variable
string( REPLACE ".c" "" EXECUTABLE_FILE ${FILE_NAME_ONLY}) #foreach(SOURCE_FILE ${SRCS})
# Add executable for every source file in SRCS # # Get only the file name from the file as add_executable doesnot support executable with slash("/")
add_executable(unit-${EXECUTABLE_FILE} ${SOURCE_FILE}) # get_filename_component(FILE_NAME_ONLY ${SOURCE_FILE} NAME_WE)
# Link above created libary to executable and dependent libary curl # # Remove .c from the file name and set it as executable name
target_link_libraries(unit-${EXECUTABLE_FILE} ${CURL_LIBRARIES} ${pkgName} ) # string( REPLACE ".c" "" EXECUTABLE_FILE ${FILE_NAME_ONLY})
endforeach(SOURCE_FILE ${SRCS}) # # 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})

1027
samples/client/petstore/c/api/PetAPI.c
View File

File diff suppressed because it is too large Load Diff

28
samples/client/petstore/c/api/PetAPI.h
View File

@ -10,47 +10,55 @@
// Add a new pet to the store // 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 // 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 // Finds Pets by status
// //
// Multiple status values can be provided with comma separated strings // 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 // Finds Pets by tags
// //
// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. // 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 // Find pet by ID
// //
// Returns a single pet // 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 // 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 // Updates a pet in the store with form data
// //
void PetAPI_updatePetWithForm(apiClient_t *apiClient, long petId, char *name, void
char *status); PetAPI_updatePetWithForm(apiClient_t *apiClient ,long petId ,char * name ,char * status);
// uploads an image // uploads an image
// //
api_response_t *PetAPI_uploadFile(apiClient_t *apiClient, long petId, api_response_t*
char *additionalMetadata, binary_t *file); PetAPI_uploadFile(apiClient_t *apiClient ,long petId ,char * additionalMetadata ,binary_t* file);

441
samples/client/petstore/c/api/StoreAPI.c
View File

@ -6,278 +6,283 @@
#define MAX_BUFFER_LENGTH 4096 #define MAX_BUFFER_LENGTH 4096
#define intToStr(dst, src) \ #define intToStr(dst, src) \
do { \ do {\
char dst[256]; \ char dst[256];\
snprintf(dst, 256, "%ld", (long int) (src)); \ snprintf(dst, 256, "%ld", (long int)(src));\
} while(0) }while(0)
// Delete purchase order by ID // Delete purchase order by ID
// //
// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors // 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
list_t *localVarQueryParameters = NULL; StoreAPI_deleteOrder(apiClient_t *apiClient ,char * orderId)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/store/order/{orderId}") + 1; long sizeOfPath = strlen("/store/order/{orderId}")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}"); snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}");
// Path Params // Path Params
long sizeOfPathParams_orderId = strlen(orderId) + 3 + strlen( long sizeOfPathParams_orderId = strlen(orderId)+3 + strlen("{ orderId }");
"{ orderId }"); if(orderId == NULL) {
if(orderId == NULL) { goto end;
goto end; }
} char* localVarToReplace_orderId = malloc(sizeOfPathParams_orderId);
char *localVarToReplace_orderId = malloc(sizeOfPathParams_orderId); sprintf(localVarToReplace_orderId, "{%s}", "orderId");
sprintf(localVarToReplace_orderId, "{%s}", "orderId");
localVarPath = strReplace(localVarPath, localVarToReplace_orderId, localVarPath = strReplace(localVarPath, localVarToReplace_orderId, orderId);
orderId);
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"DELETE"); "DELETE");
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid ID supplied"); printf("%s\n","Invalid ID supplied");
} }
if(apiClient->response_code == 404) { if (apiClient->response_code == 404) {
printf("%s\n", "Order not found"); printf("%s\n","Order not found");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
free(localVarPath);
free(localVarToReplace_orderId);
free(localVarPath);
free(localVarToReplace_orderId);
} }
// Returns pet inventories by status // Returns pet inventories by status
// //
// Returns a map of status codes to quantities // Returns a map of status codes to quantities
// //
list_t *StoreAPI_getInventory(apiClient_t *apiClient) { list_t*
list_t *localVarQueryParameters = NULL; StoreAPI_getInventory(apiClient_t *apiClient)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = list_create(); list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = list_create();
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/store/inventory") + 1; long sizeOfPath = strlen("/store/inventory")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/store/inventory"); snprintf(localVarPath, sizeOfPath, "/store/inventory");
list_addElement(localVarHeaderType, "application/json"); // produces list_addElement(localVarHeaderType,"application/json"); //produces
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"GET"); "GET");
if(apiClient->response_code == 200) { if (apiClient->response_code == 200) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
// primitive reutrn type not simple //primitive reutrn type not simple
cJSON *localVarJSON = cJSON_Parse(apiClient->dataReceived); cJSON *localVarJSON = cJSON_Parse(apiClient->dataReceived);
cJSON *VarJSON; cJSON *VarJSON;
list_t *elementToReturn = list_create(); list_t *elementToReturn = list_create();
cJSON_ArrayForEach(VarJSON, localVarJSON) { cJSON_ArrayForEach(VarJSON, localVarJSON){
keyValuePair_t *keyPair = keyValuePair_t *keyPair = keyValuePair_create(strdup(VarJSON->string), cJSON_Print(VarJSON));
keyValuePair_create(strdup( list_addElement(elementToReturn, keyPair);
VarJSON->string), cJSON_Print( }
VarJSON)); cJSON_Delete(localVarJSON);
list_addElement(elementToReturn, keyPair);
}
cJSON_Delete(localVarJSON);
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
list_free(localVarHeaderType); list_free(localVarHeaderType);
free(localVarPath); free(localVarPath);
return elementToReturn; return elementToReturn;
end: end:
return NULL; return NULL;
} }
// Find purchase order by ID // Find purchase order by ID
// //
// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions // 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*
list_t *localVarQueryParameters = NULL; StoreAPI_getOrderById(apiClient_t *apiClient ,long orderId)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = list_create(); list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = list_create();
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/store/order/{orderId}") + 1; long sizeOfPath = strlen("/store/order/{orderId}")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}"); snprintf(localVarPath, sizeOfPath, "/store/order/{orderId}");
// Path Params // Path Params
long sizeOfPathParams_orderId = sizeof(orderId) + 3 + strlen( long sizeOfPathParams_orderId = sizeof(orderId)+3 + strlen("{ orderId }");
"{ orderId }"); if(orderId == 0){
if(orderId == 0) { goto end;
goto end; }
} char* localVarToReplace_orderId = malloc(sizeOfPathParams_orderId);
char *localVarToReplace_orderId = malloc(sizeOfPathParams_orderId); snprintf(localVarToReplace_orderId, sizeOfPathParams_orderId, "{%s}", "orderId");
snprintf(localVarToReplace_orderId, sizeOfPathParams_orderId, "{%s}",
"orderId");
char localVarBuff_orderId[256]; char localVarBuff_orderId[256];
intToStr(localVarBuff_orderId, orderId); intToStr(localVarBuff_orderId, orderId);
localVarPath = strReplace(localVarPath, localVarToReplace_orderId, localVarPath = strReplace(localVarPath, localVarToReplace_orderId, localVarBuff_orderId);
localVarBuff_orderId);
list_addElement(localVarHeaderType, "application/xml"); // produces list_addElement(localVarHeaderType,"application/xml"); //produces
list_addElement(localVarHeaderType, "application/json"); // produces list_addElement(localVarHeaderType,"application/json"); //produces
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"GET"); "GET");
if(apiClient->response_code == 200) { if (apiClient->response_code == 200) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid ID supplied"); printf("%s\n","Invalid ID supplied");
} }
if(apiClient->response_code == 404) { if (apiClient->response_code == 404) {
printf("%s\n", "Order not found"); printf("%s\n","Order not found");
} }
// nonprimitive not container //nonprimitive not container
cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived);
order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON); order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON);
cJSON_Delete(StoreAPIlocalVarJSON); cJSON_Delete(StoreAPIlocalVarJSON);
if(elementToReturn == NULL) { if(elementToReturn == NULL) {
// return 0; // return 0;
} }
// return type //return type
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
list_free(localVarHeaderType); list_free(localVarHeaderType);
free(localVarPath); free(localVarPath);
free(localVarToReplace_orderId); free(localVarToReplace_orderId);
return elementToReturn; return elementToReturn;
end: end:
return NULL; return NULL;
} }
// Place an order for a pet // Place an order for a pet
// //
order_t *StoreAPI_placeOrder(apiClient_t *apiClient, order_t *body) { order_t*
list_t *localVarQueryParameters = NULL; StoreAPI_placeOrder(apiClient_t *apiClient ,order_t * body)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = list_create(); list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = list_create();
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/store/order") + 1; long sizeOfPath = strlen("/store/order")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/store/order"); snprintf(localVarPath, sizeOfPath, "/store/order");
// Body Param // Body Param
cJSON *localVarSingleItemJSON_body; cJSON *localVarSingleItemJSON_body;
if(body != NULL) { if (body != NULL)
// string {
localVarSingleItemJSON_body = order_convertToJSON(body); //string
localVarBodyParameters = localVarSingleItemJSON_body = order_convertToJSON(body);
cJSON_Print(localVarSingleItemJSON_body); localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body);
} }
list_addElement(localVarHeaderType, "application/xml"); // produces list_addElement(localVarHeaderType,"application/xml"); //produces
list_addElement(localVarHeaderType, "application/json"); // produces list_addElement(localVarHeaderType,"application/json"); //produces
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"POST"); "POST");
if(apiClient->response_code == 200) { if (apiClient->response_code == 200) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid Order"); printf("%s\n","Invalid Order");
} }
// nonprimitive not container //nonprimitive not container
cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); cJSON *StoreAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived);
order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON); order_t *elementToReturn = order_parseFromJSON(StoreAPIlocalVarJSON);
cJSON_Delete(StoreAPIlocalVarJSON); cJSON_Delete(StoreAPIlocalVarJSON);
if(elementToReturn == NULL) { if(elementToReturn == NULL) {
// return 0; // return 0;
} }
// return type //return type
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
list_free(localVarHeaderType); list_free(localVarHeaderType);
free(localVarPath); free(localVarPath);
cJSON_Delete(localVarSingleItemJSON_body); cJSON_Delete(localVarSingleItemJSON_body);
free(localVarBodyParameters); free(localVarBodyParameters);
return elementToReturn; return elementToReturn;
end: end:
return NULL; return NULL;
} }

14
samples/client/petstore/c/api/StoreAPI.h
View File

@ -11,23 +11,29 @@
// //
// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors // 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 pet inventories by status
// //
// Returns a map of status codes to quantities // 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 // Find purchase order by ID
// //
// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions // 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 // 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);

886
samples/client/petstore/c/api/UserAPI.c
View File

@ -6,546 +6,566 @@
#define MAX_BUFFER_LENGTH 4096 #define MAX_BUFFER_LENGTH 4096
#define intToStr(dst, src) \ #define intToStr(dst, src) \
do { \ do {\
char dst[256]; \ char dst[256];\
snprintf(dst, 256, "%ld", (long int) (src)); \ snprintf(dst, 256, "%ld", (long int)(src));\
} while(0) }while(0)
// Create user // Create user
// //
// This can only be done by the logged in user. // This can only be done by the logged in user.
// //
void UserAPI_createUser(apiClient_t *apiClient, user_t *body) { void
list_t *localVarQueryParameters = NULL; UserAPI_createUser(apiClient_t *apiClient ,user_t * body)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user") + 1; long sizeOfPath = strlen("/user")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user"); snprintf(localVarPath, sizeOfPath, "/user");
// Body Param // Body Param
cJSON *localVarSingleItemJSON_body; cJSON *localVarSingleItemJSON_body;
if(body != NULL) { if (body != NULL)
// string {
localVarSingleItemJSON_body = user_convertToJSON(body); //string
localVarBodyParameters = localVarSingleItemJSON_body = user_convertToJSON(body);
cJSON_Print(localVarSingleItemJSON_body); localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body);
} }
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"POST"); "POST");
if(apiClient->response_code == 0) { if (apiClient->response_code == 0) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(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 // Creates list of users with given input array
// //
void UserAPI_createUsersWithArrayInput(apiClient_t *apiClient, list_t *body) { void
list_t *localVarQueryParameters = NULL; UserAPI_createUsersWithArrayInput(apiClient_t *apiClient ,list_t * body)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/createWithArray") + 1; long sizeOfPath = strlen("/user/createWithArray")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/createWithArray"); snprintf(localVarPath, sizeOfPath, "/user/createWithArray");
// Body Param // Body Param
// notstring //notstring
cJSON *localVar_body; cJSON *localVar_body;
cJSON *localVarItemJSON_body; cJSON *localVarItemJSON_body;
cJSON *localVarSingleItemJSON_body; cJSON *localVarSingleItemJSON_body;
if(body != NULL) { if (body != NULL)
localVarItemJSON_body = cJSON_CreateObject(); {
localVarSingleItemJSON_body = cJSON_AddArrayToObject( localVarItemJSON_body = cJSON_CreateObject();
localVarItemJSON_body, "body"); localVarSingleItemJSON_body = cJSON_AddArrayToObject(localVarItemJSON_body, "body");
if(localVarSingleItemJSON_body == NULL) { if (localVarSingleItemJSON_body == NULL)
// nonprimitive container {
// nonprimitive container
goto end; goto end;
} }
} }
listEntry_t *bodyBodyListEntry; listEntry_t *bodyBodyListEntry;
list_ForEach(bodyBodyListEntry, body) list_ForEach(bodyBodyListEntry, body)
{ {
localVar_body = user_convertToJSON(bodyBodyListEntry->data); localVar_body = user_convertToJSON(bodyBodyListEntry->data);
if(localVar_body == NULL) { if(localVar_body == NULL)
goto end; {
} goto end;
cJSON_AddItemToArray(localVarSingleItemJSON_body, }
localVar_body); cJSON_AddItemToArray(localVarSingleItemJSON_body, localVar_body);
localVarBodyParameters = cJSON_Print(localVarItemJSON_body); localVarBodyParameters = cJSON_Print(localVarItemJSON_body);
} }
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"POST"); "POST");
if(apiClient->response_code == 0) { if (apiClient->response_code == 0) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(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 // Creates list of users with given input array
// //
void UserAPI_createUsersWithListInput(apiClient_t *apiClient, list_t *body) { void
list_t *localVarQueryParameters = NULL; UserAPI_createUsersWithListInput(apiClient_t *apiClient ,list_t * body)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/createWithList") + 1; long sizeOfPath = strlen("/user/createWithList")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/createWithList"); snprintf(localVarPath, sizeOfPath, "/user/createWithList");
// Body Param // Body Param
// notstring //notstring
cJSON *localVar_body; cJSON *localVar_body;
cJSON *localVarItemJSON_body; cJSON *localVarItemJSON_body;
cJSON *localVarSingleItemJSON_body; cJSON *localVarSingleItemJSON_body;
if(body != NULL) { if (body != NULL)
localVarItemJSON_body = cJSON_CreateObject(); {
localVarSingleItemJSON_body = cJSON_AddArrayToObject( localVarItemJSON_body = cJSON_CreateObject();
localVarItemJSON_body, "body"); localVarSingleItemJSON_body = cJSON_AddArrayToObject(localVarItemJSON_body, "body");
if(localVarSingleItemJSON_body == NULL) { if (localVarSingleItemJSON_body == NULL)
// nonprimitive container {
// nonprimitive container
goto end; goto end;
} }
} }
listEntry_t *bodyBodyListEntry; listEntry_t *bodyBodyListEntry;
list_ForEach(bodyBodyListEntry, body) list_ForEach(bodyBodyListEntry, body)
{ {
localVar_body = user_convertToJSON(bodyBodyListEntry->data); localVar_body = user_convertToJSON(bodyBodyListEntry->data);
if(localVar_body == NULL) { if(localVar_body == NULL)
goto end; {
} goto end;
cJSON_AddItemToArray(localVarSingleItemJSON_body, }
localVar_body); cJSON_AddItemToArray(localVarSingleItemJSON_body, localVar_body);
localVarBodyParameters = cJSON_Print(localVarItemJSON_body); localVarBodyParameters = cJSON_Print(localVarItemJSON_body);
} }
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"POST"); "POST");
if(apiClient->response_code == 0) { if (apiClient->response_code == 0) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(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 // Delete user
// //
// This can only be done by the logged in user. // This can only be done by the logged in user.
// //
void UserAPI_deleteUser(apiClient_t *apiClient, char *username) { void
list_t *localVarQueryParameters = NULL; UserAPI_deleteUser(apiClient_t *apiClient ,char * username)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/{username}") + 1; long sizeOfPath = strlen("/user/{username}")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/{username}"); snprintf(localVarPath, sizeOfPath, "/user/{username}");
// Path Params // Path Params
long sizeOfPathParams_username = strlen(username) + 3 + strlen( long sizeOfPathParams_username = strlen(username)+3 + strlen("{ username }");
"{ username }"); if(username == NULL) {
if(username == NULL) { goto end;
goto end; }
} char* localVarToReplace_username = malloc(sizeOfPathParams_username);
char *localVarToReplace_username = malloc(sizeOfPathParams_username); sprintf(localVarToReplace_username, "{%s}", "username");
sprintf(localVarToReplace_username, "{%s}", "username");
localVarPath = strReplace(localVarPath, localVarToReplace_username, localVarPath = strReplace(localVarPath, localVarToReplace_username, username);
username);
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"DELETE"); "DELETE");
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid username supplied"); printf("%s\n","Invalid username supplied");
} }
if(apiClient->response_code == 404) { if (apiClient->response_code == 404) {
printf("%s\n", "User not found"); printf("%s\n","User not found");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
free(localVarPath);
free(localVarToReplace_username);
free(localVarPath);
free(localVarToReplace_username);
} }
// Get user by user name // Get user by user name
// //
user_t *UserAPI_getUserByName(apiClient_t *apiClient, char *username) { user_t*
list_t *localVarQueryParameters = NULL; UserAPI_getUserByName(apiClient_t *apiClient ,char * username)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = list_create(); list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = list_create();
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/{username}") + 1; long sizeOfPath = strlen("/user/{username}")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/{username}"); snprintf(localVarPath, sizeOfPath, "/user/{username}");
// Path Params // Path Params
long sizeOfPathParams_username = strlen(username) + 3 + strlen( long sizeOfPathParams_username = strlen(username)+3 + strlen("{ username }");
"{ username }"); if(username == NULL) {
if(username == NULL) { goto end;
goto end; }
} char* localVarToReplace_username = malloc(sizeOfPathParams_username);
char *localVarToReplace_username = malloc(sizeOfPathParams_username); sprintf(localVarToReplace_username, "{%s}", "username");
sprintf(localVarToReplace_username, "{%s}", "username");
localVarPath = strReplace(localVarPath, localVarToReplace_username, localVarPath = strReplace(localVarPath, localVarToReplace_username, username);
username);
list_addElement(localVarHeaderType, "application/xml"); // produces list_addElement(localVarHeaderType,"application/xml"); //produces
list_addElement(localVarHeaderType, "application/json"); // produces list_addElement(localVarHeaderType,"application/json"); //produces
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"GET"); "GET");
if(apiClient->response_code == 200) { if (apiClient->response_code == 200) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid username supplied"); printf("%s\n","Invalid username supplied");
} }
if(apiClient->response_code == 404) { if (apiClient->response_code == 404) {
printf("%s\n", "User not found"); printf("%s\n","User not found");
} }
// nonprimitive not container //nonprimitive not container
cJSON *UserAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived); cJSON *UserAPIlocalVarJSON = cJSON_Parse(apiClient->dataReceived);
user_t *elementToReturn = user_parseFromJSON(UserAPIlocalVarJSON); user_t *elementToReturn = user_parseFromJSON(UserAPIlocalVarJSON);
cJSON_Delete(UserAPIlocalVarJSON); cJSON_Delete(UserAPIlocalVarJSON);
if(elementToReturn == NULL) { if(elementToReturn == NULL) {
// return 0; // return 0;
} }
// return type //return type
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
list_free(localVarHeaderType); list_free(localVarHeaderType);
free(localVarPath); free(localVarPath);
free(localVarToReplace_username); free(localVarToReplace_username);
return elementToReturn; return elementToReturn;
end: end:
return NULL; return NULL;
} }
// Logs user into the system // Logs user into the system
// //
char *UserAPI_loginUser(apiClient_t *apiClient, char *username, char*
char *password) { UserAPI_loginUser(apiClient_t *apiClient ,char * username ,char * password)
list_t *localVarQueryParameters = list_create(); {
list_t *localVarHeaderParameters = NULL; list_t *localVarQueryParameters = list_create();
list_t *localVarFormParameters = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarHeaderType = list_create(); list_t *localVarFormParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarHeaderType = list_create();
char *localVarBodyParameters = NULL; list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/login") + 1; long sizeOfPath = strlen("/user/login")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/login"); snprintf(localVarPath, sizeOfPath, "/user/login");
// query parameters // query parameters
char *keyQuery_username; char *keyQuery_username;
char *valueQuery_username; char * valueQuery_username;
keyValuePair_t *keyPairQuery_username = 0; keyValuePair_t *keyPairQuery_username = 0;
if(username) { if (username)
keyQuery_username = strdup("username"); {
valueQuery_username = strdup((username)); keyQuery_username = strdup("username");
keyPairQuery_username = keyValuePair_create(keyQuery_username, valueQuery_username = strdup((username));
valueQuery_username); keyPairQuery_username = keyValuePair_create(keyQuery_username, valueQuery_username);
list_addElement(localVarQueryParameters, keyPairQuery_username); list_addElement(localVarQueryParameters,keyPairQuery_username);
} }
// query parameters // query parameters
char *keyQuery_password; char *keyQuery_password;
char *valueQuery_password; char * valueQuery_password;
keyValuePair_t *keyPairQuery_password = 0; keyValuePair_t *keyPairQuery_password = 0;
if(password) { if (password)
keyQuery_password = strdup("password"); {
valueQuery_password = strdup((password)); keyQuery_password = strdup("password");
keyPairQuery_password = keyValuePair_create(keyQuery_password, valueQuery_password = strdup((password));
valueQuery_password); keyPairQuery_password = keyValuePair_create(keyQuery_password, valueQuery_password);
list_addElement(localVarQueryParameters, keyPairQuery_password); list_addElement(localVarQueryParameters,keyPairQuery_password);
} }
list_addElement(localVarHeaderType, "application/xml"); // produces list_addElement(localVarHeaderType,"application/xml"); //produces
list_addElement(localVarHeaderType, "application/json"); // produces list_addElement(localVarHeaderType,"application/json"); //produces
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"GET"); "GET");
if(apiClient->response_code == 200) { if (apiClient->response_code == 200) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid username/password supplied"); printf("%s\n","Invalid username/password supplied");
} }
// primitive reutrn type simple //primitive reutrn type simple
char *elementToReturn = strdup((char *) apiClient->dataReceived); char* elementToReturn = strdup((char*)apiClient->dataReceived);
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
list_free(localVarQueryParameters); list_free(localVarQueryParameters);
list_free(localVarHeaderType); list_free(localVarHeaderType);
free(localVarPath); free(localVarPath);
free(keyQuery_username); free(keyQuery_username);
free(valueQuery_username); free(valueQuery_username);
keyValuePair_free(keyPairQuery_username); keyValuePair_free(keyPairQuery_username);
free(keyQuery_password); free(keyQuery_password);
free(valueQuery_password); free(valueQuery_password);
keyValuePair_free(keyPairQuery_password); keyValuePair_free(keyPairQuery_password);
return elementToReturn; return elementToReturn;
end: end:
return NULL; return NULL;
} }
// Logs out current logged in user session // Logs out current logged in user session
// //
void UserAPI_logoutUser(apiClient_t *apiClient) { void
list_t *localVarQueryParameters = NULL; UserAPI_logoutUser(apiClient_t *apiClient)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/logout") + 1; long sizeOfPath = strlen("/user/logout")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/logout"); snprintf(localVarPath, sizeOfPath, "/user/logout");
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"GET"); "GET");
if(apiClient->response_code == 0) { if (apiClient->response_code == 0) {
printf("%s\n", "successful operation"); printf("%s\n","successful operation");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(apiClient->dataReceived); free(apiClient->dataReceived);
} }
free(localVarPath);
free(localVarPath);
} }
// Updated user // Updated user
// //
// This can only be done by the logged in user. // This can only be done by the logged in user.
// //
void UserAPI_updateUser(apiClient_t *apiClient, char *username, user_t *body) { void
list_t *localVarQueryParameters = NULL; UserAPI_updateUser(apiClient_t *apiClient ,char * username ,user_t * body)
list_t *localVarHeaderParameters = NULL; {
list_t *localVarFormParameters = NULL; list_t *localVarQueryParameters = NULL;
list_t *localVarHeaderType = NULL; list_t *localVarHeaderParameters = NULL;
list_t *localVarContentType = NULL; list_t *localVarFormParameters = NULL;
char *localVarBodyParameters = NULL; list_t *localVarHeaderType = NULL;
list_t *localVarContentType = NULL;
char *localVarBodyParameters = NULL;
// create the path // create the path
long sizeOfPath = strlen("/user/{username}") + 1; long sizeOfPath = strlen("/user/{username}")+1;
char *localVarPath = malloc(sizeOfPath); char *localVarPath = malloc(sizeOfPath);
snprintf(localVarPath, sizeOfPath, "/user/{username}"); snprintf(localVarPath, sizeOfPath, "/user/{username}");
// Path Params // Path Params
long sizeOfPathParams_username = strlen(username) + 3 + strlen( long sizeOfPathParams_username = strlen(username)+3 + strlen("{ username }");
"{ username }"); if(username == NULL) {
if(username == NULL) { goto end;
goto end; }
} char* localVarToReplace_username = malloc(sizeOfPathParams_username);
char *localVarToReplace_username = malloc(sizeOfPathParams_username); sprintf(localVarToReplace_username, "{%s}", "username");
sprintf(localVarToReplace_username, "{%s}", "username");
localVarPath = strReplace(localVarPath, localVarToReplace_username, localVarPath = strReplace(localVarPath, localVarToReplace_username, username);
username);
// Body Param // Body Param
cJSON *localVarSingleItemJSON_body; cJSON *localVarSingleItemJSON_body;
if(body != NULL) { if (body != NULL)
// string {
localVarSingleItemJSON_body = user_convertToJSON(body); //string
localVarBodyParameters = localVarSingleItemJSON_body = user_convertToJSON(body);
cJSON_Print(localVarSingleItemJSON_body); localVarBodyParameters = cJSON_Print(localVarSingleItemJSON_body);
} }
apiClient_invoke(apiClient, apiClient_invoke(apiClient,
localVarPath, localVarPath,
localVarQueryParameters, localVarQueryParameters,
localVarHeaderParameters, localVarHeaderParameters,
localVarFormParameters, localVarFormParameters,
localVarHeaderType, localVarHeaderType,
localVarContentType, localVarContentType,
localVarBodyParameters, localVarBodyParameters,
"PUT"); "PUT");
if(apiClient->response_code == 400) { if (apiClient->response_code == 400) {
printf("%s\n", "Invalid user supplied"); printf("%s\n","Invalid user supplied");
} }
if(apiClient->response_code == 404) { if (apiClient->response_code == 404) {
printf("%s\n", "User not found"); printf("%s\n","User not found");
} }
// No return type //No return type
end: end:
if(apiClient->dataReceived) { if (apiClient->dataReceived) {
free(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);
} }

26
samples/client/petstore/c/api/UserAPI.h
View File

@ -11,43 +11,53 @@
// //
// This can only be done by the logged in user. // 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 // 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 // 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 // Delete user
// //
// This can only be done by the logged in 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 // 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 // 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 // Logs out current logged in user session
// //
void UserAPI_logoutUser(apiClient_t *apiClient); void
UserAPI_logoutUser(apiClient_t *apiClient);
// Updated user // Updated user
// //
// This can only be done by the logged in 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);

4333
samples/client/petstore/c/external/cJSON.c vendored
View File

File diff suppressed because it is too large Load Diff

282
samples/client/petstore/c/external/cJSON.h vendored
View File

@ -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 Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions: furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software. all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 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 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. THE SOFTWARE.
*/ */
#ifndef cJSON__h #ifndef cJSON__h
#define cJSON__h #define cJSON__h
@ -37,94 +37,87 @@ extern "C"
/* cJSON Types: */ /* cJSON Types: */
#define cJSON_Invalid (0) #define cJSON_Invalid (0)
#define cJSON_False (1 << 0) #define cJSON_False (1 << 0)
#define cJSON_True (1 << 1) #define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2) #define cJSON_NULL (1 << 2)
#define cJSON_Number (1 << 3) #define cJSON_Number (1 << 3)
#define cJSON_String (1 << 4) #define cJSON_String (1 << 4)
#define cJSON_Array (1 << 5) #define cJSON_Array (1 << 5)
#define cJSON_Object (1 << 6) #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_IsReference 256
#define cJSON_StringIsConst 512 #define cJSON_StringIsConst 512
/* The cJSON structure: */ /* The cJSON structure: */
typedef struct cJSON { typedef struct cJSON
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ {
struct cJSON *next; /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
struct cJSON *prev; struct cJSON *next;
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ struct cJSON *prev;
struct cJSON *child; /* 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. */ /* The type of the item, as above. */
int type; int type;
/* The item's string, if type==cJSON_String and type == cJSON_Raw */ /* The item's string, if type==cJSON_String and type == cJSON_Raw */
char *valuestring; char *valuestring;
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
int valueint; int valueint;
/* The item's number, if type==cJSON_Number */ /* The item's number, if type==cJSON_Number */
double valuedouble; double valuedouble;
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
char *string; char *string;
} cJSON; } cJSON;
typedef struct cJSON_Hooks { typedef struct cJSON_Hooks
void *(*malloc_fn)(size_t sz); {
void (*free_fn)(void *ptr); void *(*malloc_fn)(size_t sz);
void (*free_fn)(void *ptr);
} cJSON_Hooks; } cJSON_Hooks;
typedef int cJSON_bool; typedef int cJSON_bool;
#if !defined(__WINDOWS__) && \ #if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
(defined(WIN32) || \
defined(WIN64) || \
defined(_MSC_VER) || \
defined(_WIN32))
#define __WINDOWS__ #define __WINDOWS__
#endif #endif
#ifdef __WINDOWS__ #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: /* 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_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_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_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 setting default visibility to hidden by adding
-fvisibility=hidden (for gcc) -fvisibility=hidden (for gcc)
or or
-xldscope=hidden (for sun cc) -xldscope=hidden (for sun cc)
to CFLAGS 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 */ /* export symbols by default, this is necessary for copy pasting the C and header file */
#if !defined(CJSON_HIDE_SYMBOLS) && \ #if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
!defined(CJSON_IMPORT_SYMBOLS) && \
!defined(CJSON_EXPORT_SYMBOLS)
#define CJSON_EXPORT_SYMBOLS #define CJSON_EXPORT_SYMBOLS
#endif #endif
#if defined(CJSON_HIDE_SYMBOLS) #if defined(CJSON_HIDE_SYMBOLS)
#define CJSON_PUBLIC(type) type __stdcall #define CJSON_PUBLIC(type) type __stdcall
#elif defined(CJSON_EXPORT_SYMBOLS) #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) #elif defined(CJSON_IMPORT_SYMBOLS)
#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall #define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall
#endif #endif
#else /* !WIN32 */ #else /* !WIN32 */
#if (defined(__GNUC__) || \ #if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
defined(__SUNPRO_CC) || \ #define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
defined(__SUNPRO_C)) && \
defined(CJSON_API_VISIBILITY)
#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
#else #else
#define CJSON_PUBLIC(type) type #define CJSON_PUBLIC(type) type
#endif #endif
@ -137,51 +130,43 @@ typedef int cJSON_bool;
#endif #endif
/* returns the version of cJSON as a string */ /* 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 */ /* 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. */ /* 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. */ /* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); 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. */ /* 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(). */ /* 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, CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
const char **return_parse_end,
cJSON_bool require_null_terminated);
/* Render a cJSON entity to text for transfer/storage. */ /* 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. */ /* 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 */ /* 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_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
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. */ /* 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 */ /* 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, CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
const int length,
const cJSON_bool format);
/* Delete a cJSON entity and all subentities. */ /* 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). */ /* 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. */ /* 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. */ /* Get item "string" from object. Case insensitive. */
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
const char *const string); CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive( CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
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. */ /* 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); CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
/* Check if the item is a string and return its valuestring */ /* 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 */ /* These functions check the type of an item */
CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const 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); CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
/* Create an object/arrray that only references it's elements so /* Create an object/arrray that only references it's elements so
* they will not be freed by cJSON_Delete */ * they will not be freed by cJSON_Delete */
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON * child); CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON * child); CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
/* These utilities create an Array of count items. */ /* These utilities create an Array of count items. */
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); 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); CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count);
/* Append item to the specified array/object. */ /* Append item to the specified array/object. */
CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON * array, cJSON * item); CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item);
CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON * object, const char *string, CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
cJSON * item);
/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. /* 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 * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
* writing to `item->string` */ * writing to `item->string` */
CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON * object, const char *string, CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
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. */ /* 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_AddItemReferenceToArray(cJSON *array, cJSON *item);
CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON * object, CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
const char *string,
cJSON * item);
/* Remove/Detatch items from Arrays/Objects. */ /* Remove/Detatch items from Arrays/Objects. */
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON * parent, CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
cJSON * const item); CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON * array, int which); CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(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_DetachItemFromObject(cJSON * object, CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
const char *string); CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON * object, CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
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. */ /* Update array items. */
CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON * array, int which, CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
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(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
cJSON * const item, CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
cJSON * replacement); CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
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 */ /* 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 /* 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. 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. */ 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. /* 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) */ * 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, CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
const cJSON * const b,
const cJSON_bool case_sensitive);
CJSON_PUBLIC(void) cJSON_Minify(char *json); CJSON_PUBLIC(void) cJSON_Minify(char *json);
/* Helper functions for creating and adding items to an object at the same time. /* Helper functions for creating and adding items to an object at the same time.
* They return the added item or NULL on failure. */ * They return the added item or NULL on failure. */
CJSON_PUBLIC(cJSON *) cJSON_AddNullToObject(cJSON * const object, CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
const char *const name); CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON *) cJSON_AddTrueToObject(cJSON * const object, CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
const char *const name); CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
CJSON_PUBLIC(cJSON *) cJSON_AddFalseToObject(cJSON * const object, CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
const char *const name); CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
CJSON_PUBLIC(cJSON *) cJSON_AddBoolToObject(cJSON * const object, CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
const char *const name, CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
const cJSON_bool boolean); CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
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. */ /* When assigning an integer value, it needs to be propagated to valuedouble too. */
#define cJSON_SetIntValue(object, \ #define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
number) ((object) ? (object)->valueint = \
(object)->valuedouble = \
(number) : (number))
/* helper for the cJSON_SetNumberValue macro */ /* helper for the cJSON_SetNumberValue macro */
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON * object, double number); CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
#define cJSON_SetNumberValue(object, \ #define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
number) ((object != \
NULL) ? cJSON_SetNumberHelper(object, \
( \
double) \
number) : ( \
number))
/* Macro for iterating over an array or object */ /* Macro for iterating over an array or object */
#define cJSON_ArrayForEach(element, array) for(element = \ #define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
(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 */ /* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
CJSON_PUBLIC(void *) cJSON_malloc(size_t size); CJSON_PUBLIC(void *) cJSON_malloc(size_t size);

25
samples/client/petstore/c/include/apiClient.h
View File

@ -10,27 +10,24 @@
#include "../include/keyValuePair.h" #include "../include/keyValuePair.h"
typedef struct apiClient_t { typedef struct apiClient_t {
char *basePath; char *basePath;
void *dataReceived; void *dataReceived;
long response_code; long response_code;
list_t *apiKeys; list_t *apiKeys;
char *accessToken; char *accessToken;
} apiClient_t; } apiClient_t;
typedef struct binary_t { typedef struct binary_t
uint8_t *data; {
unsigned int len; uint8_t* data;
unsigned int len;
} binary_t; } binary_t;
apiClient_t *apiClient_create(); apiClient_t* apiClient_create();
void apiClient_free(apiClient_t *apiClient); void apiClient_free(apiClient_t *apiClient);
void apiClient_invoke(apiClient_t *apiClient, char *operationParameter, 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);
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); char *strReplace(char *orig, char *rep, char *with);

6
samples/client/petstore/c/include/keyValuePair.h
View File

@ -1,11 +1,11 @@
#ifndef _keyValuePair_H_ #ifndef _keyValuePair_H_
#define _keyValuePair_H_ #define _keyValuePair_H_
#include <string.h> #include<string.h>
typedef struct keyValuePair_t { typedef struct keyValuePair_t {
char *key; char* key;
void *value; void* value;
} keyValuePair_t; } keyValuePair_t;
keyValuePair_t *keyValuePair_create(char *key, void *value); keyValuePair_t *keyValuePair_create(char *key, void *value);

41
samples/client/petstore/c/include/list.h
View File

@ -9,40 +9,31 @@ typedef struct list_t list_t;
typedef struct listEntry_t listEntry_t; typedef struct listEntry_t listEntry_t;
struct listEntry_t { struct listEntry_t {
listEntry_t *nextListEntry; listEntry_t* nextListEntry;
listEntry_t *prevListEntry; listEntry_t* prevListEntry;
void *data; void* data;
}; };
typedef struct list_t { typedef struct list_t {
listEntry_t *firstEntry; listEntry_t *firstEntry;
listEntry_t *lastEntry; listEntry_t *lastEntry;
long count; long count;
} list_t; } list_t;
#define list_ForEach(element, list) for(element = \ #define list_ForEach(element, list) for(element = (list != NULL) ? (list)->firstEntry : NULL; element != NULL; element = element->nextListEntry)
(list != \
NULL) ? (list)->firstEntry : \
NULL; \
element != NULL; \
element = element->nextListEntry)
list_t *list_create(); list_t* list_create();
void list_free(list_t *listToFree); void list_free(list_t* listToFree);
void list_addElement(list_t *list, void *dataToAddInList); void list_addElement(list_t* list, void* dataToAddInList);
listEntry_t *list_getElementAt(list_t *list, long indexOfElement); listEntry_t* list_getElementAt(list_t *list, long indexOfElement);
listEntry_t *list_getWithIndex(list_t *list, int index); listEntry_t* list_getWithIndex(list_t* list, int index);
void list_removeElement(list_t *list, listEntry_t *elementToRemove); void list_removeElement(list_t* list, listEntry_t* elementToRemove);
void list_iterateThroughListForward(list_t *list, void (*operationToPerform)( void list_iterateThroughListForward(list_t* list, void (*operationToPerform)(listEntry_t*, void*), void *additionalDataNeededForCallbackFunction);
listEntry_t *, void list_iterateThroughListBackward(list_t* list, void (*operationToPerform)(listEntry_t*, void*), void *additionalDataNeededForCallbackFunction);
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); void listEntry_free(listEntry_t *listEntry, void *additionalData);
#endif // INCLUDE_LIST_H #endif // INCLUDE_LIST_H

152
samples/client/petstore/c/model/api_response.c
View File

@ -5,104 +5,104 @@
api_response_t *api_response_create(int code, char *type, char *message) { api_response_t *api_response_create(
api_response_t *api_response_local_var = malloc(sizeof(api_response_t)); int code,
if(!api_response_local_var) { char *type,
return NULL; char *message
} ) {
api_response_local_var->code = code; api_response_t *api_response_local_var = malloc(sizeof(api_response_t));
api_response_local_var->type = type; if (!api_response_local_var) {
api_response_local_var->message = message; 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) { void api_response_free(api_response_t *api_response) {
listEntry_t *listEntry; listEntry_t *listEntry;
free(api_response->type); free(api_response->type);
free(api_response->message); free(api_response->message);
free(api_response); free(api_response);
} }
cJSON *api_response_convertToJSON(api_response_t *api_response) { cJSON *api_response_convertToJSON(api_response_t *api_response) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
// api_response->code // api_response->code
if(api_response->code) { if(api_response->code) {
if(cJSON_AddNumberToObject(item, "code", if(cJSON_AddNumberToObject(item, "code", api_response->code) == NULL) {
api_response->code) == NULL) goto fail; //Numeric
{ }
goto fail; // Numeric }
}
}
// api_response->type // api_response->type
if(api_response->type) { if(api_response->type) {
if(cJSON_AddStringToObject(item, "type", if(cJSON_AddStringToObject(item, "type", api_response->type) == NULL) {
api_response->type) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// api_response->message // api_response->message
if(api_response->message) { if(api_response->message) {
if(cJSON_AddStringToObject(item, "message", if(cJSON_AddStringToObject(item, "message", api_response->message) == NULL) {
api_response->message) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
return item; return item;
fail: fail:
if(item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
api_response_t *api_response_parseFromJSON(cJSON *api_responseJSON) { api_response_t *api_response_parseFromJSON(cJSON *api_responseJSON){
api_response_t *api_response_local_var = NULL;
// api_response->code api_response_t *api_response_local_var = NULL;
cJSON *code =
cJSON_GetObjectItemCaseSensitive(api_responseJSON, "code");
if(code) {
if(!cJSON_IsNumber(code)) {
goto end; // Numeric
}
}
// api_response->type // api_response->code
cJSON *type = cJSON *code = cJSON_GetObjectItemCaseSensitive(api_responseJSON, "code");
cJSON_GetObjectItemCaseSensitive(api_responseJSON, "type"); if (code) {
if(type) { if(!cJSON_IsNumber(code))
if(!cJSON_IsString(type)) { {
goto end; // String goto end; //Numeric
} }
} }
// api_response->message // api_response->type
cJSON *message = cJSON_GetObjectItemCaseSensitive(api_responseJSON, cJSON *type = cJSON_GetObjectItemCaseSensitive(api_responseJSON, "type");
"message"); if (type) {
if(message) { if(!cJSON_IsString(type))
if(!cJSON_IsString(message)) { {
goto end; // String 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( api_response_local_var = api_response_create (
code ? code->valuedouble : 0, code ? code->valuedouble : 0,
type ? strdup(type->valuestring) : NULL, type ? strdup(type->valuestring) : NULL,
message ? strdup(message->valuestring) : NULL message ? strdup(message->valuestring) : NULL
); );
return api_response_local_var; return api_response_local_var;
end: end:
return NULL; return NULL;
} }

14
samples/client/petstore/c/model/api_response.h
View File

@ -15,12 +15,17 @@
typedef struct api_response_t { typedef struct api_response_t {
int code; // numeric int code; //numeric
char *type; // string char *type; // string
char *message; // string char *message; // string
} api_response_t; } 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); 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); cJSON *api_response_convertToJSON(api_response_t *api_response);
#endif /* _api_response_H_ */ #endif /* _api_response_H_ */

111
samples/client/petstore/c/model/category.c
View File

@ -5,78 +5,83 @@
category_t *category_create(long id, char *name) { category_t *category_create(
category_t *category_local_var = malloc(sizeof(category_t)); long id,
if(!category_local_var) { char *name
return NULL; ) {
} category_t *category_local_var = malloc(sizeof(category_t));
category_local_var->id = id; if (!category_local_var) {
category_local_var->name = name; 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) { void category_free(category_t *category) {
listEntry_t *listEntry; listEntry_t *listEntry;
free(category->name); free(category->name);
free(category); free(category);
} }
cJSON *category_convertToJSON(category_t *category) { cJSON *category_convertToJSON(category_t *category) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
// category->id // category->id
if(category->id) { if(category->id) {
if(cJSON_AddNumberToObject(item, "id", category->id) == NULL) { if(cJSON_AddNumberToObject(item, "id", category->id) == NULL) {
goto fail; // Numeric goto fail; //Numeric
} }
} }
// category->name // category->name
if(category->name) { if(category->name) {
if(cJSON_AddStringToObject(item, "name", if(cJSON_AddStringToObject(item, "name", category->name) == NULL) {
category->name) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
return item; return item;
fail: fail:
if(item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
category_t *category_parseFromJSON(cJSON *categoryJSON) { category_t *category_parseFromJSON(cJSON *categoryJSON){
category_t *category_local_var = NULL;
// category->id category_t *category_local_var = NULL;
cJSON *id = cJSON_GetObjectItemCaseSensitive(categoryJSON, "id");
if(id) {
if(!cJSON_IsNumber(id)) {
goto end; // Numeric
}
}
// category->name // category->id
cJSON *name = cJSON_GetObjectItemCaseSensitive(categoryJSON, "name"); cJSON *id = cJSON_GetObjectItemCaseSensitive(categoryJSON, "id");
if(name) { if (id) {
if(!cJSON_IsString(name)) { if(!cJSON_IsNumber(id))
goto end; // String {
} 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( category_local_var = category_create (
id ? id->valuedouble : 0, id ? id->valuedouble : 0,
name ? strdup(name->valuestring) : NULL name ? strdup(name->valuestring) : NULL
); );
return category_local_var; return category_local_var;
end: end:
return NULL; return NULL;
} }

11
samples/client/petstore/c/model/category.h
View File

@ -15,11 +15,15 @@
typedef struct category_t { typedef struct category_t {
long id; // numeric long id; //numeric
char *name; // string char *name; // string
} category_t; } category_t;
category_t *category_create(long id, char *name); category_t *category_create(
long id,
char *name
);
void category_free(category_t *category); void category_free(category_t *category);
@ -28,3 +32,4 @@ category_t *category_parseFromJSON(cJSON *categoryJSON);
cJSON *category_convertToJSON(category_t *category); cJSON *category_convertToJSON(category_t *category);
#endif /* _category_H_ */ #endif /* _category_H_ */

22
samples/client/petstore/c/model/object.c
View File

@ -4,28 +4,28 @@
#include "object.h" #include "object.h"
object_t *object_create() { 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) { void object_free(object_t *object) {
free(object); free (object);
} }
cJSON *object_convertToJSON(object_t *object) { cJSON *object_convertToJSON(object_t *object) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
return item; return item;
fail: fail:
cJSON_Delete(item); cJSON_Delete(item);
return NULL; return NULL;
} }
object_t *object_parseFromJSON(char *jsonString) { object_t *object_parseFromJSON(char *jsonString){
object_t *object = NULL; object_t *object = NULL;
return object; return object;
end: end:
return NULL; return NULL;
} }

2
samples/client/petstore/c/model/object.h
View File

@ -12,7 +12,7 @@
typedef struct object_t { typedef struct object_t {
void *temporary; void *temporary;
} object_t; } object_t;
object_t *object_create(); object_t *object_create();

288
samples/client/petstore/c/model/order.c
View File

@ -4,182 +4,184 @@
#include "order.h" #include "order.h"
char *statusorder_ToString(status_e status) { char* statusorder_ToString(status_e status){
char *statusArray[] = { "placed", "approved", "delivered" }; char *statusArray[] = { "placed","approved","delivered" };
return statusArray[status]; return statusArray[status];
} }
status_e statusorder_FromString(char *status) { status_e statusorder_FromString(char* status){
int stringToReturn = 0; int stringToReturn = 0;
char *statusArray[] = { "placed", "approved", "delivered" }; char *statusArray[] = { "placed","approved","delivered" };
size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]); size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]);
while(stringToReturn < sizeofArray) { while(stringToReturn < sizeofArray) {
if(strcmp(status, statusArray[stringToReturn]) == 0) { if(strcmp(status, statusArray[stringToReturn]) == 0) {
return stringToReturn; return stringToReturn;
} }
stringToReturn++; stringToReturn++;
} }
return 0; return 0;
} }
order_t *order_create(long id, long petId, int quantity, char *shipDate, order_t *order_create(
status_e status, int complete) { long id,
order_t *order_local_var = malloc(sizeof(order_t)); long petId,
if(!order_local_var) { int quantity,
return NULL; char *shipDate,
} status_e status,
order_local_var->id = id; int complete
order_local_var->petId = petId; ) {
order_local_var->quantity = quantity; order_t *order_local_var = malloc(sizeof(order_t));
order_local_var->shipDate = shipDate; if (!order_local_var) {
order_local_var->status = status; return NULL;
order_local_var->complete = complete; }
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) { void order_free(order_t *order) {
listEntry_t *listEntry; listEntry_t *listEntry;
free(order->shipDate); free(order->shipDate);
free(order); free(order);
} }
cJSON *order_convertToJSON(order_t *order) { cJSON *order_convertToJSON(order_t *order) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
// order->id // order->id
if(order->id) { if(order->id) {
if(cJSON_AddNumberToObject(item, "id", order->id) == NULL) { if(cJSON_AddNumberToObject(item, "id", order->id) == NULL) {
goto fail; // Numeric goto fail; //Numeric
} }
} }
// order->petId // order->petId
if(order->petId) { if(order->petId) {
if(cJSON_AddNumberToObject(item, "petId", if(cJSON_AddNumberToObject(item, "petId", order->petId) == NULL) {
order->petId) == NULL) goto fail; //Numeric
{ }
goto fail; // Numeric }
}
}
// order->quantity // order->quantity
if(order->quantity) { if(order->quantity) {
if(cJSON_AddNumberToObject(item, "quantity", if(cJSON_AddNumberToObject(item, "quantity", order->quantity) == NULL) {
order->quantity) == NULL) goto fail; //Numeric
{ }
goto fail; // Numeric }
}
}
// order->shipDate // order->shipDate
if(order->shipDate) { if(order->shipDate) {
if(cJSON_AddStringToObject(item, "shipDate", if(cJSON_AddStringToObject(item, "shipDate", order->shipDate) == NULL) {
order->shipDate) == NULL) goto fail; //Date-Time
{ }
goto fail; // Date-Time }
}
}
// order->status // order->status
if(cJSON_AddStringToObject(item, "status", if(cJSON_AddStringToObject(item, "status", statusorder_ToString(order->status)) == NULL)
statusorder_ToString(order->status)) == NULL) {
{ goto fail; //Enum
goto fail; // Enum }
}
// order->complete
if(order->complete) {
if(cJSON_AddBoolToObject(item, "complete", order->complete) == NULL) {
goto fail; //Bool
}
}
// order->complete return item;
if(order->complete) {
if(cJSON_AddBoolToObject(item, "complete",
order->complete) == NULL)
{
goto fail; // Bool
}
}
return item;
fail: fail:
if(item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
order_t *order_parseFromJSON(cJSON *orderJSON) { order_t *order_parseFromJSON(cJSON *orderJSON){
order_t *order_local_var = NULL;
// order->id order_t *order_local_var = NULL;
cJSON *id = cJSON_GetObjectItemCaseSensitive(orderJSON, "id");
if(id) {
if(!cJSON_IsNumber(id)) {
goto end; // Numeric
}
}
// order->petId // order->id
cJSON *petId = cJSON_GetObjectItemCaseSensitive(orderJSON, "petId"); cJSON *id = cJSON_GetObjectItemCaseSensitive(orderJSON, "id");
if(petId) { if (id) {
if(!cJSON_IsNumber(petId)) { if(!cJSON_IsNumber(id))
goto end; // Numeric {
} goto end; //Numeric
} }
}
// order->quantity // order->petId
cJSON *quantity = cJSON *petId = cJSON_GetObjectItemCaseSensitive(orderJSON, "petId");
cJSON_GetObjectItemCaseSensitive(orderJSON, "quantity"); if (petId) {
if(quantity) { if(!cJSON_IsNumber(petId))
if(!cJSON_IsNumber(quantity)) { {
goto end; // Numeric goto end; //Numeric
} }
} }
// order->shipDate // order->quantity
cJSON *shipDate = cJSON *quantity = cJSON_GetObjectItemCaseSensitive(orderJSON, "quantity");
cJSON_GetObjectItemCaseSensitive(orderJSON, "shipDate"); if (quantity) {
if(shipDate) { if(!cJSON_IsNumber(quantity))
if(!cJSON_IsString(shipDate)) { {
goto end; // DateTime goto end; //Numeric
} }
} }
// order->status // order->shipDate
cJSON *status = cJSON_GetObjectItemCaseSensitive(orderJSON, "status"); cJSON *shipDate = cJSON_GetObjectItemCaseSensitive(orderJSON, "shipDate");
status_e statusVariable; if (shipDate) {
if(status) { if(!cJSON_IsString(shipDate))
if(!cJSON_IsString(status)) { {
goto end; // Enum goto end; //DateTime
} }
statusVariable = statusorder_FromString(status->valuestring); }
}
// order->complete // order->status
cJSON *complete = cJSON *status = cJSON_GetObjectItemCaseSensitive(orderJSON, "status");
cJSON_GetObjectItemCaseSensitive(orderJSON, "complete"); status_e statusVariable;
if(complete) { if (status) {
if(!cJSON_IsBool(complete)) { if(!cJSON_IsString(status))
goto end; // Bool {
} 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( order_local_var = order_create (
id ? id->valuedouble : 0, id ? id->valuedouble : 0,
petId ? petId->valuedouble : 0, petId ? petId->valuedouble : 0,
quantity ? quantity->valuedouble : 0, quantity ? quantity->valuedouble : 0,
shipDate ? strdup(shipDate->valuestring) : NULL, shipDate ? strdup(shipDate->valuestring) : NULL,
status ? statusVariable : -1, status ? statusVariable : -1,
complete ? complete->valueint : 0 complete ? complete->valueint : 0
); );
return order_local_var; return order_local_var;
end: end:
return NULL; return NULL;
} }

30
samples/client/petstore/c/model/order.h
View File

@ -12,24 +12,31 @@
#include "../include/list.h" #include "../include/list.h"
#include "../include/keyValuePair.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 { typedef struct order_t {
long id; // numeric long id; //numeric
long petId; // numeric long petId; //numeric
int quantity; // numeric int quantity; //numeric
char *shipDate; // date time char *shipDate; //date time
status_e status; // enum status_e status; //enum
int complete; // boolean int complete; //boolean
} order_t; } order_t;
order_t *order_create(long id, long petId, int quantity, char *shipDate, order_t *order_create(
status_e status, int complete); long id,
long petId,
int quantity,
char *shipDate,
status_e status,
int complete
);
void order_free(order_t *order); void order_free(order_t *order);
@ -38,3 +45,4 @@ order_t *order_parseFromJSON(cJSON *orderJSON);
cJSON *order_convertToJSON(order_t *order); cJSON *order_convertToJSON(order_t *order);
#endif /* _order_H_ */ #endif /* _order_H_ */

422
samples/client/petstore/c/model/pet.c
View File

@ -4,247 +4,251 @@
#include "pet.h" #include "pet.h"
char *statuspet_ToString(status_e status) { char* statuspet_ToString(status_e status){
char *statusArray[] = { "available", "pending", "sold" }; char *statusArray[] = { "available","pending","sold" };
return statusArray[status]; return statusArray[status];
} }
status_e statuspet_FromString(char *status) { status_e statuspet_FromString(char* status){
int stringToReturn = 0; int stringToReturn = 0;
char *statusArray[] = { "available", "pending", "sold" }; char *statusArray[] = { "available","pending","sold" };
size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]); size_t sizeofArray = sizeof(statusArray) / sizeof(statusArray[0]);
while(stringToReturn < sizeofArray) { while(stringToReturn < sizeofArray) {
if(strcmp(status, statusArray[stringToReturn]) == 0) { if(strcmp(status, statusArray[stringToReturn]) == 0) {
return stringToReturn; return stringToReturn;
} }
stringToReturn++; stringToReturn++;
} }
return 0; return 0;
} }
pet_t *pet_create(long id, category_t *category, char *name, list_t *photoUrls, pet_t *pet_create(
list_t *tags, status_e status) { long id,
pet_t *pet_local_var = malloc(sizeof(pet_t)); category_t *category,
if(!pet_local_var) { char *name,
return NULL; list_t *photoUrls,
} list_t *tags,
pet_local_var->id = id; status_e status
pet_local_var->category = category; ) {
pet_local_var->name = name; pet_t *pet_local_var = malloc(sizeof(pet_t));
pet_local_var->photoUrls = photoUrls; if (!pet_local_var) {
pet_local_var->tags = tags; return NULL;
pet_local_var->status = status; }
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) { void pet_free(pet_t *pet) {
listEntry_t *listEntry; listEntry_t *listEntry;
category_free(pet->category); category_free(pet->category);
free(pet->name); free(pet->name);
list_ForEach(listEntry, pet->photoUrls) { list_ForEach(listEntry, pet->photoUrls) {
free(listEntry->data); free(listEntry->data);
} }
list_free(pet->photoUrls); list_free(pet->photoUrls);
list_ForEach(listEntry, pet->tags) { list_ForEach(listEntry, pet->tags) {
tag_free(listEntry->data); tag_free(listEntry->data);
} }
list_free(pet->tags); list_free(pet->tags);
free(pet); free(pet);
} }
cJSON *pet_convertToJSON(pet_t *pet) { cJSON *pet_convertToJSON(pet_t *pet) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
// pet->id // pet->id
if(pet->id) { if(pet->id) {
if(cJSON_AddNumberToObject(item, "id", pet->id) == NULL) { if(cJSON_AddNumberToObject(item, "id", pet->id) == NULL) {
goto fail; // Numeric goto fail; //Numeric
} }
} }
// pet->category // pet->category
if(pet->category) { if(pet->category) {
cJSON *category_local_JSON = category_convertToJSON( cJSON *category_local_JSON = category_convertToJSON(pet->category);
pet->category); if(category_local_JSON == NULL) {
if(category_local_JSON == NULL) { goto fail; //model
goto fail; // model }
} cJSON_AddItemToObject(item, "category", category_local_JSON);
cJSON_AddItemToObject(item, "category", category_local_JSON); if(item->child == NULL) {
if(item->child == NULL) { goto fail;
goto fail; }
} }
}
// pet->name // pet->name
if(!pet->name) { if (!pet->name) {
goto fail; goto fail;
} }
if(cJSON_AddStringToObject(item, "name", pet->name) == NULL) { if(cJSON_AddStringToObject(item, "name", pet->name) == NULL) {
goto fail; // String goto fail; //String
} }
// pet->photoUrls // pet->photoUrls
if(!pet->photoUrls) { if (!pet->photoUrls) {
goto fail; goto fail;
} }
cJSON *photo_urls = cJSON_AddArrayToObject(item, "photoUrls");
if(photo_urls == NULL) {
goto fail; //primitive container
}
cJSON *photo_urls = cJSON_AddArrayToObject(item, "photoUrls"); listEntry_t *photo_urlsListEntry;
if(photo_urls == NULL) { list_ForEach(photo_urlsListEntry, pet->photoUrls) {
goto fail; // primitive container 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 // pet->tags
if(pet->tags) { if(pet->tags) {
cJSON *tags = cJSON_AddArrayToObject(item, "tags"); cJSON *tags = cJSON_AddArrayToObject(item, "tags");
if(tags == NULL) { if(tags == NULL) {
goto fail; // nonprimitive container goto fail; //nonprimitive container
} }
listEntry_t *tagsListEntry; listEntry_t *tagsListEntry;
if(pet->tags) { if (pet->tags) {
list_ForEach(tagsListEntry, pet->tags) { list_ForEach(tagsListEntry, pet->tags) {
cJSON *itemLocal = tag_convertToJSON( cJSON *itemLocal = tag_convertToJSON(tagsListEntry->data);
tagsListEntry->data); if(itemLocal == NULL) {
if(itemLocal == NULL) { goto fail;
goto fail; }
} cJSON_AddItemToArray(tags, itemLocal);
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", return item;
statuspet_ToString(pet->status)) == NULL)
{
goto fail; // Enum
}
return item;
fail: fail:
if(item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
pet_t *pet_parseFromJSON(cJSON *petJSON) { pet_t *pet_parseFromJSON(cJSON *petJSON){
pet_t *pet_local_var = NULL;
// pet->id pet_t *pet_local_var = NULL;
cJSON *id = cJSON_GetObjectItemCaseSensitive(petJSON, "id");
if(id) {
if(!cJSON_IsNumber(id)) {
goto end; // Numeric
}
}
// pet->category // pet->id
cJSON *category = cJSON_GetObjectItemCaseSensitive(petJSON, "category"); cJSON *id = cJSON_GetObjectItemCaseSensitive(petJSON, "id");
category_t *category_local_nonprim = NULL; if (id) {
if(category) { if(!cJSON_IsNumber(id))
category_local_nonprim = category_parseFromJSON(category); // nonprimitive {
} goto end; //Numeric
}
}
// pet->name // pet->category
cJSON *name = cJSON_GetObjectItemCaseSensitive(petJSON, "name"); cJSON *category = cJSON_GetObjectItemCaseSensitive(petJSON, "category");
if(!name) { category_t *category_local_nonprim = NULL;
goto end; 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)) { pet_local_var = pet_create (
goto end; // String id ? id->valuedouble : 0,
} category ? category_local_nonprim : NULL,
strdup(name->valuestring),
photo_urlsList,
tags ? tagsList : NULL,
status ? statusVariable : -1
);
// pet->photoUrls return pet_local_var;
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;
end: end:
return NULL; return NULL;
} }

30
samples/client/petstore/c/model/pet.h
View File

@ -14,24 +14,31 @@
#include "category.h" #include "category.h"
#include "tag.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 { typedef struct pet_t {
long id; // numeric long id; //numeric
category_t *category; // model category_t *category; //model
char *name; // string char *name; // string
list_t *photoUrls; // primitive container list_t *photoUrls; //primitive container
list_t *tags; // nonprimitive container list_t *tags; //nonprimitive container
status_e status; // enum status_e status; //enum
} pet_t; } pet_t;
pet_t *pet_create(long id, category_t *category, char *name, list_t *photoUrls, pet_t *pet_create(
list_t *tags, status_e status); long id,
category_t *category,
char *name,
list_t *photoUrls,
list_t *tags,
status_e status
);
void pet_free(pet_t *pet); void pet_free(pet_t *pet);
@ -40,3 +47,4 @@ pet_t *pet_parseFromJSON(cJSON *petJSON);
cJSON *pet_convertToJSON(pet_t *pet); cJSON *pet_convertToJSON(pet_t *pet);
#endif /* _pet_H_ */ #endif /* _pet_H_ */

109
samples/client/petstore/c/model/tag.c
View File

@ -5,76 +5,83 @@
tag_t *tag_create(long id, char *name) { tag_t *tag_create(
tag_t *tag_local_var = malloc(sizeof(tag_t)); long id,
if(!tag_local_var) { char *name
return NULL; ) {
} tag_t *tag_local_var = malloc(sizeof(tag_t));
tag_local_var->id = id; if (!tag_local_var) {
tag_local_var->name = name; 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) { void tag_free(tag_t *tag) {
listEntry_t *listEntry; listEntry_t *listEntry;
free(tag->name); free(tag->name);
free(tag); free(tag);
} }
cJSON *tag_convertToJSON(tag_t *tag) { cJSON *tag_convertToJSON(tag_t *tag) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
// tag->id // tag->id
if(tag->id) { if(tag->id) {
if(cJSON_AddNumberToObject(item, "id", tag->id) == NULL) { if(cJSON_AddNumberToObject(item, "id", tag->id) == NULL) {
goto fail; // Numeric goto fail; //Numeric
} }
} }
// tag->name // tag->name
if(tag->name) { if(tag->name) {
if(cJSON_AddStringToObject(item, "name", tag->name) == NULL) { if(cJSON_AddStringToObject(item, "name", tag->name) == NULL) {
goto fail; // String goto fail; //String
} }
} }
return item; return item;
fail: fail:
if(item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
tag_t *tag_parseFromJSON(cJSON *tagJSON) { tag_t *tag_parseFromJSON(cJSON *tagJSON){
tag_t *tag_local_var = NULL;
// tag->id tag_t *tag_local_var = NULL;
cJSON *id = cJSON_GetObjectItemCaseSensitive(tagJSON, "id");
if(id) {
if(!cJSON_IsNumber(id)) {
goto end; // Numeric
}
}
// tag->name // tag->id
cJSON *name = cJSON_GetObjectItemCaseSensitive(tagJSON, "name"); cJSON *id = cJSON_GetObjectItemCaseSensitive(tagJSON, "id");
if(name) { if (id) {
if(!cJSON_IsString(name)) { if(!cJSON_IsNumber(id))
goto end; // String {
} 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( tag_local_var = tag_create (
id ? id->valuedouble : 0, id ? id->valuedouble : 0,
name ? strdup(name->valuestring) : NULL name ? strdup(name->valuestring) : NULL
); );
return tag_local_var; return tag_local_var;
end: end:
return NULL; return NULL;
} }

11
samples/client/petstore/c/model/tag.h
View File

@ -15,11 +15,15 @@
typedef struct tag_t { typedef struct tag_t {
long id; // numeric long id; //numeric
char *name; // string char *name; // string
} tag_t; } tag_t;
tag_t *tag_create(long id, char *name); tag_t *tag_create(
long id,
char *name
);
void tag_free(tag_t *tag); void tag_free(tag_t *tag);
@ -28,3 +32,4 @@ tag_t *tag_parseFromJSON(cJSON *tagJSON);
cJSON *tag_convertToJSON(tag_t *tag); cJSON *tag_convertToJSON(tag_t *tag);
#endif /* _tag_H_ */ #endif /* _tag_H_ */

331
samples/client/petstore/c/model/user.c
View File

@ -5,209 +5,208 @@
user_t *user_create(long id, char *username, char *firstName, char *lastName, user_t *user_create(
char *email, char *password, char *phone, int userStatus) { long id,
user_t *user_local_var = malloc(sizeof(user_t)); char *username,
if(!user_local_var) { char *firstName,
return NULL; char *lastName,
} char *email,
user_local_var->id = id; char *password,
user_local_var->username = username; char *phone,
user_local_var->firstName = firstName; int userStatus
user_local_var->lastName = lastName; ) {
user_local_var->email = email; user_t *user_local_var = malloc(sizeof(user_t));
user_local_var->password = password; if (!user_local_var) {
user_local_var->phone = phone; return NULL;
user_local_var->userStatus = userStatus; }
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) { void user_free(user_t *user) {
listEntry_t *listEntry; listEntry_t *listEntry;
free(user->username); free(user->username);
free(user->firstName); free(user->firstName);
free(user->lastName); free(user->lastName);
free(user->email); free(user->email);
free(user->password); free(user->password);
free(user->phone); free(user->phone);
free(user); free(user);
} }
cJSON *user_convertToJSON(user_t *user) { cJSON *user_convertToJSON(user_t *user) {
cJSON *item = cJSON_CreateObject(); cJSON *item = cJSON_CreateObject();
// user->id // user->id
if(user->id) { if(user->id) {
if(cJSON_AddNumberToObject(item, "id", user->id) == NULL) { if(cJSON_AddNumberToObject(item, "id", user->id) == NULL) {
goto fail; // Numeric goto fail; //Numeric
} }
} }
// user->username // user->username
if(user->username) { if(user->username) {
if(cJSON_AddStringToObject(item, "username", if(cJSON_AddStringToObject(item, "username", user->username) == NULL) {
user->username) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// user->firstName // user->firstName
if(user->firstName) { if(user->firstName) {
if(cJSON_AddStringToObject(item, "firstName", if(cJSON_AddStringToObject(item, "firstName", user->firstName) == NULL) {
user->firstName) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// user->lastName // user->lastName
if(user->lastName) { if(user->lastName) {
if(cJSON_AddStringToObject(item, "lastName", if(cJSON_AddStringToObject(item, "lastName", user->lastName) == NULL) {
user->lastName) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// user->email // user->email
if(user->email) { if(user->email) {
if(cJSON_AddStringToObject(item, "email", if(cJSON_AddStringToObject(item, "email", user->email) == NULL) {
user->email) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// user->password // user->password
if(user->password) { if(user->password) {
if(cJSON_AddStringToObject(item, "password", if(cJSON_AddStringToObject(item, "password", user->password) == NULL) {
user->password) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// user->phone // user->phone
if(user->phone) { if(user->phone) {
if(cJSON_AddStringToObject(item, "phone", if(cJSON_AddStringToObject(item, "phone", user->phone) == NULL) {
user->phone) == NULL) goto fail; //String
{ }
goto fail; // String }
}
}
// user->userStatus // user->userStatus
if(user->userStatus) { if(user->userStatus) {
if(cJSON_AddNumberToObject(item, "userStatus", if(cJSON_AddNumberToObject(item, "userStatus", user->userStatus) == NULL) {
user->userStatus) == NULL) goto fail; //Numeric
{ }
goto fail; // Numeric }
}
}
return item; return item;
fail: fail:
if(item) { if (item) {
cJSON_Delete(item); cJSON_Delete(item);
} }
return NULL; return NULL;
} }
user_t *user_parseFromJSON(cJSON *userJSON) { user_t *user_parseFromJSON(cJSON *userJSON){
user_t *user_local_var = NULL;
// user->id user_t *user_local_var = NULL;
cJSON *id = cJSON_GetObjectItemCaseSensitive(userJSON, "id");
if(id) {
if(!cJSON_IsNumber(id)) {
goto end; // Numeric
}
}
// user->username // user->id
cJSON *username = cJSON *id = cJSON_GetObjectItemCaseSensitive(userJSON, "id");
cJSON_GetObjectItemCaseSensitive(userJSON, "username"); if (id) {
if(username) { if(!cJSON_IsNumber(id))
if(!cJSON_IsString(username)) { {
goto end; // String goto end; //Numeric
} }
} }
// user->firstName // user->username
cJSON *firstName = cJSON_GetObjectItemCaseSensitive(userJSON, cJSON *username = cJSON_GetObjectItemCaseSensitive(userJSON, "username");
"firstName"); if (username) {
if(firstName) { if(!cJSON_IsString(username))
if(!cJSON_IsString(firstName)) { {
goto end; // String goto end; //String
} }
} }
// user->lastName // user->firstName
cJSON *lastName = cJSON *firstName = cJSON_GetObjectItemCaseSensitive(userJSON, "firstName");
cJSON_GetObjectItemCaseSensitive(userJSON, "lastName"); if (firstName) {
if(lastName) { if(!cJSON_IsString(firstName))
if(!cJSON_IsString(lastName)) { {
goto end; // String goto end; //String
} }
} }
// user->email // user->lastName
cJSON *email = cJSON_GetObjectItemCaseSensitive(userJSON, "email"); cJSON *lastName = cJSON_GetObjectItemCaseSensitive(userJSON, "lastName");
if(email) { if (lastName) {
if(!cJSON_IsString(email)) { if(!cJSON_IsString(lastName))
goto end; // String {
} goto end; //String
} }
}
// user->password // user->email
cJSON *password = cJSON *email = cJSON_GetObjectItemCaseSensitive(userJSON, "email");
cJSON_GetObjectItemCaseSensitive(userJSON, "password"); if (email) {
if(password) { if(!cJSON_IsString(email))
if(!cJSON_IsString(password)) { {
goto end; // String goto end; //String
} }
} }
// user->phone // user->password
cJSON *phone = cJSON_GetObjectItemCaseSensitive(userJSON, "phone"); cJSON *password = cJSON_GetObjectItemCaseSensitive(userJSON, "password");
if(phone) { if (password) {
if(!cJSON_IsString(phone)) { if(!cJSON_IsString(password))
goto end; // String {
} goto end; //String
} }
}
// user->userStatus // user->phone
cJSON *userStatus = cJSON_GetObjectItemCaseSensitive(userJSON, cJSON *phone = cJSON_GetObjectItemCaseSensitive(userJSON, "phone");
"userStatus"); if (phone) {
if(userStatus) { if(!cJSON_IsString(phone))
if(!cJSON_IsNumber(userStatus)) { {
goto end; // Numeric 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( user_local_var = user_create (
id ? id->valuedouble : 0, id ? id->valuedouble : 0,
username ? strdup(username->valuestring) : NULL, username ? strdup(username->valuestring) : NULL,
firstName ? strdup(firstName->valuestring) : NULL, firstName ? strdup(firstName->valuestring) : NULL,
lastName ? strdup(lastName->valuestring) : NULL, lastName ? strdup(lastName->valuestring) : NULL,
email ? strdup(email->valuestring) : NULL, email ? strdup(email->valuestring) : NULL,
password ? strdup(password->valuestring) : NULL, password ? strdup(password->valuestring) : NULL,
phone ? strdup(phone->valuestring) : NULL, phone ? strdup(phone->valuestring) : NULL,
userStatus ? userStatus->valuedouble : 0 userStatus ? userStatus->valuedouble : 0
); );
return user_local_var; return user_local_var;
end: end:
return NULL; return NULL;
} }

30
samples/client/petstore/c/model/user.h
View File

@ -15,18 +15,27 @@
typedef struct user_t { typedef struct user_t {
long id; // numeric long id; //numeric
char *username; // string char *username; // string
char *firstName; // string char *firstName; // string
char *lastName; // string char *lastName; // string
char *email; // string char *email; // string
char *password; // string char *password; // string
char *phone; // string char *phone; // string
int userStatus; // numeric int userStatus; //numeric
} user_t; } user_t;
user_t *user_create(long id, char *username, char *firstName, char *lastName, user_t *user_create(
char *email, char *password, char *phone, int userStatus); long id,
char *username,
char *firstName,
char *lastName,
char *email,
char *password,
char *phone,
int userStatus
);
void user_free(user_t *user); void user_free(user_t *user);
@ -35,3 +44,4 @@ user_t *user_parseFromJSON(cJSON *userJSON);
cJSON *user_convertToJSON(user_t *user); cJSON *user_convertToJSON(user_t *user);
#endif /* _user_H_ */ #endif /* _user_H_ */

743
samples/client/petstore/c/src/apiClient.c
View File

@ -10,451 +10,448 @@
size_t writeDataCallback(void *buffer, size_t size, size_t nmemb, void *userp); size_t writeDataCallback(void *buffer, size_t size, size_t nmemb, void *userp);
apiClient_t *apiClient_create() { apiClient_t *apiClient_create() {
curl_global_init(CURL_GLOBAL_ALL); curl_global_init(CURL_GLOBAL_ALL);
apiClient_t *apiClient = malloc(sizeof(apiClient_t)); apiClient_t *apiClient = malloc(sizeof(apiClient_t));
apiClient->basePath = "http://petstore.swagger.io/v2"; apiClient->basePath = "http://petstore.swagger.io/v2";
apiClient->dataReceived = NULL; apiClient->dataReceived = NULL;
apiClient->response_code = 0; apiClient->response_code = 0;
apiClient->apiKeys = NULL; apiClient->apiKeys = NULL;
apiClient->accessToken = NULL; apiClient->accessToken = NULL;
return apiClient; return apiClient;
} }
void apiClient_free(apiClient_t *apiClient) { void apiClient_free(apiClient_t *apiClient) {
if(apiClient->accessToken) { if(apiClient->accessToken) {
list_free(apiClient->apiKeys); list_free(apiClient->apiKeys);
} }
if(apiClient->accessToken) { if(apiClient->accessToken) {
free(apiClient->accessToken); free(apiClient->accessToken);
} }
free(apiClient); free(apiClient);
curl_global_cleanup(); curl_global_cleanup();
} }
void replaceSpaceWithPlus(char *stringToProcess) { void replaceSpaceWithPlus(char *stringToProcess) {
for(int i = 0; i < strlen(stringToProcess); i++) { for(int i = 0; i < strlen(stringToProcess); i++) {
if(stringToProcess[i] == ' ') { if(stringToProcess[i] == ' ') {
stringToProcess[i] = '+'; stringToProcess[i] = '+';
} }
} }
} }
char *assembleTargetUrl(char *basePath, char *operationParameter, char *assembleTargetUrl(char *basePath,
list_t *queryParameters) { char *operationParameter,
int neededBufferSizeForQueryParameters = 0; list_t *queryParameters) {
listEntry_t *listEntry; int neededBufferSizeForQueryParameters = 0;
listEntry_t *listEntry;
if(queryParameters != NULL) { if(queryParameters != NULL) {
list_ForEach(listEntry, queryParameters) { list_ForEach(listEntry, queryParameters) {
keyValuePair_t *pair = listEntry->data; keyValuePair_t *pair = listEntry->data;
neededBufferSizeForQueryParameters += neededBufferSizeForQueryParameters +=
strlen(pair->key) + strlen(pair->value); strlen(pair->key) + strlen(pair->value);
} }
neededBufferSizeForQueryParameters += neededBufferSizeForQueryParameters +=
(queryParameters->count * 2); // each keyValuePair is separated by a = and a & except the last, but this makes up for the ? at the beginning (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 operationParameterLength = 0;
int basePathLength = strlen(basePath); int basePathLength = strlen(basePath);
bool slashNeedsToBeAppendedToBasePath = false; bool slashNeedsToBeAppendedToBasePath = false;
if(operationParameter != NULL) { if(operationParameter != NULL) {
operationParameterLength = (1 + strlen(operationParameter)); operationParameterLength = (1 + strlen(operationParameter));
} }
if(basePath[strlen(basePath) - 1] != '/') { if(basePath[strlen(basePath) - 1] != '/') {
slashNeedsToBeAppendedToBasePath = true; slashNeedsToBeAppendedToBasePath = true;
basePathLength++; basePathLength++;
} }
char *targetUrl = char *targetUrl =
malloc( malloc(
neededBufferSizeForQueryParameters + basePathLength + operationParameterLength + neededBufferSizeForQueryParameters + basePathLength + operationParameterLength +
1); 1);
strcpy(targetUrl, basePath); strcpy(targetUrl, basePath);
if(operationParameter != NULL) { if(operationParameter != NULL) {
strcat(targetUrl, operationParameter); strcat(targetUrl, operationParameter);
} }
if(queryParameters != NULL) { if(queryParameters != NULL) {
strcat(targetUrl, "?"); strcat(targetUrl, "?");
list_ForEach(listEntry, queryParameters) { list_ForEach(listEntry, queryParameters) {
keyValuePair_t *pair = listEntry->data; keyValuePair_t *pair = listEntry->data;
replaceSpaceWithPlus(pair->key); replaceSpaceWithPlus(pair->key);
strcat(targetUrl, pair->key); strcat(targetUrl, pair->key);
strcat(targetUrl, "="); strcat(targetUrl, "=");
replaceSpaceWithPlus(pair->value); replaceSpaceWithPlus(pair->value);
strcat(targetUrl, pair->value); strcat(targetUrl, pair->value);
if(listEntry->nextListEntry != NULL) { if(listEntry->nextListEntry != NULL) {
strcat(targetUrl, "&"); strcat(targetUrl, "&");
} }
} }
} }
return targetUrl; return targetUrl;
} }
char *assembleHeaderField(char *key, char *value) { 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), strcpy(header, key),
strcat(header, ": "); strcat(header, ": ");
strcat(header, value); strcat(header, value);
return header; return header;
} }
void postData(CURL *handle, char *bodyParameters) { void postData(CURL *handle, char *bodyParameters) {
curl_easy_setopt(handle, CURLOPT_POSTFIELDS, bodyParameters); curl_easy_setopt(handle, CURLOPT_POSTFIELDS, bodyParameters);
curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE_LARGE, curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE_LARGE,
strlen(bodyParameters)); strlen(bodyParameters));
} }
int lengthOfKeyPair(keyValuePair_t *keyPair) { int lengthOfKeyPair(keyValuePair_t *keyPair) {
long length = 0; long length = 0;
if((keyPair->key != NULL) && if((keyPair->key != NULL) &&
(keyPair->value != NULL) ) (keyPair->value != NULL) )
{ {
length = strlen(keyPair->key) + strlen(keyPair->value); length = strlen(keyPair->key) + strlen(keyPair->value);
return length; return length;
} }
return 0; return 0;
} }
void apiClient_invoke(apiClient_t *apiClient, char *operationParameter, void apiClient_invoke(apiClient_t *apiClient,
list_t *queryParameters, list_t *headerParameters, char *operationParameter,
list_t *formParameters, list_t *headerType, list_t *queryParameters,
list_t *contentType, char *bodyParameters, list_t *headerParameters,
char *requestType) { list_t *formParameters,
CURL *handle = curl_easy_init(); list_t *headerType,
CURLcode res; list_t *contentType,
char *bodyParameters,
char *requestType) {
CURL *handle = curl_easy_init();
CURLcode res;
if(handle) { if(handle) {
listEntry_t *listEntry; listEntry_t *listEntry;
curl_mime *mime = NULL; curl_mime *mime = NULL;
struct curl_slist *headers = NULL; struct curl_slist *headers = NULL;
char *buffContent = NULL; char *buffContent = NULL;
char *buffHeader = NULL; char *buffHeader = NULL;
binary_t *fileVar = NULL; binary_t *fileVar = NULL;
char *formString = NULL; char *formString = NULL;
if(headerType != NULL) { if(headerType != NULL) {
list_ForEach(listEntry, headerType) { list_ForEach(listEntry, headerType) {
if(strstr((char *) listEntry->data, if(strstr((char *) listEntry->data,
"xml") == NULL) "xml") == NULL)
{ {
buffHeader = malloc(strlen( buffHeader = malloc(strlen(
"Accept: ") + "Accept: ") +
strlen((char *) strlen((char *)
listEntry-> listEntry->
data) + 1); data) + 1);
sprintf(buffHeader, "%s%s", "Accept: ", sprintf(buffHeader, "%s%s", "Accept: ",
(char *) listEntry->data); (char *) listEntry->data);
headers = curl_slist_append(headers, headers = curl_slist_append(headers,
buffHeader); buffHeader);
free(buffHeader); free(buffHeader);
} }
} }
} }
if(contentType != NULL) { if(contentType != NULL) {
list_ForEach(listEntry, contentType) { list_ForEach(listEntry, contentType) {
if(strstr((char *) listEntry->data, if(strstr((char *) listEntry->data,
"xml") == NULL) "xml") == NULL)
{ {
buffContent = buffContent =
malloc(strlen( malloc(strlen(
"Content-Type: ") + strlen( "Content-Type: ") + strlen(
(char *) (char *)
listEntry->data) + listEntry->data) +
1); 1);
sprintf(buffContent, "%s%s", sprintf(buffContent, "%s%s",
"Content-Type: ", "Content-Type: ",
(char *) listEntry->data); (char *) listEntry->data);
headers = curl_slist_append(headers, headers = curl_slist_append(headers,
buffContent); buffContent);
} }
} }
} else { } else {
headers = curl_slist_append(headers, headers = curl_slist_append(headers,
"Content-Type: application/json"); "Content-Type: application/json");
} }
if(requestType != NULL) { if(requestType != NULL) {
curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST,
requestType); requestType);
} }
if(formParameters != NULL) { if(formParameters != NULL) {
if(strstr(buffContent, if(strstr(buffContent,
"application/x-www-form-urlencoded") != NULL) "application/x-www-form-urlencoded") != NULL)
{ {
long parameterLength = 0; long parameterLength = 0;
long keyPairLength = 0; long keyPairLength = 0;
list_ForEach(listEntry, formParameters) { list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyPair = keyValuePair_t *keyPair =
listEntry->data; listEntry->data;
keyPairLength = keyPairLength =
lengthOfKeyPair(keyPair) + 1; lengthOfKeyPair(keyPair) + 1;
if(listEntry->nextListEntry != NULL) { if(listEntry->nextListEntry != NULL) {
parameterLength++; parameterLength++;
} }
parameterLength = parameterLength + parameterLength = parameterLength +
keyPairLength; keyPairLength;
} }
formString = malloc(parameterLength + 1); formString = malloc(parameterLength + 1);
memset(formString, 0, parameterLength + 1); memset(formString, 0, parameterLength + 1);
list_ForEach(listEntry, formParameters) { list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyPair = keyValuePair_t *keyPair =
listEntry->data; listEntry->data;
if((keyPair->key != NULL) && if((keyPair->key != NULL) &&
(keyPair->value != NULL) ) (keyPair->value != NULL) )
{ {
strcat(formString, strcat(formString,
keyPair->key); keyPair->key);
strcat(formString, "="); strcat(formString, "=");
strcat(formString, strcat(formString,
keyPair->value); keyPair->value);
if(listEntry->nextListEntry != if(listEntry->nextListEntry !=
NULL) NULL)
{ {
strcat(formString, "&"); strcat(formString, "&");
} }
} }
} }
curl_easy_setopt(handle, CURLOPT_POSTFIELDS, curl_easy_setopt(handle, CURLOPT_POSTFIELDS,
formString); formString);
} }
if(strstr(buffContent, "multipart/form-data") != NULL) { if(strstr(buffContent, "multipart/form-data") != NULL) {
mime = curl_mime_init(handle); mime = curl_mime_init(handle);
list_ForEach(listEntry, formParameters) { list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyValuePair = keyValuePair_t *keyValuePair =
listEntry->data; listEntry->data;
if((keyValuePair->key != NULL) && if((keyValuePair->key != NULL) &&
(keyValuePair->value != NULL) ) (keyValuePair->value != NULL) )
{ {
curl_mimepart *part = curl_mimepart *part =
curl_mime_addpart(mime); curl_mime_addpart(mime);
curl_mime_name(part, curl_mime_name(part,
keyValuePair->key); keyValuePair->key);
if(strcmp(keyValuePair->key, if(strcmp(keyValuePair->key,
"file") == 0) "file") == 0)
{ {
memcpy(&fileVar, memcpy(&fileVar,
keyValuePair->value, keyValuePair->value,
sizeof(fileVar)); sizeof(fileVar));
curl_mime_data(part, curl_mime_data(part,
fileVar->data, fileVar->data,
fileVar->len); fileVar->len);
curl_mime_filename(part, curl_mime_filename(part,
"image.png"); "image.png");
} else { } else {
curl_mime_data(part, curl_mime_data(part,
keyValuePair->value, keyValuePair->value,
CURL_ZERO_TERMINATED); CURL_ZERO_TERMINATED);
} }
} }
} }
curl_easy_setopt(handle, CURLOPT_MIMEPOST, curl_easy_setopt(handle, CURLOPT_MIMEPOST,
mime); mime);
} }
} }
list_ForEach(listEntry, headerParameters) { list_ForEach(listEntry, headerParameters) {
keyValuePair_t *keyValuePair = listEntry->data; keyValuePair_t *keyValuePair = listEntry->data;
if((keyValuePair->key != NULL) && if((keyValuePair->key != NULL) &&
(keyValuePair->value != NULL) ) (keyValuePair->value != NULL) )
{ {
char *headerValueToWrite = assembleHeaderField( char *headerValueToWrite = assembleHeaderField(
keyValuePair->key, keyValuePair->value); keyValuePair->key, keyValuePair->value);
curl_slist_append(headers, headerValueToWrite); curl_slist_append(headers, headerValueToWrite);
free(headerValueToWrite); free(headerValueToWrite);
} }
} }
// this would only be generated for apiKey authentication // this would only be generated for apiKey authentication
if(apiClient->apiKeys != NULL) { if (apiClient->apiKeys != NULL)
list_ForEach(listEntry, apiClient->apiKeys) { {
keyValuePair_t *apiKey = listEntry->data; list_ForEach(listEntry, apiClient->apiKeys) {
if((apiKey->key != NULL) && keyValuePair_t *apiKey = listEntry->data;
(apiKey->value != NULL) ) if((apiKey->key != NULL) &&
{ (apiKey->value != NULL) )
char *headerValueToWrite = {
assembleHeaderField( char *headerValueToWrite = assembleHeaderField(
apiKey->key, apiKey->key, apiKey->value);
apiKey->value); curl_slist_append(headers, headerValueToWrite);
curl_slist_append(headers, free(headerValueToWrite);
headerValueToWrite); }
free(headerValueToWrite); }
} }
}
}
char *targetUrl = char *targetUrl =
assembleTargetUrl(apiClient->basePath, assembleTargetUrl(apiClient->basePath,
operationParameter, operationParameter,
queryParameters); queryParameters);
curl_easy_setopt(handle, CURLOPT_URL, targetUrl); curl_easy_setopt(handle, CURLOPT_URL, targetUrl);
curl_easy_setopt(handle, curl_easy_setopt(handle,
CURLOPT_WRITEFUNCTION, CURLOPT_WRITEFUNCTION,
writeDataCallback); writeDataCallback);
curl_easy_setopt(handle, curl_easy_setopt(handle,
CURLOPT_WRITEDATA, CURLOPT_WRITEDATA,
&apiClient->dataReceived); &apiClient->dataReceived);
curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers); 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_VERBOSE, 0); // to get curl debug msg 0: to disable, 1L:to enable
// this would only be generated for OAuth2 authentication // this would only be generated for OAuth2 authentication
if(apiClient->accessToken != NULL) { if(apiClient->accessToken != NULL) {
// curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BEARER); // curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BEARER);
curl_easy_setopt(handle, curl_easy_setopt(handle,
CURLOPT_XOAUTH2_BEARER, CURLOPT_XOAUTH2_BEARER,
apiClient->accessToken); apiClient->accessToken);
} }
if(bodyParameters != NULL) { if(bodyParameters != NULL) {
postData(handle, bodyParameters); 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) { if(contentType != NULL) {
free(buffContent); free(buffContent);
} }
if(res == CURLE_OK) { if(res == CURLE_OK) {
curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &apiClient->response_code);
&apiClient->response_code); } else {
} else { char *url,*ip,*scheme;
char *url, *ip, *scheme; long port;
long port; curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url);
curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url); curl_easy_getinfo(handle, CURLINFO_PRIMARY_IP, &ip);
curl_easy_getinfo(handle, CURLINFO_PRIMARY_IP, &ip); curl_easy_getinfo(handle, CURLINFO_PRIMARY_PORT, &port);
curl_easy_getinfo(handle, CURLINFO_PRIMARY_PORT, &port); curl_easy_getinfo(handle, CURLINFO_SCHEME, &scheme);
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,
fprintf(stderr, curl_easy_strerror(res));
"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); curl_easy_cleanup(handle);
if(formParameters != NULL) { if(formParameters != NULL) {
free(formString); free(formString);
curl_mime_free(mime); curl_mime_free(mime);
} }
} }
} }
size_t writeDataCallback(void *buffer, size_t size, size_t nmemb, void *userp) { 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 *strReplace(char *orig, char *rep, char *with) {
char *result; // the return string char *result; // the return string
char *ins; // the next insert point char *ins; // the next insert point
char *tmp; // varies char *tmp; // varies
int lenRep; // length of rep (the string to remove) int lenRep; // length of rep (the string to remove)
int lenWith; // length of with (the string to replace rep with) int lenWith; // length of with (the string to replace rep with)
int lenFront; // distance between rep and end of last rep int lenFront; // distance between rep and end of last rep
int count; // number of replacements int count; // number of replacements
// sanity checks and initialization // sanity checks and initialization
if(!orig || if(!orig || !rep)
!rep) {
{ return NULL;
return NULL; }
} lenRep = strlen(rep);
lenRep = strlen(rep); if(lenRep == 0) {
if(lenRep == 0) { return NULL; // empty rep causes infinite loop during count
return NULL; // empty rep causes infinite loop during count }
} if(!with) {
if(!with) { with = "";
with = ""; }
} lenWith = strlen(with);
lenWith = strlen(with);
// count the number of replacements needed // count the number of replacements needed
ins = orig; ins = orig;
for(count = 0; tmp = strstr(ins, rep); ++count) { for(count = 0; tmp = strstr(ins, rep); ++count) {
ins = tmp + lenRep; ins = tmp + lenRep;
} }
tmp = result = malloc(strlen(orig) + (lenWith - lenRep) * count + 1); tmp = result = malloc(strlen(orig) + (lenWith - lenRep) * count + 1);
if(!result) { if(!result) {
return NULL; return NULL;
} }
char *originalPointer = orig; // copying original pointer to free the memory char *originalPointer = orig; // copying original pointer to free the memory
// first time through the loop, all the variable are set correctly // first time through the loop, all the variable are set correctly
// from here on, // from here on,
// tmp points to the end of the result string // tmp points to the end of the result string
// ins points to the next occurrence of rep in orig // ins points to the next occurrence of rep in orig
// orig points to the remainder of orig after "end of rep" // orig points to the remainder of orig after "end of rep"
while(count--) { while(count--) {
ins = strstr(orig, rep); ins = strstr(orig, rep);
lenFront = ins - orig; lenFront = ins - orig;
tmp = strncpy(tmp, orig, lenFront) + lenFront; tmp = strncpy(tmp, orig, lenFront) + lenFront;
tmp = strcpy(tmp, with) + lenWith; tmp = strcpy(tmp, with) + lenWith;
orig += lenFront + lenRep; // move to next "end of rep" orig += lenFront + lenRep; // move to next "end of rep"
} }
strcpy(tmp, orig); strcpy(tmp, orig);
free(originalPointer); free(originalPointer);
return result; return result;
} }
char *sbi_base64encode(const void *b64_encode_this, char *sbi_base64encode (const void *b64_encode_this, int encode_this_many_bytes){
int encode_this_many_bytes) {
#ifdef OPENSSL #ifdef OPENSSL
BIO *b64_bio, *mem_bio; // Declares two OpenSSL BIOs: a base64 filter and a memory BIO. 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. 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. b64_bio = BIO_new(BIO_f_base64()); //Initialize our base64 filter BIO.
mem_bio = BIO_new(BIO_s_mem()); // Initialize our memory sink 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_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_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_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_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_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_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). 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. 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. (*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). return (*mem_bio_mem_ptr).data; //Returns base-64 encoded data. (See: "buf_mem_st" struct).
#endif #endif
} }
char *sbi_base64decode(const void *b64_decode_this, char *sbi_base64decode (const void *b64_decode_this, int decode_this_many_bytes){
int decode_this_many_bytes) {
#ifdef OPENSSL #ifdef OPENSSL
BIO *b64_bio, *mem_bio; // Declares two OpenSSL BIOs: a base64 filter and a memory BIO. 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, char *base64_decoded = calloc( (decode_this_many_bytes*3)/4+1, sizeof(char) ); //+1 = null.
sizeof(char) ); // +1 = null. b64_bio = BIO_new(BIO_f_base64()); //Initialize our base64 filter BIO.
b64_bio = BIO_new(BIO_f_base64()); // Initialize our base64 filter BIO. mem_bio = BIO_new(BIO_s_mem()); //Initialize our memory source 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_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_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.
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.
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.
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.
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.
} // 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).
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.
return base64_decoded; // Returns base-64 decoded data with trailing null terminator.
#endif #endif
} }

10
samples/client/petstore/c/src/apiKey.c
View File

@ -3,12 +3,12 @@
#include "../include/keyValuePair.h" #include "../include/keyValuePair.h"
keyValuePair_t *keyValuePair_create(char *key, void *value) { keyValuePair_t *keyValuePair_create(char *key, void *value) {
keyValuePair_t *keyValuePair = malloc(sizeof(keyValuePair_t)); keyValuePair_t *keyValuePair = malloc(sizeof(keyValuePair_t));
keyValuePair->key = key; keyValuePair->key = key;
keyValuePair->value = value; keyValuePair->value = value;
return keyValuePair; return keyValuePair;
} }
void keyValuePair_free(keyValuePair_t *keyValuePair) { void keyValuePair_free(keyValuePair_t *keyValuePair) {
free(keyValuePair); free(keyValuePair);
} }

212
samples/client/petstore/c/src/list.c
View File

@ -4,161 +4,163 @@
#include "../include/list.h" #include "../include/list.h"
static listEntry_t *listEntry_create(void *data) { static listEntry_t *listEntry_create(void *data) {
listEntry_t *createdListEntry = malloc(sizeof(listEntry_t)); listEntry_t *createdListEntry = malloc(sizeof(listEntry_t));
if(createdListEntry == NULL) { if(createdListEntry == NULL) {
// TODO Malloc Failure // TODO Malloc Failure
return NULL; return NULL;
} }
createdListEntry->data = data; createdListEntry->data = data;
return createdListEntry; return createdListEntry;
} }
void listEntry_free(listEntry_t *listEntry, void *additionalData) { void listEntry_free(listEntry_t *listEntry, void *additionalData) {
free(listEntry); free(listEntry);
} }
void listEntry_printAsInt(listEntry_t *listEntry, void *additionalData) { 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 *list_create() {
list_t *createdList = malloc(sizeof(list_t)); list_t *createdList = malloc(sizeof(list_t));
if(createdList == NULL) { if(createdList == NULL) {
// TODO Malloc Failure // TODO Malloc Failure
return NULL; return NULL;
} }
createdList->firstEntry = NULL; createdList->firstEntry = NULL;
createdList->lastEntry = NULL; createdList->lastEntry = NULL;
createdList->count = 0; createdList->count = 0;
return createdList; return createdList;
} }
void list_iterateThroughListForward(list_t *list, void (*operationToPerform)( void list_iterateThroughListForward(list_t *list,
listEntry_t *, void (*operationToPerform)(
void *callbackFunctionUsedData), listEntry_t *,
void *callbackFunctionUsedData),
void *additionalDataNeededForCallbackFunction) void *additionalDataNeededForCallbackFunction)
{ {
listEntry_t *currentListEntry = list->firstEntry; listEntry_t *currentListEntry = list->firstEntry;
listEntry_t *nextListEntry; listEntry_t *nextListEntry;
if(currentListEntry == NULL) { if(currentListEntry == NULL) {
return; return;
} }
nextListEntry = currentListEntry->nextListEntry; nextListEntry = currentListEntry->nextListEntry;
operationToPerform(currentListEntry, operationToPerform(currentListEntry,
additionalDataNeededForCallbackFunction); additionalDataNeededForCallbackFunction);
currentListEntry = nextListEntry; currentListEntry = nextListEntry;
while(currentListEntry != NULL) { while(currentListEntry != NULL) {
nextListEntry = currentListEntry->nextListEntry; nextListEntry = currentListEntry->nextListEntry;
operationToPerform(currentListEntry, operationToPerform(currentListEntry,
additionalDataNeededForCallbackFunction); additionalDataNeededForCallbackFunction);
currentListEntry = nextListEntry; currentListEntry = nextListEntry;
} }
} }
void list_iterateThroughListBackward(list_t *list, void (*operationToPerform)( void list_iterateThroughListBackward(list_t *list,
listEntry_t *, void (*operationToPerform)(
void *callbackFunctionUsedData), listEntry_t *,
void *callbackFunctionUsedData),
void *additionalDataNeededForCallbackFunction) void *additionalDataNeededForCallbackFunction)
{ {
listEntry_t *currentListEntry = list->lastEntry; listEntry_t *currentListEntry = list->lastEntry;
listEntry_t *nextListEntry = currentListEntry->prevListEntry; listEntry_t *nextListEntry = currentListEntry->prevListEntry;
if(currentListEntry == NULL) { if(currentListEntry == NULL) {
return; return;
} }
operationToPerform(currentListEntry, operationToPerform(currentListEntry,
additionalDataNeededForCallbackFunction); additionalDataNeededForCallbackFunction);
currentListEntry = nextListEntry; currentListEntry = nextListEntry;
while(currentListEntry != NULL) { while(currentListEntry != NULL) {
nextListEntry = currentListEntry->prevListEntry; nextListEntry = currentListEntry->prevListEntry;
operationToPerform(currentListEntry, operationToPerform(currentListEntry,
additionalDataNeededForCallbackFunction); additionalDataNeededForCallbackFunction);
currentListEntry = nextListEntry; currentListEntry = nextListEntry;
} }
} }
void list_free(list_t *list) { void list_free(list_t *list) {
list_iterateThroughListForward(list, listEntry_free, NULL); list_iterateThroughListForward(list, listEntry_free, NULL);
free(list); free(list);
} }
void list_addElement(list_t *list, void *dataToAddInList) { void list_addElement(list_t *list, void *dataToAddInList) {
listEntry_t *newListEntry = listEntry_create(dataToAddInList); listEntry_t *newListEntry = listEntry_create(dataToAddInList);
if(newListEntry == NULL) { if(newListEntry == NULL) {
// TODO Malloc Failure // TODO Malloc Failure
return; return;
} }
if(list->firstEntry == NULL) { if(list->firstEntry == NULL) {
list->firstEntry = newListEntry; list->firstEntry = newListEntry;
list->lastEntry = newListEntry; list->lastEntry = newListEntry;
newListEntry->prevListEntry = NULL; newListEntry->prevListEntry = NULL;
newListEntry->nextListEntry = NULL; newListEntry->nextListEntry = NULL;
list->count++; list->count++;
return; return;
} }
list->lastEntry->nextListEntry = newListEntry; list->lastEntry->nextListEntry = newListEntry;
newListEntry->prevListEntry = list->lastEntry; newListEntry->prevListEntry = list->lastEntry;
newListEntry->nextListEntry = NULL; newListEntry->nextListEntry = NULL;
list->lastEntry = newListEntry; list->lastEntry = newListEntry;
list->count++; list->count++;
} }
void list_removeElement(list_t *list, listEntry_t *elementToRemove) { void list_removeElement(list_t *list, listEntry_t *elementToRemove) {
listEntry_t *elementBeforeElementToRemove = listEntry_t *elementBeforeElementToRemove =
elementToRemove->prevListEntry; elementToRemove->prevListEntry;
listEntry_t *elementAfterElementToRemove = listEntry_t *elementAfterElementToRemove =
elementToRemove->nextListEntry; elementToRemove->nextListEntry;
if(elementBeforeElementToRemove != NULL) { if(elementBeforeElementToRemove != NULL) {
elementBeforeElementToRemove->nextListEntry = elementBeforeElementToRemove->nextListEntry =
elementAfterElementToRemove; elementAfterElementToRemove;
} else { } else {
list->firstEntry = elementAfterElementToRemove; list->firstEntry = elementAfterElementToRemove;
} }
if(elementAfterElementToRemove != NULL) { if(elementAfterElementToRemove != NULL) {
elementAfterElementToRemove->prevListEntry = elementAfterElementToRemove->prevListEntry =
elementBeforeElementToRemove; elementBeforeElementToRemove;
} else { } else {
list->lastEntry = elementBeforeElementToRemove; 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 *list_getElementAt(list_t *list, long indexOfElement) {
listEntry_t *currentListEntry; listEntry_t *currentListEntry;
if((list->count / 2) > indexOfElement) { if((list->count / 2) > indexOfElement) {
currentListEntry = list->firstEntry; currentListEntry = list->firstEntry;
for(int i = 0; i < indexOfElement; i++) { for(int i = 0; i < indexOfElement; i++) {
currentListEntry = currentListEntry->nextListEntry; currentListEntry = currentListEntry->nextListEntry;
} }
return currentListEntry; return currentListEntry;
} else { } else {
currentListEntry = list->lastEntry; currentListEntry = list->lastEntry;
for(int i = 1; i < (list->count - indexOfElement); i++) { for(int i = 1; i < (list->count - indexOfElement); i++) {
currentListEntry = currentListEntry->prevListEntry; currentListEntry = currentListEntry->prevListEntry;
} }
return currentListEntry; return currentListEntry;
} }
} }