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

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

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
//
void PetAPI_addPet(apiClient_t *apiClient, pet_t *body);
void
PetAPI_addPet(apiClient_t *apiClient ,pet_t * body);
// Deletes a pet
//
void PetAPI_deletePet(apiClient_t *apiClient, long petId, char *api_key);
void
PetAPI_deletePet(apiClient_t *apiClient ,long petId ,char * api_key);
// Finds Pets by status
//
// Multiple status values can be provided with comma separated strings
//
list_t *PetAPI_findPetsByStatus(apiClient_t *apiClient, list_t *status);
list_t*
PetAPI_findPetsByStatus(apiClient_t *apiClient ,list_t * status);
// Finds Pets by tags
//
// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
//
list_t *PetAPI_findPetsByTags(apiClient_t *apiClient, list_t *tags);
list_t*
PetAPI_findPetsByTags(apiClient_t *apiClient ,list_t * tags);
// Find pet by ID
//
// Returns a single pet
//
pet_t *PetAPI_getPetById(apiClient_t *apiClient, long petId);
pet_t*
PetAPI_getPetById(apiClient_t *apiClient ,long petId);
// Update an existing pet
//
void PetAPI_updatePet(apiClient_t *apiClient, pet_t *body);
void
PetAPI_updatePet(apiClient_t *apiClient ,pet_t * body);
// Updates a pet in the store with form data
//
void PetAPI_updatePetWithForm(apiClient_t *apiClient, long petId, char *name,
char *status);
void
PetAPI_updatePetWithForm(apiClient_t *apiClient ,long petId ,char * name ,char * status);
// uploads an image
//
api_response_t *PetAPI_uploadFile(apiClient_t *apiClient, long petId,
char *additionalMetadata, binary_t *file);
api_response_t*
PetAPI_uploadFile(apiClient_t *apiClient ,long petId ,char * additionalMetadata ,binary_t* file);

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

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

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
//
void StoreAPI_deleteOrder(apiClient_t *apiClient, char *orderId);
void
StoreAPI_deleteOrder(apiClient_t *apiClient ,char * orderId);
// Returns pet inventories by status
//
// Returns a map of status codes to quantities
//
list_t *StoreAPI_getInventory(apiClient_t *apiClient);
list_t*
StoreAPI_getInventory(apiClient_t *apiClient);
// Find purchase order by ID
//
// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
//
order_t *StoreAPI_getOrderById(apiClient_t *apiClient, long orderId);
order_t*
StoreAPI_getOrderById(apiClient_t *apiClient ,long orderId);
// Place an order for a pet
//
order_t *StoreAPI_placeOrder(apiClient_t *apiClient, order_t *body);
order_t*
StoreAPI_placeOrder(apiClient_t *apiClient ,order_t * body);

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

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

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

@ -11,43 +11,53 @@
//
// This can only be done by the logged in user.
//
void UserAPI_createUser(apiClient_t *apiClient, user_t *body);
void
UserAPI_createUser(apiClient_t *apiClient ,user_t * body);
// Creates list of users with given input array
//
void UserAPI_createUsersWithArrayInput(apiClient_t *apiClient, list_t *body);
void
UserAPI_createUsersWithArrayInput(apiClient_t *apiClient ,list_t * body);
// Creates list of users with given input array
//
void UserAPI_createUsersWithListInput(apiClient_t *apiClient, list_t *body);
void
UserAPI_createUsersWithListInput(apiClient_t *apiClient ,list_t * body);
// Delete user
//
// This can only be done by the logged in user.
//
void UserAPI_deleteUser(apiClient_t *apiClient, char *username);
void
UserAPI_deleteUser(apiClient_t *apiClient ,char * username);
// Get user by user name
//
user_t *UserAPI_getUserByName(apiClient_t *apiClient, char *username);
user_t*
UserAPI_getUserByName(apiClient_t *apiClient ,char * username);
// Logs user into the system
//
char *UserAPI_loginUser(apiClient_t *apiClient, char *username, char *password);
char*
UserAPI_loginUser(apiClient_t *apiClient ,char * username ,char * password);
// Logs out current logged in user session
//
void UserAPI_logoutUser(apiClient_t *apiClient);
void
UserAPI_logoutUser(apiClient_t *apiClient);
// Updated user
//
// This can only be done by the logged in user.
//
void UserAPI_updateUser(apiClient_t *apiClient, char *username, user_t *body);
void
UserAPI_updateUser(apiClient_t *apiClient ,char * username ,user_t * body);

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
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifndef cJSON__h
#define cJSON__h
@ -37,94 +37,87 @@ extern "C"
/* cJSON Types: */
#define cJSON_Invalid (0)
#define cJSON_False (1 << 0)
#define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2)
#define cJSON_False (1 << 0)
#define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2)
#define cJSON_Number (1 << 3)
#define cJSON_String (1 << 4)
#define cJSON_Array (1 << 5)
#define cJSON_Array (1 << 5)
#define cJSON_Object (1 << 6)
#define cJSON_Raw (1 << 7) /* raw json */
#define cJSON_Raw (1 << 7) /* raw json */
#define cJSON_IsReference 256
#define cJSON_StringIsConst 512
/* The cJSON structure: */
typedef struct cJSON {
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
struct cJSON *next;
struct cJSON *prev;
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
struct cJSON *child;
typedef struct cJSON
{
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
struct cJSON *next;
struct cJSON *prev;
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
struct cJSON *child;
/* The type of the item, as above. */
int type;
/* The type of the item, as above. */
int type;
/* The item's string, if type==cJSON_String and type == cJSON_Raw */
char *valuestring;
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
int valueint;
/* The item's number, if type==cJSON_Number */
double valuedouble;
/* The item's string, if type==cJSON_String and type == cJSON_Raw */
char *valuestring;
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
int valueint;
/* The item's number, if type==cJSON_Number */
double valuedouble;
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
char *string;
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
char *string;
} cJSON;
typedef struct cJSON_Hooks {
void *(*malloc_fn)(size_t sz);
void (*free_fn)(void *ptr);
typedef struct cJSON_Hooks
{
void *(*malloc_fn)(size_t sz);
void (*free_fn)(void *ptr);
} cJSON_Hooks;
typedef int cJSON_bool;
#if !defined(__WINDOWS__) && \
(defined(WIN32) || \
defined(WIN64) || \
defined(_MSC_VER) || \
defined(_WIN32))
#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
#define __WINDOWS__
#endif
#ifdef __WINDOWS__
/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 2 define options:
CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
For *nix builds that support visibility attribute, you can define similar behavior by
For *nix builds that support visibility attribute, you can define similar behavior by
setting default visibility to hidden by adding
-fvisibility=hidden (for gcc)
or
-xldscope=hidden (for sun cc)
to CFLAGS
setting default visibility to hidden by adding
-fvisibility=hidden (for gcc)
or
-xldscope=hidden (for sun cc)
to CFLAGS
then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
*/
*/
/* export symbols by default, this is necessary for copy pasting the C and header file */
#if !defined(CJSON_HIDE_SYMBOLS) && \
!defined(CJSON_IMPORT_SYMBOLS) && \
!defined(CJSON_EXPORT_SYMBOLS)
#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
#define CJSON_EXPORT_SYMBOLS
#endif
#if defined(CJSON_HIDE_SYMBOLS)
#define CJSON_PUBLIC(type) type __stdcall
#define CJSON_PUBLIC(type) type __stdcall
#elif defined(CJSON_EXPORT_SYMBOLS)
#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall
#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall
#elif defined(CJSON_IMPORT_SYMBOLS)
#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall
#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall
#endif
#else /* !WIN32 */
#if (defined(__GNUC__) || \
defined(__SUNPRO_CC) || \
defined(__SUNPRO_C)) && \
defined(CJSON_API_VISIBILITY)
#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
#else
#define CJSON_PUBLIC(type) type
#endif
@ -137,51 +130,43 @@ typedef int cJSON_bool;
#endif
/* returns the version of cJSON as a string */
CJSON_PUBLIC(const char *) cJSON_Version(void);
CJSON_PUBLIC(const char*) cJSON_Version(void);
/* Supply malloc, realloc and free functions to cJSON */
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks * hooks);
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value,
const char **return_parse_end,
cJSON_bool require_null_terminated);
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
/* Render a cJSON entity to text for transfer/storage. */
CJSON_PUBLIC(char *) cJSON_Print(const cJSON * item);
CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
/* Render a cJSON entity to text for transfer/storage without any formatting. */
CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON * item);
CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON * item, int prebuffer,
cJSON_bool fmt);
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON * item, char *buffer,
const int length,
const cJSON_bool format);
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
/* Delete a cJSON entity and all subentities. */
CJSON_PUBLIC(void) cJSON_Delete(cJSON * c);
CJSON_PUBLIC(void) cJSON_Delete(cJSON *c);
/* Returns the number of items in an array (or object). */
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON * array);
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON * array, int index);
CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
/* Get item "string" from object. Case insensitive. */
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object,
const char *const string);
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(
const cJSON * const object, const char *const string);
CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON * object,
const char *string);
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
/* Check if the item is a string and return its valuestring */
CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON * item);
CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item);
/* These functions check the type of an item */
CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
@ -212,8 +197,8 @@ CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
/* Create an object/arrray that only references it's elements so
* they will not be freed by cJSON_Delete */
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON * child);
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON * child);
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
/* These utilities create an Array of count items. */
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
@ -222,109 +207,64 @@ CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count);
/* Append item to the specified array/object. */
CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON * array, cJSON * item);
CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON * object, const char *string,
cJSON * item);
CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item);
CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
* WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
* writing to `item->string` */
CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON * object, const char *string,
cJSON * item);
CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON * array, cJSON * item);
CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON * object,
const char *string,
cJSON * item);
CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
/* Remove/Detatch items from Arrays/Objects. */
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON * parent,
cJSON * const item);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON * array, int which);
CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON * array, int which);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON * object,
const char *string);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON * object,
const char *string);
CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON * object,
const char *string);
CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON * object,
const char *string);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
/* Update array items. */
CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON * array, int which,
cJSON * newitem); /* Shifts pre-existing items to the right. */
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent,
cJSON * const item,
cJSON * replacement);
CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON * array, int which,
cJSON * newitem);
CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON * object, const char *string,
cJSON * newitem);
CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON * object,
const char *string,
cJSON * newitem);
CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
/* Duplicate a cJSON item */
CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON * item, cJSON_bool recurse);
CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
need to be released. With recurse!=0, it will duplicate any children connected to the item.
The item->next and ->prev pointers are always zero on return from Duplicate. */
need to be released. With recurse!=0, it will duplicate any children connected to the item.
The item->next and ->prev pointers are always zero on return from Duplicate. */
/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
* case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a,
const cJSON * const b,
const cJSON_bool case_sensitive);
CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
CJSON_PUBLIC(void) cJSON_Minify(char *json);
/* Helper functions for creating and adding items to an object at the same time.
* They return the added item or NULL on failure. */
CJSON_PUBLIC(cJSON *) cJSON_AddNullToObject(cJSON * const object,
const char *const name);
CJSON_PUBLIC(cJSON *) cJSON_AddTrueToObject(cJSON * const object,
const char *const name);
CJSON_PUBLIC(cJSON *) cJSON_AddFalseToObject(cJSON * const object,
const char *const name);
CJSON_PUBLIC(cJSON *) cJSON_AddBoolToObject(cJSON * const object,
const char *const name,
const cJSON_bool boolean);
CJSON_PUBLIC(cJSON *) cJSON_AddNumberToObject(cJSON * const object,
const char *const name,
const double number);
CJSON_PUBLIC(cJSON *) cJSON_AddStringToObject(cJSON * const object,
const char *const name,
const char *const string);
CJSON_PUBLIC(cJSON *) cJSON_AddRawToObject(cJSON * const object,
const char *const name,
const char *const raw);
CJSON_PUBLIC(cJSON *) cJSON_AddObjectToObject(cJSON * const object,
const char *const name);
CJSON_PUBLIC(cJSON *) cJSON_AddArrayToObject(cJSON * const object,
const char *const name);
CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
/* When assigning an integer value, it needs to be propagated to valuedouble too. */
#define cJSON_SetIntValue(object, \
number) ((object) ? (object)->valueint = \
(object)->valuedouble = \
(number) : (number))
#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
/* helper for the cJSON_SetNumberValue macro */
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON * object, double number);
#define cJSON_SetNumberValue(object, \
number) ((object != \
NULL) ? cJSON_SetNumberHelper(object, \
( \
double) \
number) : ( \
number))
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
/* Macro for iterating over an array or object */
#define cJSON_ArrayForEach(element, array) for(element = \
(array != \
NULL) ? (array)->child : \
NULL; \
element != NULL; \
element = element->next)
#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
CJSON_PUBLIC(void *) cJSON_malloc(size_t size);

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

@ -10,27 +10,24 @@
#include "../include/keyValuePair.h"
typedef struct apiClient_t {
char *basePath;
void *dataReceived;
long response_code;
list_t *apiKeys;
char *accessToken;
char *basePath;
void *dataReceived;
long response_code;
list_t *apiKeys;
char *accessToken;
} apiClient_t;
typedef struct binary_t {
uint8_t *data;
unsigned int len;
typedef struct binary_t
{
uint8_t* data;
unsigned int len;
} binary_t;
apiClient_t *apiClient_create();
apiClient_t* apiClient_create();
void apiClient_free(apiClient_t *apiClient);
void apiClient_invoke(apiClient_t *apiClient, char *operationParameter,
list_t *queryParameters, list_t *headerParameters,
list_t *formParameters, list_t *headerType,
list_t *contentType, char *bodyParameters,
char *requestType);
void apiClient_invoke(apiClient_t *apiClient,char* operationParameter, list_t *queryParameters, list_t *headerParameters, list_t *formParameters,list_t *headerType,list_t *contentType, char *bodyParameters, char *requestType);
char *strReplace(char *orig, char *rep, char *with);

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

@ -1,11 +1,11 @@
#ifndef _keyValuePair_H_
#define _keyValuePair_H_
#include <string.h>
#include<string.h>
typedef struct keyValuePair_t {
char *key;
void *value;
char* key;
void* value;
} keyValuePair_t;
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;
struct listEntry_t {
listEntry_t *nextListEntry;
listEntry_t *prevListEntry;
void *data;
listEntry_t* nextListEntry;
listEntry_t* prevListEntry;
void* data;
};
typedef struct list_t {
listEntry_t *firstEntry;
listEntry_t *lastEntry;
listEntry_t *firstEntry;
listEntry_t *lastEntry;
long count;
long count;
} list_t;
#define list_ForEach(element, list) for(element = \
(list != \
NULL) ? (list)->firstEntry : \
NULL; \
element != NULL; \
element = element->nextListEntry)
#define list_ForEach(element, list) for(element = (list != NULL) ? (list)->firstEntry : NULL; element != NULL; element = element->nextListEntry)
list_t *list_create();
void list_free(list_t *listToFree);
list_t* list_create();
void list_free(list_t* listToFree);
void list_addElement(list_t *list, void *dataToAddInList);
listEntry_t *list_getElementAt(list_t *list, long indexOfElement);
listEntry_t *list_getWithIndex(list_t *list, int index);
void list_removeElement(list_t *list, listEntry_t *elementToRemove);
void list_addElement(list_t* list, void* dataToAddInList);
listEntry_t* list_getElementAt(list_t *list, long indexOfElement);
listEntry_t* list_getWithIndex(list_t* list, int index);
void list_removeElement(list_t* list, listEntry_t* elementToRemove);
void list_iterateThroughListForward(list_t *list, void (*operationToPerform)(
listEntry_t *,
void *), void *additionalDataNeededForCallbackFunction);
void list_iterateThroughListBackward(list_t *list, void (*operationToPerform)(
listEntry_t *,
void *), void *additionalDataNeededForCallbackFunction);
void list_iterateThroughListForward(list_t* list, void (*operationToPerform)(listEntry_t*, void*), void *additionalDataNeededForCallbackFunction);
void list_iterateThroughListBackward(list_t* list, void (*operationToPerform)(listEntry_t*, void*), void *additionalDataNeededForCallbackFunction);
void listEntry_printAsInt(listEntry_t *listEntry, void *additionalData);
void listEntry_printAsInt(listEntry_t* listEntry, void *additionalData);
void listEntry_free(listEntry_t *listEntry, void *additionalData);
#endif // INCLUDE_LIST_H

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

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

@ -15,12 +15,17 @@
typedef struct api_response_t {
int code; // numeric
char *type; // string
char *message; // string
int code; //numeric
char *type; // string
char *message; // string
} api_response_t;
api_response_t *api_response_create(int code, char *type, char *message);
api_response_t *api_response_create(
int code,
char *type,
char *message
);
void api_response_free(api_response_t *api_response);
@ -29,3 +34,4 @@ api_response_t *api_response_parseFromJSON(cJSON *api_responseJSON);
cJSON *api_response_convertToJSON(api_response_t *api_response);
#endif /* _api_response_H_ */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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);
apiClient_t *apiClient_create() {
curl_global_init(CURL_GLOBAL_ALL);
apiClient_t *apiClient = malloc(sizeof(apiClient_t));
apiClient->basePath = "http://petstore.swagger.io/v2";
apiClient->dataReceived = NULL;
apiClient->response_code = 0;
apiClient->apiKeys = NULL;
apiClient->accessToken = NULL;
curl_global_init(CURL_GLOBAL_ALL);
apiClient_t *apiClient = malloc(sizeof(apiClient_t));
apiClient->basePath = "http://petstore.swagger.io/v2";
apiClient->dataReceived = NULL;
apiClient->response_code = 0;
apiClient->apiKeys = NULL;
apiClient->accessToken = NULL;
return apiClient;
return apiClient;
}
void apiClient_free(apiClient_t *apiClient) {
if(apiClient->accessToken) {
list_free(apiClient->apiKeys);
}
if(apiClient->accessToken) {
free(apiClient->accessToken);
}
free(apiClient);
curl_global_cleanup();
if(apiClient->accessToken) {
list_free(apiClient->apiKeys);
}
if(apiClient->accessToken) {
free(apiClient->accessToken);
}
free(apiClient);
curl_global_cleanup();
}
void replaceSpaceWithPlus(char *stringToProcess) {
for(int i = 0; i < strlen(stringToProcess); i++) {
if(stringToProcess[i] == ' ') {
stringToProcess[i] = '+';
}
}
for(int i = 0; i < strlen(stringToProcess); i++) {
if(stringToProcess[i] == ' ') {
stringToProcess[i] = '+';
}
}
}
char *assembleTargetUrl(char *basePath, char *operationParameter,
list_t *queryParameters) {
int neededBufferSizeForQueryParameters = 0;
listEntry_t *listEntry;
char *assembleTargetUrl(char *basePath,
char *operationParameter,
list_t *queryParameters) {
int neededBufferSizeForQueryParameters = 0;
listEntry_t *listEntry;
if(queryParameters != NULL) {
list_ForEach(listEntry, queryParameters) {
keyValuePair_t *pair = listEntry->data;
neededBufferSizeForQueryParameters +=
strlen(pair->key) + strlen(pair->value);
}
if(queryParameters != NULL) {
list_ForEach(listEntry, queryParameters) {
keyValuePair_t *pair = listEntry->data;
neededBufferSizeForQueryParameters +=
strlen(pair->key) + strlen(pair->value);
}
neededBufferSizeForQueryParameters +=
(queryParameters->count * 2); // each keyValuePair is separated by a = and a & except the last, but this makes up for the ? at the beginning
}
neededBufferSizeForQueryParameters +=
(queryParameters->count * 2); // each keyValuePair is separated by a = and a & except the last, but this makes up for the ? at the beginning
}
int operationParameterLength = 0;
int basePathLength = strlen(basePath);
bool slashNeedsToBeAppendedToBasePath = false;
int operationParameterLength = 0;
int basePathLength = strlen(basePath);
bool slashNeedsToBeAppendedToBasePath = false;
if(operationParameter != NULL) {
operationParameterLength = (1 + strlen(operationParameter));
}
if(basePath[strlen(basePath) - 1] != '/') {
slashNeedsToBeAppendedToBasePath = true;
basePathLength++;
}
if(operationParameter != NULL) {
operationParameterLength = (1 + strlen(operationParameter));
}
if(basePath[strlen(basePath) - 1] != '/') {
slashNeedsToBeAppendedToBasePath = true;
basePathLength++;
}
char *targetUrl =
malloc(
neededBufferSizeForQueryParameters + basePathLength + operationParameterLength +
1);
char *targetUrl =
malloc(
neededBufferSizeForQueryParameters + basePathLength + operationParameterLength +
1);
strcpy(targetUrl, basePath);
strcpy(targetUrl, basePath);
if(operationParameter != NULL) {
strcat(targetUrl, operationParameter);
}
if(operationParameter != NULL) {
strcat(targetUrl, operationParameter);
}
if(queryParameters != NULL) {
strcat(targetUrl, "?");
list_ForEach(listEntry, queryParameters) {
keyValuePair_t *pair = listEntry->data;
replaceSpaceWithPlus(pair->key);
strcat(targetUrl, pair->key);
strcat(targetUrl, "=");
replaceSpaceWithPlus(pair->value);
strcat(targetUrl, pair->value);
if(listEntry->nextListEntry != NULL) {
strcat(targetUrl, "&");
}
}
}
if(queryParameters != NULL) {
strcat(targetUrl, "?");
list_ForEach(listEntry, queryParameters) {
keyValuePair_t *pair = listEntry->data;
replaceSpaceWithPlus(pair->key);
strcat(targetUrl, pair->key);
strcat(targetUrl, "=");
replaceSpaceWithPlus(pair->value);
strcat(targetUrl, pair->value);
if(listEntry->nextListEntry != NULL) {
strcat(targetUrl, "&");
}
}
}
return targetUrl;
return targetUrl;
}
char *assembleHeaderField(char *key, char *value) {
char *header = malloc(strlen(key) + strlen(value) + 3);
char *header = malloc(strlen(key) + strlen(value) + 3);
strcpy(header, key),
strcat(header, ": ");
strcat(header, value);
strcpy(header, key),
strcat(header, ": ");
strcat(header, value);
return header;
return header;
}
void postData(CURL *handle, char *bodyParameters) {
curl_easy_setopt(handle, CURLOPT_POSTFIELDS, bodyParameters);
curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE_LARGE,
strlen(bodyParameters));
curl_easy_setopt(handle, CURLOPT_POSTFIELDS, bodyParameters);
curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE_LARGE,
strlen(bodyParameters));
}
int lengthOfKeyPair(keyValuePair_t *keyPair) {
long length = 0;
if((keyPair->key != NULL) &&
(keyPair->value != NULL) )
{
length = strlen(keyPair->key) + strlen(keyPair->value);
return length;
}
return 0;
long length = 0;
if((keyPair->key != NULL) &&
(keyPair->value != NULL) )
{
length = strlen(keyPair->key) + strlen(keyPair->value);
return length;
}
return 0;
}
void apiClient_invoke(apiClient_t *apiClient, char *operationParameter,
list_t *queryParameters, list_t *headerParameters,
list_t *formParameters, list_t *headerType,
list_t *contentType, char *bodyParameters,
char *requestType) {
CURL *handle = curl_easy_init();
CURLcode res;
void apiClient_invoke(apiClient_t *apiClient,
char *operationParameter,
list_t *queryParameters,
list_t *headerParameters,
list_t *formParameters,
list_t *headerType,
list_t *contentType,
char *bodyParameters,
char *requestType) {
CURL *handle = curl_easy_init();
CURLcode res;
if(handle) {
listEntry_t *listEntry;
curl_mime *mime = NULL;
struct curl_slist *headers = NULL;
char *buffContent = NULL;
char *buffHeader = NULL;
binary_t *fileVar = NULL;
char *formString = NULL;
if(handle) {
listEntry_t *listEntry;
curl_mime *mime = NULL;
struct curl_slist *headers = NULL;
char *buffContent = NULL;
char *buffHeader = NULL;
binary_t *fileVar = NULL;
char *formString = NULL;
if(headerType != NULL) {
list_ForEach(listEntry, headerType) {
if(strstr((char *) listEntry->data,
"xml") == NULL)
{
buffHeader = malloc(strlen(
"Accept: ") +
strlen((char *)
listEntry->
data) + 1);
sprintf(buffHeader, "%s%s", "Accept: ",
(char *) listEntry->data);
headers = curl_slist_append(headers,
buffHeader);
free(buffHeader);
}
}
}
if(contentType != NULL) {
list_ForEach(listEntry, contentType) {
if(strstr((char *) listEntry->data,
"xml") == NULL)
{
buffContent =
malloc(strlen(
"Content-Type: ") + strlen(
(char *)
listEntry->data) +
1);
sprintf(buffContent, "%s%s",
"Content-Type: ",
(char *) listEntry->data);
headers = curl_slist_append(headers,
buffContent);
}
}
} else {
headers = curl_slist_append(headers,
"Content-Type: application/json");
}
if(headerType != NULL) {
list_ForEach(listEntry, headerType) {
if(strstr((char *) listEntry->data,
"xml") == NULL)
{
buffHeader = malloc(strlen(
"Accept: ") +
strlen((char *)
listEntry->
data) + 1);
sprintf(buffHeader, "%s%s", "Accept: ",
(char *) listEntry->data);
headers = curl_slist_append(headers,
buffHeader);
free(buffHeader);
}
}
}
if(contentType != NULL) {
list_ForEach(listEntry, contentType) {
if(strstr((char *) listEntry->data,
"xml") == NULL)
{
buffContent =
malloc(strlen(
"Content-Type: ") + strlen(
(char *)
listEntry->data) +
1);
sprintf(buffContent, "%s%s",
"Content-Type: ",
(char *) listEntry->data);
headers = curl_slist_append(headers,
buffContent);
}
}
} else {
headers = curl_slist_append(headers,
"Content-Type: application/json");
}
if(requestType != NULL) {
curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST,
requestType);
}
if(requestType != NULL) {
curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST,
requestType);
}
if(formParameters != NULL) {
if(strstr(buffContent,
"application/x-www-form-urlencoded") != NULL)
{
long parameterLength = 0;
long keyPairLength = 0;
list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyPair =
listEntry->data;
if(formParameters != NULL) {
if(strstr(buffContent,
"application/x-www-form-urlencoded") != NULL)
{
long parameterLength = 0;
long keyPairLength = 0;
list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyPair =
listEntry->data;
keyPairLength =
lengthOfKeyPair(keyPair) + 1;
keyPairLength =
lengthOfKeyPair(keyPair) + 1;
if(listEntry->nextListEntry != NULL) {
parameterLength++;
}
parameterLength = parameterLength +
keyPairLength;
}
if(listEntry->nextListEntry != NULL) {
parameterLength++;
}
parameterLength = parameterLength +
keyPairLength;
}
formString = malloc(parameterLength + 1);
memset(formString, 0, parameterLength + 1);
formString = malloc(parameterLength + 1);
memset(formString, 0, parameterLength + 1);
list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyPair =
listEntry->data;
if((keyPair->key != NULL) &&
(keyPair->value != NULL) )
{
strcat(formString,
keyPair->key);
strcat(formString, "=");
strcat(formString,
keyPair->value);
if(listEntry->nextListEntry !=
NULL)
{
strcat(formString, "&");
}
}
}
curl_easy_setopt(handle, CURLOPT_POSTFIELDS,
formString);
}
if(strstr(buffContent, "multipart/form-data") != NULL) {
mime = curl_mime_init(handle);
list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyValuePair =
listEntry->data;
list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyPair =
listEntry->data;
if((keyPair->key != NULL) &&
(keyPair->value != NULL) )
{
strcat(formString,
keyPair->key);
strcat(formString, "=");
strcat(formString,
keyPair->value);
if(listEntry->nextListEntry !=
NULL)
{
strcat(formString, "&");
}
}
}
curl_easy_setopt(handle, CURLOPT_POSTFIELDS,
formString);
}
if(strstr(buffContent, "multipart/form-data") != NULL) {
mime = curl_mime_init(handle);
list_ForEach(listEntry, formParameters) {
keyValuePair_t *keyValuePair =
listEntry->data;
if((keyValuePair->key != NULL) &&
(keyValuePair->value != NULL) )
{
curl_mimepart *part =
curl_mime_addpart(mime);
if((keyValuePair->key != NULL) &&
(keyValuePair->value != NULL) )
{
curl_mimepart *part =
curl_mime_addpart(mime);
curl_mime_name(part,
keyValuePair->key);
curl_mime_name(part,
keyValuePair->key);
if(strcmp(keyValuePair->key,
"file") == 0)
{
memcpy(&fileVar,
keyValuePair->value,
sizeof(fileVar));
curl_mime_data(part,
fileVar->data,
fileVar->len);
curl_mime_filename(part,
"image.png");
} else {
curl_mime_data(part,
keyValuePair->value,
CURL_ZERO_TERMINATED);
}
}
}
curl_easy_setopt(handle, CURLOPT_MIMEPOST,
mime);
}
}
if(strcmp(keyValuePair->key,
"file") == 0)
{
memcpy(&fileVar,
keyValuePair->value,
sizeof(fileVar));
curl_mime_data(part,
fileVar->data,
fileVar->len);
curl_mime_filename(part,
"image.png");
} else {
curl_mime_data(part,
keyValuePair->value,
CURL_ZERO_TERMINATED);
}
}
}
curl_easy_setopt(handle, CURLOPT_MIMEPOST,
mime);
}
}
list_ForEach(listEntry, headerParameters) {
keyValuePair_t *keyValuePair = listEntry->data;
if((keyValuePair->key != NULL) &&
(keyValuePair->value != NULL) )
{
char *headerValueToWrite = assembleHeaderField(
keyValuePair->key, keyValuePair->value);
curl_slist_append(headers, headerValueToWrite);
free(headerValueToWrite);
}
}
// this would only be generated for apiKey authentication
if(apiClient->apiKeys != NULL) {
list_ForEach(listEntry, apiClient->apiKeys) {
keyValuePair_t *apiKey = listEntry->data;
if((apiKey->key != NULL) &&
(apiKey->value != NULL) )
{
char *headerValueToWrite =
assembleHeaderField(
apiKey->key,
apiKey->value);
curl_slist_append(headers,
headerValueToWrite);
free(headerValueToWrite);
}
}
}
list_ForEach(listEntry, headerParameters) {
keyValuePair_t *keyValuePair = listEntry->data;
if((keyValuePair->key != NULL) &&
(keyValuePair->value != NULL) )
{
char *headerValueToWrite = assembleHeaderField(
keyValuePair->key, keyValuePair->value);
curl_slist_append(headers, headerValueToWrite);
free(headerValueToWrite);
}
}
// this would only be generated for apiKey authentication
if (apiClient->apiKeys != NULL)
{
list_ForEach(listEntry, apiClient->apiKeys) {
keyValuePair_t *apiKey = listEntry->data;
if((apiKey->key != NULL) &&
(apiKey->value != NULL) )
{
char *headerValueToWrite = assembleHeaderField(
apiKey->key, apiKey->value);
curl_slist_append(headers, headerValueToWrite);
free(headerValueToWrite);
}
}
}
char *targetUrl =
assembleTargetUrl(apiClient->basePath,
operationParameter,
queryParameters);
char *targetUrl =
assembleTargetUrl(apiClient->basePath,
operationParameter,
queryParameters);
curl_easy_setopt(handle, CURLOPT_URL, targetUrl);
curl_easy_setopt(handle,
CURLOPT_WRITEFUNCTION,
writeDataCallback);
curl_easy_setopt(handle,
CURLOPT_WRITEDATA,
&apiClient->dataReceived);
curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(handle, CURLOPT_VERBOSE, 0); // to get curl debug msg 0: to disable, 1L:to enable
curl_easy_setopt(handle, CURLOPT_URL, targetUrl);
curl_easy_setopt(handle,
CURLOPT_WRITEFUNCTION,
writeDataCallback);
curl_easy_setopt(handle,
CURLOPT_WRITEDATA,
&apiClient->dataReceived);
curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(handle, CURLOPT_VERBOSE, 0); // to get curl debug msg 0: to disable, 1L:to enable
// this would only be generated for OAuth2 authentication
if(apiClient->accessToken != NULL) {
// curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BEARER);
curl_easy_setopt(handle,
CURLOPT_XOAUTH2_BEARER,
apiClient->accessToken);
}
// this would only be generated for OAuth2 authentication
if(apiClient->accessToken != NULL) {
// curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_BEARER);
curl_easy_setopt(handle,
CURLOPT_XOAUTH2_BEARER,
apiClient->accessToken);
}
if(bodyParameters != NULL) {
postData(handle, bodyParameters);
}
if(bodyParameters != NULL) {
postData(handle, bodyParameters);
}
res = curl_easy_perform(handle);
res = curl_easy_perform(handle);
curl_slist_free_all(headers);
curl_slist_free_all(headers);
free(targetUrl);
free(targetUrl);
if(contentType != NULL) {
free(buffContent);
}
if(contentType != NULL) {
free(buffContent);
}
if(res == CURLE_OK) {
curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE,
&apiClient->response_code);
} else {
char *url, *ip, *scheme;
long port;
curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url);
curl_easy_getinfo(handle, CURLINFO_PRIMARY_IP, &ip);
curl_easy_getinfo(handle, CURLINFO_PRIMARY_PORT, &port);
curl_easy_getinfo(handle, CURLINFO_SCHEME, &scheme);
fprintf(stderr,
"curl_easy_perform() failed\n\nURL: %s\nIP: %s\nPORT: %li\nSCHEME: %s\nStrERROR: %s\n", url, ip, port, scheme,
curl_easy_strerror(res));
}
if(res == CURLE_OK) {
curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &apiClient->response_code);
} else {
char *url,*ip,*scheme;
long port;
curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url);
curl_easy_getinfo(handle, CURLINFO_PRIMARY_IP, &ip);
curl_easy_getinfo(handle, CURLINFO_PRIMARY_PORT, &port);
curl_easy_getinfo(handle, CURLINFO_SCHEME, &scheme);
fprintf(stderr, "curl_easy_perform() failed\n\nURL: %s\nIP: %s\nPORT: %li\nSCHEME: %s\nStrERROR: %s\n",url,ip,port,scheme,
curl_easy_strerror(res));
}
curl_easy_cleanup(handle);
if(formParameters != NULL) {
free(formString);
curl_mime_free(mime);
}
}
curl_easy_cleanup(handle);
if(formParameters != NULL) {
free(formString);
curl_mime_free(mime);
}
}
}
size_t writeDataCallback(void *buffer, size_t size, size_t nmemb, void *userp) {
*(char **) userp = strdup(buffer);
*(char **) userp = strdup(buffer);
return size * nmemb;
return size * nmemb;
}
char *strReplace(char *orig, char *rep, char *with) {
char *result; // the return string
char *ins; // the next insert point
char *tmp; // varies
int lenRep; // length of rep (the string to remove)
int lenWith; // length of with (the string to replace rep with)
int lenFront; // distance between rep and end of last rep
int count; // number of replacements
char *result; // the return string
char *ins; // the next insert point
char *tmp; // varies
int lenRep; // length of rep (the string to remove)
int lenWith; // length of with (the string to replace rep with)
int lenFront; // distance between rep and end of last rep
int count; // number of replacements
// sanity checks and initialization
if(!orig ||
!rep)
{
return NULL;
}
lenRep = strlen(rep);
if(lenRep == 0) {
return NULL; // empty rep causes infinite loop during count
}
if(!with) {
with = "";
}
lenWith = strlen(with);
// sanity checks and initialization
if(!orig || !rep)
{
return NULL;
}
lenRep = strlen(rep);
if(lenRep == 0) {
return NULL; // empty rep causes infinite loop during count
}
if(!with) {
with = "";
}
lenWith = strlen(with);
// count the number of replacements needed
ins = orig;
for(count = 0; tmp = strstr(ins, rep); ++count) {
ins = tmp + lenRep;
}
// count the number of replacements needed
ins = orig;
for(count = 0; tmp = strstr(ins, rep); ++count) {
ins = tmp + lenRep;
}
tmp = result = malloc(strlen(orig) + (lenWith - lenRep) * count + 1);
tmp = result = malloc(strlen(orig) + (lenWith - lenRep) * count + 1);
if(!result) {
return NULL;
}
char *originalPointer = orig; // copying original pointer to free the memory
// first time through the loop, all the variable are set correctly
// from here on,
// tmp points to the end of the result string
// ins points to the next occurrence of rep in orig
// orig points to the remainder of orig after "end of rep"
while(count--) {
ins = strstr(orig, rep);
lenFront = ins - orig;
tmp = strncpy(tmp, orig, lenFront) + lenFront;
tmp = strcpy(tmp, with) + lenWith;
orig += lenFront + lenRep; // move to next "end of rep"
}
strcpy(tmp, orig);
free(originalPointer);
return result;
if(!result) {
return NULL;
}
char *originalPointer = orig; // copying original pointer to free the memory
// first time through the loop, all the variable are set correctly
// from here on,
// tmp points to the end of the result string
// ins points to the next occurrence of rep in orig
// orig points to the remainder of orig after "end of rep"
while(count--) {
ins = strstr(orig, rep);
lenFront = ins - orig;
tmp = strncpy(tmp, orig, lenFront) + lenFront;
tmp = strcpy(tmp, with) + lenWith;
orig += lenFront + lenRep; // move to next "end of rep"
}
strcpy(tmp, orig);
free(originalPointer);
return result;
}
char *sbi_base64encode(const void *b64_encode_this,
int encode_this_many_bytes) {
char *sbi_base64encode (const void *b64_encode_this, int encode_this_many_bytes){
#ifdef OPENSSL
BIO *b64_bio, *mem_bio; // Declares two OpenSSL BIOs: a base64 filter and a memory BIO.
BUF_MEM *mem_bio_mem_ptr; // Pointer to a "memory BIO" structure holding our base64 data.
b64_bio = BIO_new(BIO_f_base64()); // Initialize our base64 filter BIO.
mem_bio = BIO_new(BIO_s_mem()); // Initialize our memory sink BIO.
BIO_push(b64_bio, mem_bio); // Link the BIOs by creating a filter-sink BIO chain.
BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); // No newlines every 64 characters or less.
BIO_write(b64_bio, b64_encode_this, encode_this_many_bytes); // Records base64 encoded data.
BIO_flush(b64_bio); // Flush data. Necessary for b64 encoding, because of pad characters.
BIO_get_mem_ptr(mem_bio, &mem_bio_mem_ptr); // Store address of mem_bio's memory structure.
BIO_set_close(mem_bio, BIO_NOCLOSE); // Permit access to mem_ptr after BIOs are destroyed.
BIO_free_all(b64_bio); // Destroys all BIOs in chain, starting with b64 (i.e. the 1st one).
BUF_MEM_grow(mem_bio_mem_ptr, (*mem_bio_mem_ptr).length + 1); // Makes space for end null.
(*mem_bio_mem_ptr).data[(*mem_bio_mem_ptr).length] = '\0'; // Adds null-terminator to tail.
return (*mem_bio_mem_ptr).data; // Returns base-64 encoded data. (See: "buf_mem_st" struct).
BIO *b64_bio, *mem_bio; //Declares two OpenSSL BIOs: a base64 filter and a memory BIO.
BUF_MEM *mem_bio_mem_ptr; //Pointer to a "memory BIO" structure holding our base64 data.
b64_bio = BIO_new(BIO_f_base64()); //Initialize our base64 filter BIO.
mem_bio = BIO_new(BIO_s_mem()); //Initialize our memory sink BIO.
BIO_push(b64_bio, mem_bio); //Link the BIOs by creating a filter-sink BIO chain.
BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); //No newlines every 64 characters or less.
BIO_write(b64_bio, b64_encode_this, encode_this_many_bytes); //Records base64 encoded data.
BIO_flush(b64_bio); //Flush data. Necessary for b64 encoding, because of pad characters.
BIO_get_mem_ptr(mem_bio, &mem_bio_mem_ptr); //Store address of mem_bio's memory structure.
BIO_set_close(mem_bio, BIO_NOCLOSE); //Permit access to mem_ptr after BIOs are destroyed.
BIO_free_all(b64_bio); //Destroys all BIOs in chain, starting with b64 (i.e. the 1st one).
BUF_MEM_grow(mem_bio_mem_ptr, (*mem_bio_mem_ptr).length + 1); //Makes space for end null.
(*mem_bio_mem_ptr).data[(*mem_bio_mem_ptr).length] = '\0'; //Adds null-terminator to tail.
return (*mem_bio_mem_ptr).data; //Returns base-64 encoded data. (See: "buf_mem_st" struct).
#endif
}
char *sbi_base64decode(const void *b64_decode_this,
int decode_this_many_bytes) {
char *sbi_base64decode (const void *b64_decode_this, int decode_this_many_bytes){
#ifdef OPENSSL
BIO *b64_bio, *mem_bio; // Declares two OpenSSL BIOs: a base64 filter and a memory BIO.
char *base64_decoded = calloc( (decode_this_many_bytes * 3) / 4 + 1,
sizeof(char) ); // +1 = null.
b64_bio = BIO_new(BIO_f_base64()); // Initialize our base64 filter BIO.
mem_bio = BIO_new(BIO_s_mem()); // Initialize our memory source BIO.
BIO_write(mem_bio, b64_decode_this, decode_this_many_bytes); // Base64 data saved in source.
BIO_push(b64_bio, mem_bio); // Link the BIOs by creating a filter-source BIO chain.
BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); // Don't require trailing newlines.
int decoded_byte_index = 0; // Index where the next base64_decoded byte should be written.
while(0 < BIO_read(b64_bio, base64_decoded + decoded_byte_index, 1) ) { // Read byte-by-byte.
decoded_byte_index++; // Increment the index until read of BIO decoded data is complete.
} // Once we're done reading decoded data, BIO_read returns -1 even though there's no error.
BIO_free_all(b64_bio); // Destroys all BIOs in chain, starting with b64 (i.e. the 1st one).
return base64_decoded; // Returns base-64 decoded data with trailing null terminator.
BIO *b64_bio, *mem_bio; //Declares two OpenSSL BIOs: a base64 filter and a memory BIO.
char *base64_decoded = calloc( (decode_this_many_bytes*3)/4+1, sizeof(char) ); //+1 = null.
b64_bio = BIO_new(BIO_f_base64()); //Initialize our base64 filter BIO.
mem_bio = BIO_new(BIO_s_mem()); //Initialize our memory source BIO.
BIO_write(mem_bio, b64_decode_this, decode_this_many_bytes); //Base64 data saved in source.
BIO_push(b64_bio, mem_bio); //Link the BIOs by creating a filter-source BIO chain.
BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL); //Don't require trailing newlines.
int decoded_byte_index = 0; //Index where the next base64_decoded byte should be written.
while ( 0 < BIO_read(b64_bio, base64_decoded+decoded_byte_index, 1) ){ //Read byte-by-byte.
decoded_byte_index++; //Increment the index until read of BIO decoded data is complete.
} //Once we're done reading decoded data, BIO_read returns -1 even though there's no error.
BIO_free_all(b64_bio); //Destroys all BIOs in chain, starting with b64 (i.e. the 1st one).
return base64_decoded; //Returns base-64 decoded data with trailing null terminator.
#endif
}

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

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

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

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