loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity
Files
ecf924e78f3c791cf35ff1e51799799e29d1d2ea
openapi-generator/modules/swagger-codegen/src/main/resources/cpprest/model-source.mustache
stkrwork 025bf3aa80 Final fix for cpprest for issue #5862 (#5893) 
* - Added Restbed Generator

* - Added Json processing functions to model
- Removed unnused code from restbed codegen class
- Added response header processing to api template

* Changed it to respect alphabetical order

* Made the string joining java 7 compatible

* Added samples

* First step in fixing the cpp rest template
regenerated new samples

TODO: Fix the other functions

* Updated samples

* Added isMapContainer check

* Fixed item selection in json object for MapContainer

* - Fixed Syntax error in C++
- Fixed Syntax error in Mustache, that escaped characters
2017-06-22 23:00:54 +08:00

599 lines
18 KiB
Plaintext
Raw Blame History

{{>licenseInfo}}
{{#models}}{{#model}}
#include "{{classname}}.h"
{{#modelNamespaceDeclarations}}
namespace {{this}} {
{{/modelNamespaceDeclarations}}
{{classname}}::{{classname}}()
{
{{#vars}}
{{^isInherited}}
{{#isNotContainer}}
{{#isPrimitiveType}}
m_{{name}} = {{{defaultValue}}};
{{/isPrimitiveType}}
{{^isPrimitiveType}}
{{#isString}}
m_{{name}} = {{{defaultValue}}};
{{/isString}}
{{#isDateTime}}
m_{{name}} = {{{defaultValue}}};
{{/isDateTime}}
{{/isPrimitiveType}}
{{/isNotContainer}}
{{^required}}
m_{{name}}IsSet = false;
{{/required}}
{{/isInherited}}
{{/vars}}
}
{{classname}}::~{{classname}}()
{
}
void {{classname}}::validate()
{
// TODO: implement validation
}
web::json::value {{classname}}::toJson() const
{
{{#parent}}
web::json::value val = this->{{{parent}}}::toJson();
{{/parent}}
{{^parent}}
web::json::value val = web::json::value::object();
{{/parent}}
{{#vars}}
{{^isInherited}}
{{#isPrimitiveType}}
{{^isListContainer}}
{{^isMapContainer}}
{{^required}}
if(m_{{name}}IsSet)
{
val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
}
{{/required}}
{{#required}}
val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
{{/required}}
{{/isMapContainer}}
{{/isListContainer}}
{{/isPrimitiveType}}
{{#isListContainer}}
{
std::vector<web::json::value> jsonArray;
for( auto& item : m_{{name}} )
{
jsonArray.push_back(ModelBase::toJson(item));
}
{{#required}}
val[U("{{baseName}}")] = web::json::value::array(jsonArray);
{{/required}}
{{^required}}
if(jsonArray.size() > 0)
{
val[U("{{baseName}}")] = web::json::value::array(jsonArray);
}
{{/required}}
}
{{/isListContainer}}
{{#isMapContainer}}
{
std::vector<web::json::value> jsonArray;
for( auto& item : m_{{name}} )
{
web::json::value tmp = web::json::value::object();
tmp[U("key")] = ModelBase::toJson(item.first);
tmp[U("value")] = ModelBase::toJson(item.second);
jsonArray.push_back(tmp);
}
{{#required}}
val[U("{{baseName}}")] = web::json::value::array(jsonArray);
{{/required}}
{{^required}}
if(jsonArray.size() > 0)
{
val[U("{{baseName}}")] = web::json::value::array(jsonArray);
}
{{/required}}
}
{{/isMapContainer}}
{{^isListContainer}}
{{^isMapContainer}}
{{^isPrimitiveType}}
{{^required}}
if(m_{{name}}IsSet)
{
val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
}
{{/required}}
{{#required}}
val[U("{{baseName}}")] = ModelBase::toJson(m_{{name}});
{{/required}}
{{/isPrimitiveType}}
{{/isMapContainer}}
{{/isListContainer}}
{{/isInherited}}
{{/vars}}
return val;
}
void {{classname}}::fromJson(web::json::value& val)
{
{{#parent}}
this->{{{parent}}}::fromJson(val);
{{/parent}}
{{#vars}}
{{^isInherited}}
{{#isPrimitiveType}}
{{^isListContainer}}
{{^isMapContainer}}
{{^required}}
if(val.has_field(U("{{baseName}}")))
{
{{setter}}(ModelBase::{{baseType}}FromJson(val[U("{{baseName}}")]));
}
{{/required}}
{{#required}}
{{setter}}(ModelBase::{{baseType}}FromJson(val[U("{{baseName}}")]));
{{/required}}
{{/isMapContainer}}
{{/isListContainer}}
{{/isPrimitiveType}}
{{#isListContainer}}
{
m_{{name}}.clear();
std::vector<web::json::value> jsonArray;
{{^required}}
if(val.has_field(U("{{baseName}}")))
{
{{/required}}
for( auto& item : val[U("{{baseName}}")].as_array() )
{
{{#items.isPrimitiveType}}
m_{{name}}.push_back(ModelBase::{{items.baseType}}FromJson(item));
{{/items.isPrimitiveType}}
{{^items.isPrimitiveType}}
{{#items.isString}}
m_{{name}}.push_back(ModelBase::stringFromJson(item));
{{/items.isString}}
{{^items.isString}}
{{#items.isDateTime}}
m_{{name}}.push_back(ModelBase::dateFromJson(item));
{{/items.isDateTime}}
{{^items.isDateTime}}
if(item.is_null())
{
m_{{name}}.push_back( {{{items.datatype}}}(nullptr) );
}
else
{
{{{items.datatype}}} newItem({{{items.defaultValue}}});
newItem->fromJson(item);
m_{{name}}.push_back( newItem );
}
{{/items.isDateTime}}
{{/items.isString}}
{{/items.isPrimitiveType}}
}
{{^required}}
}
{{/required}}
}
{{/isListContainer}}
{{#isMapContainer}}
{
m_{{name}}.clear();
std::vector<web::json::value> jsonArray;
{{^required}}
if(val.has_field(U("{{baseName}}")))
{
{{/required}}
for( auto& item : val[U("{{baseName}}")].as_array() )
{
utility::string_t key;
if(item.has_field(U("key")))
{
key = ModelBase::stringFromJson(item[U("key")]);
}
{{#items.isPrimitiveType}}
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::{{items.baseType}}FromJson(item[U("value")])));
{{/items.isPrimitiveType}}
{{^items.isPrimitiveType}}
{{#items.isString}}
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::stringFromJson(item[U("value")])));
{{/items.isString}}
{{^items.isString}}
{{#items.isDateTime}}
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::dateFromJson(item[U("value")])));
{{/items.isDateTime}}
{{^items.isDateTime}}
if(item.is_null())
{
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, {{{items.datatype}}}(nullptr) ));
}
else
{
{{{items.datatype}}} newItem({{{items.defaultValue}}});
newItem->fromJson(item[U("value")]);
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, newItem ));
}
{{/items.isDateTime}}
{{/items.isString}}
{{/items.isPrimitiveType}}
}
{{^required}}
}
{{/required}}
}
{{/isMapContainer}}
{{^isListContainer}}
{{^isMapContainer}}
{{^isPrimitiveType}}
{{^required}}
if(val.has_field(U("{{baseName}}")))
{
{{#isString}}
{{setter}}(ModelBase::stringFromJson(val[U("{{baseName}}")]));
{{/isString}}
{{^isString}}
{{#isDateTime}}
{{setter}}(ModelBase::dateFromJson(val[U("{{baseName}}")]));
{{/isDateTime}}
{{^isDateTime}}
if(!val[U("{{baseName}}")].is_null())
{
{{{datatype}}} newItem({{{defaultValue}}});
newItem->fromJson(val[U("{{baseName}}")]);
{{setter}}( newItem );
}
{{/isDateTime}}
{{/isString}}
}
{{/required}}
{{#required}}
{{#isString}}
{{setter}}(ModelBase::stringFromJson(val[U("{{baseName}}")]));
{{/isString}}
{{^isString}}
{{#isDateTime}}
{{setter}}
(ModelBase::dateFromJson(val[U("{{baseName}}")]));
{{/isDateTime}}
{{^isDateTime}}
{{#vendorExtensions.x-codegen-file}}
{{setter}}(ModelBase::fileFromJson(val[U("{{baseName}}")]));
{{/vendorExtensions.x-codegen-file}}
{{^vendorExtensions.x-codegen-file}}
{{{datatype}}} new{{name}}({{{defaultValue}}});
new{{name}}->fromJson(val[U("{{baseName}}")]);
{{setter}}( new{{name}} );
{{/vendorExtensions.x-codegen-file}}
{{/isDateTime}}
{{/isString}}
{{/required}}
{{/isPrimitiveType}}
{{/isMapContainer}}
{{/isListContainer}}
{{/isInherited}}
{{/vars}}
}
void {{classname}}::toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix) const
{
utility::string_t namePrefix = prefix;
if(namePrefix.size() > 0 && namePrefix[namePrefix.size() - 1] != U('.'))
{
namePrefix += U(".");
}
{{#vars}}
{{#isPrimitiveType}}
{{^isMapContainer}}
{{^isListContainer}}
{{^required}}
if(m_{{name}}IsSet)
{
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
}
{{/required}}
{{#required}}
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
{{/required}}
{{/isListContainer}}
{{/isMapContainer}}
{{/isPrimitiveType}}
{{#isListContainer}}
{
std::vector<web::json::value> jsonArray;
for( auto& item : m_{{name}} )
{
jsonArray.push_back(ModelBase::toJson(item));
}
{{#required}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
{{/required}}{{^required}}
if(jsonArray.size() > 0)
{
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
}
{{/required}}
}
{{/isListContainer}}
{{#isMapContainer}}
{
std::vector<web::json::value> jsonArray;
for( auto& item : m_{{name}} )
{
web::json::value tmp = web::json::value::object();
tmp[U("key")] = ModelBase::toJson(item.first);
tmp[U("value")] = ModelBase::toJson(item.second);
jsonArray.push_back(tmp);
}
{{#required}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
{{/required}}{{^required}}
if(jsonArray.size() > 0)
{
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), web::json::value::array(jsonArray), U("application/json")));
}
{{/required}}
}
{{/isMapContainer}}
{{^isListContainer}}
{{^isMapContainer}}
{{^isPrimitiveType}}
{{^required}}
if(m_{{name}}IsSet)
{
{{#isString}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
{{/isString}}{{^isString}}{{#isDateTime}}multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
{{/isDateTime}}{{^isDateTime}}if (m_{{name}}.get())
{
m_{{name}}->toMultipart(multipart, U("{{baseName}}."));
}
{{/isDateTime}}{{/isString}}
}
{{/required}}
{{#required}}
{{#isString}}
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
{{/isString}}
{{^isString}}
{{#isDateTime}}
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
{{/isDateTime}}
{{^isDateTime}}
{{#vendorExtensions.x-codegen-file}}
multipart->add(ModelBase::toHttpContent(namePrefix + U("{{baseName}}"), m_{{name}}));
{{/vendorExtensions.x-codegen-file}}
{{^vendorExtensions.x-codegen-file}}
m_{{name}}->toMultipart(multipart, U("{{baseName}}."));
{{/vendorExtensions.x-codegen-file}}
{{/isDateTime}}
{{/isString}}
{{/required}}
{{/isPrimitiveType}}
{{/isMapContainer}}
{{/isListContainer}}
{{/vars}}
}
void {{classname}}::fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix)
{
utility::string_t namePrefix = prefix;
if(namePrefix.size() > 0 && namePrefix[namePrefix.size() - 1] != U('.'))
{
namePrefix += U(".");
}
{{#vars}}
{{#isPrimitiveType}}
{{^isListContainer}}
{{^isMapContainer}}
{{^required}}
if(multipart->hasContent(U("{{baseName}}")))
{
{{setter}}(ModelBase::{{baseType}}FromHttpContent(multipart->getContent(U("{{baseName}}"))));
}
{{/required}}
{{#required}}
{{setter}}(ModelBase::{{baseType}}FromHttpContent(multipart->getContent(U("{{baseName}}"))));
{{/required}}
{{/isMapContainer}}
{{/isListContainer}}
{{/isPrimitiveType}}
{{#isListContainer}}
{
m_{{name}}.clear();
{{^required}}
if(multipart->hasContent(U("{{baseName}}")))
{
{{/required}}
web::json::value jsonArray = web::json::value::parse(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
for( auto& item : jsonArray.as_array() )
{
{{#isPrimitiveType}}
m_{{name}}.push_back(ModelBase::{{items.baseType}}FromJson(item));
{{/isPrimitiveType}}
{{^isPrimitiveType}}
{{#items.isString}}
m_{{name}}.push_back(ModelBase::stringFromJson(item));
{{/items.isString}}
{{^items.isString}}
{{#items.isDateTime}}
m_{{name}}.push_back(ModelBase::dateFromJson(item));
{{/items.isDateTime}}
{{^items.isDateTime}}
if(item.is_null())
{
m_{{name}}.push_back( {{{items.datatype}}}(nullptr) );
}
else
{
{{{items.datatype}}} newItem({{{items.defaultValue}}});
newItem->fromJson(item);
m_{{name}}.push_back( newItem );
}
{{/items.isDateTime}}
{{/items.isString}}
{{/isPrimitiveType}}
}
{{^required}}
}
{{/required}}
}
{{/isListContainer}}
{{#isMapContainer}}
{
m_{{name}}.clear();
{{^required}}
if(multipart->hasContent(U("{{baseName}}")))
{
{{/required}}
web::json::value jsonArray = web::json::value::parse(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
for( auto& item : jsonArray.as_array() )
{
utility::string_t key;
if(item.has_field(U("key")))
{
key = ModelBase::stringFromJson(item[U("key")]);
}
{{#items.isPrimitiveType}}
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::{{items.baseType}}FromJson(item[U("value")])));
{{/items.isPrimitiveType}}
{{^items.isPrimitiveType}}
{{#items.isString}}
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::stringFromJson(item[U("value")])));
{{/items.isString}}
{{^items.isString}}
{{#items.isDateTime}}
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, ModelBase::dateFromJson(item[U("value")])));
{{/items.isDateTime}}
{{^items.isDateTime}}
if(item.is_null())
{
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, {{{items.datatype}}}(nullptr) ));
}
else
{
{{{items.datatype}}} newItem({{{items.defaultValue}}});
newItem->fromJson(item[U("value")]);
m_{{name}}.insert(std::pair<utility::string_t,{{{items.datatype}}}>( key, newItem ));
}
{{/items.isDateTime}}
{{/items.isString}}
{{/items.isPrimitiveType}}
}
{{^required}}
}
{{/required}}
}
{{/isMapContainer}}
{{^isListContainer}}
{{^isMapContainer}}
{{^isPrimitiveType}}
{{^required}}
if(multipart->hasContent(U("{{baseName}}")))
{
{{#isString}}
{{setter}}(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
{{/isString}}
{{^isString}}
{{#isDateTime}}
{{setter}}(ModelBase::dateFromHttpContent(multipart->getContent(U("{{baseName}}"))));
{{/isDateTime}}
{{^isDateTime}}
if(multipart->hasContent(U("{{baseName}}")))
{
{{{datatype}}} newItem({{{defaultValue}}});
newItem->fromMultiPart(multipart, U("{{baseName}}."));
{{setter}}( newItem );
}
{{/isDateTime}}
{{/isString}}
}
{{/required}}
{{#required}}
{{#isString}}
{{setter}}(ModelBase::stringFromHttpContent(multipart->getContent(U("{{baseName}}"))));
{{/isString}}
{{^isString}}
{{#isDateTime}}
{{setter}}(ModelBase::dateFromHttpContent(multipart->getContent(U("{{baseName}}"))));
{{/isDateTime}}
{{^isDateTime}}
{{#vendorExtensions.x-codegen-file}}
{{setter}}(multipart->getContent(U("{{baseName}}")));
{{/vendorExtensions.x-codegen-file}}
{{^vendorExtensions.x-codegen-file}}
{{{datatype}}} new{{name}}({{{defaultValue}}});
new{{name}}->fromMultiPart(multipart, U("{{baseName}}."));
{{setter}}( new{{name}} );
{{/vendorExtensions.x-codegen-file}}
{{/isDateTime}}
{{/isString}}
{{/required}}
{{/isPrimitiveType}}
{{/isMapContainer}}
{{/isListContainer}}
{{/vars}}
}
{{#vars}}
{{^isInherited}}
{{^isNotContainer}}
{{{datatype}}}& {{classname}}::{{getter}}()
{
return m_{{name}};
}
void {{classname}}::{{setter}}({{{datatype}}} value)
{
m_{{name}} = value;
{{^required}}m_{{name}}IsSet = true;{{/required}}
}
{{/isNotContainer}}
{{#isNotContainer}}
{{{datatype}}} {{classname}}::{{getter}}() const
{
return m_{{name}};
}
void {{classname}}::{{setter}}({{{datatype}}} value)
{
m_{{name}} = value;
{{^required}}m_{{name}}IsSet = true;{{/required}}
}
{{/isNotContainer}}
{{^required}}
bool {{classname}}::{{baseName}}IsSet() const
{
return m_{{name}}IsSet;
}
void {{classname}}::unset{{name}}()
{
m_{{name}}IsSet = false;
}
{{/required}}
{{/isInherited}}
{{/vars}}
{{#modelNamespaceDeclarations}}
}
{{/modelNamespaceDeclarations}}
{{/model}}
{{/models}}
View Git Blame Copy Permalink