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

[cpp-pistache]Add support for map (#1359)

Browse Source 
* Add support for map
* Add support for nested maps
* Simplify Array and Map Helper
* Use const reference wherever possible
This commit is contained in:
sunn 2018-11-03 14:09:31 +01:00 committed by GitHub
parent 36991a4e14
commit f8f3a08282
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 246 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/openapi-generator/src/main/resources/cpp-pistache-server/api-source.mustache
View File

@ -73,7 +73,7 @@ void {{classname}}::{{operationIdSnakeCase}}_handler(const Pistache::Rest::Reque
nlohmann::json request_body = nlohmann::json::parse(request.body());
{{^isPrimitiveType}}{{^isContainer}}
{{paramName}}.fromJson(request_body);
{{/isContainer}}{{/isPrimitiveType}}{{#isContainer}} {{paramName}} = {{#isListContainer}} {{prefix}}ModelArrayHelper{{/isListContainer}}{{#isMapContainer}} {{prefix}}ModelMapHelper{{/isMapContainer}}::fromJson<{{items.baseType}}>(request_body);{{/isContainer}}
{{/isContainer}}{{/isPrimitiveType}}{{#isContainer}} {{paramName}} = {{#isListContainer}} {{prefix}}ArrayHelper{{/isListContainer}}{{#isMapContainer}} {{prefix}}MapHelper{{/isMapContainer}}::fromJson<{{items.baseType}}>(request_body);{{/isContainer}}
{{#isPrimitiveType}}
// The conversion is done automatically by the json library
{{paramName}} = request_body;

2
modules/openapi-generator/src/main/resources/cpp-pistache-server/model-header.mustache
View File

@ -34,7 +34,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// {{classname}} members

82
modules/openapi-generator/src/main/resources/cpp-pistache-server/model-source.mustache
View File

@ -45,20 +45,34 @@ nlohmann::json {{classname}}::toJson() const
if(jsonArray.size() > 0)
{
val["{{baseName}}"] = jsonArray;
}
{{/required}}
} {{/required}}
}
{{/isListContainer}}{{^isListContainer}}{{^isPrimitiveType}}{{^required}}if(m_{{name}}IsSet)
{{/isListContainer}}{{#isMapContainer}}{
nlohmann::json jsonObj;
for( auto const& item : m_{{name}} )
{ {{^items.isContainer}}
jsonObj[item.first] = {{prefix}}ModelBase::toJson(item.second);{{/items.isContainer}} {{#items.isListContainer}}
jsonObj[item.first] = {{prefix}}ArrayHelper::toJson<{{{items.items.datatype}}}>(item.second);
{{/items.isListContainer}} {{#items.isMapContainer}}
jsonObj[item.first] = {{prefix}}MapHelper::toJson<{{{items.items.datatype}}}>(item.second); {{/items.isMapContainer}}
}
{{#required}}val["{{baseName}}"] = jsonObj; {{/required}}{{^required}}
if(jsonObj.size() > 0)
{
val["{{baseName}}"] = jsonObj;
} {{/required}}
}
{{/isMapContainer}}{{^isContainer}}{{^isPrimitiveType}}{{^required}}if(m_{{name}}IsSet)
{
val["{{baseName}}"] = {{prefix}}ModelBase::toJson(m_{{name}});
}
{{/required}}{{#required}}val["{{baseName}}"] = {{prefix}}ModelBase::toJson(m_{{name}});
{{/required}}{{/isPrimitiveType}}{{/isListContainer}}{{/vars}}
{{/required}}{{/isPrimitiveType}}{{/isContainer}}{{/vars}}
return val;
}
void {{classname}}::fromJson(nlohmann::json& val)
void {{classname}}::fromJson(const nlohmann::json& val)
{
{{#vars}}{{#isPrimitiveType}}{{^isListContainer}}{{^required}}if(val.find("{{baseName}}") != val.end())
{
@ -67,33 +81,53 @@ void {{classname}}::fromJson(nlohmann::json& val)
{{/required}}{{#required}}{{setter}}(val.at("{{baseName}}"));
{{/required}}{{/isListContainer}}{{/isPrimitiveType}}{{#isListContainer}}{
m_{{name}}.clear();
nlohmann::json jsonArray;
{{^required}}if(val.find("{{baseName}}") != val.end())
{
{{/required}}
for( auto& item : val["{{baseName}}"] )
{
{{#isPrimitiveType}}m_{{name}}.push_back(item);
{{/isPrimitiveType}}{{^isPrimitiveType}}{{#items.isString}}m_{{name}}.push_back(item);
{{/items.isString}}{{^items.isString}}{{#items.isDateTime}}m_{{name}}.push_back(item);
{{/items.isDateTime}}{{^items.isDateTime}}
if(item.is_null())
for( auto& item : val["{{baseName}}"] )
{
m_{{name}}.push_back( {{{items.datatype}}}() );
{{#isPrimitiveType}}m_{{name}}.push_back(item);
{{/isPrimitiveType}}{{^isPrimitiveType}}{{#items.isString}}m_{{name}}.push_back(item);
{{/items.isString}}{{^items.isString}}{{#items.isDateTime}}m_{{name}}.push_back(item);
{{/items.isDateTime}}{{^items.isDateTime}}
if(item.is_null())
{
m_{{name}}.push_back( {{{items.datatype}}}() );
}
else
{
{{{items.datatype}}} newItem;
newItem.fromJson(item);
m_{{name}}.push_back( newItem );
}
{{/items.isDateTime}}{{/items.isString}}{{/isPrimitiveType}}
}
else
{
{{{items.datatype}}} newItem;
newItem.fromJson(item);
m_{{name}}.push_back( newItem );
}
{{/items.isDateTime}}{{/items.isString}}{{/isPrimitiveType}}
}
{{^required}}
}
{{/required}}
}
{{/isListContainer}}{{^isListContainer}}{{^isPrimitiveType}}{{^required}}if(val.find("{{baseName}}") != val.end())
{{/isListContainer}}{{#isMapContainer}}{
m_{{name}}.clear();
{{^required}}if(val.find("{{baseName}}") != val.end())
{
{{/required}}
if(val["{{baseName}}"].is_object()) { {{^items.isContainer}}
m_{{name}} = {{prefix}}MapHelper::fromJson<{{{items.datatype}}}>(val["{{baseName}}"]);
{{/items.isContainer}} {{#items.isContainer}}
for( auto& item : val["{{baseName}}"].items() )
{ {{#items.isMapContainer}}
{{{items.datatype}}} newItem = {{prefix}}MapHelper::fromJson<{{{items.items.datatype}}}>(item.value());
{{/items.isMapContainer}}{{#items.isListContainer}}
{{{items.datatype}}} newItem = {{prefix}}ArrayHelper::fromJson<{{{items.items.datatype}}}>(item.value());
{{/items.isListContainer}}
m_{{name}}.insert(m_{{name}}.end(), std::pair< std::string, {{{items.datatype}}} >(item.key(), newItem));
} {{/items.isContainer}}
}
{{^required}}
}
{{/required}}
}
{{/isMapContainer}}{{^isContainer}}{{^isPrimitiveType}}{{^required}}if(val.find("{{baseName}}") != val.end())
{
{{#isString}}{{setter}}(val.at("{{baseName}}"));{{/isString}}{{#isByteArray}}{{setter}}(val.at("{{baseName}}"));{{/isByteArray}}{{#isBinary}}{{setter}}(val.at("{{baseName}}"));
{{/isBinary}}{{^isString}}{{#isDateTime}}{{setter}}(val.at("{{baseName}}"));
@ -107,7 +141,7 @@ void {{classname}}::fromJson(nlohmann::json& val)
}
{{/required}}{{#required}}{{#isString}}{{setter}}(val.at("{{baseName}}"));
{{/isString}}{{^isString}}{{#isDateTime}}{{setter}}(val.at("{{baseName}}"));
{{/isDateTime}}{{/isString}}{{/required}}{{/isPrimitiveType}}{{/isListContainer}}{{/vars}}
{{/isDateTime}}{{/isString}}{{/required}}{{/isPrimitiveType}}{{/isContainer}}{{/vars}}
}

163
modules/openapi-generator/src/main/resources/cpp-pistache-server/modelbase-header.mustache
View File

@ -28,7 +28,7 @@ public:
virtual void validate() = 0;
virtual nlohmann::json toJson() const = 0;
virtual void fromJson(nlohmann::json& json) = 0;
virtual void fromJson(const nlohmann::json& json) = 0;
static std::string toJson( std::string const& value );
static std::string toJson( std::time_t const& value );
@ -39,100 +39,85 @@ public:
static nlohmann::json toJson({{prefix}}ModelBase const& content );
};
class {{prefix}}ModelArrayHelper {
public:
template<typename T>
static std::vector<T> fromJson(nlohmann::json& json) {
T *ptrTest;
std::vector<T> val;
if (dynamic_cast<{{prefix}}ModelBase*>(ptrTest) != nullptr) {
if (!json.empty()) {
for (auto &item : json.items()) {
T entry;
entry.fromJson(item.value());
val.push_back(entry);
}
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(std::vector<T> val) {
nlohmann::json json;
for(auto item : val){
json.push_back(item.toJson());
}
return json;
}
};
class {{prefix}}ArrayHelper {
private:
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static void itemFromJson(T& item, const nlohmann::json& json){
item = json;
}
static void itemFromJson(ModelBase& item, const nlohmann::json& json){
item.fromJson(json);
}
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static nlohmann::json itemtoJson(const T& item){
return item;
}
static nlohmann::json itemtoJson(const ModelBase& item){
return item.toJson();
}
public:
template<typename T>
static std::vector<T> fromJson(nlohmann::json& json) {
std::vector<T> val;
nlohmann::from_json(json, val);
return val;
}
template<typename T>
static nlohmann::json toJson(std::vector<T> val) {
nlohmann::json json;
nlohmann::to_json(json, val);
return json;
}
};
class {{prefix}}ModelMapHelper {
public:
template<typename T>
static std::map<std::string, T> & fromJson(nlohmann::json& json) {
T *ptrTest;
std::map<std::string, T> val;
if (dynamic_cast<{{prefix}}ModelBase*>(ptrTest) != nullptr) {
if (!json.empty()) {
for (auto &item : json.items()) {
T entry;
entry.fromJson(item.value());
val.insert(val.end(),
std::pair<std::string, T>(item.key(), entry));
}
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(std::map<std::string, T> val) {
nlohmann::json json;
for (auto const& item : val) {
json[item.first] = item.second.toJson();
}
return json;
}
template<typename T>
static std::vector<T> fromJson(const nlohmann::json& json) {
std::vector<T> val;
if (!json.empty()) {
for (const auto& item : json.items()) {
T entry;
itemFromJson(entry, item.value());
val.push_back(entry);
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(const std::vector<T>& val) {
nlohmann::json json;
for(const auto& item : val){
json.push_back(itemtoJson(item));
}
return json;
}
};
class {{prefix}}MapHelper {
private:
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static void itemFromJson(T &item, const nlohmann::json& json){
item = json;
}
static void itemFromJson(ModelBase &item, const nlohmann::json& json){
item.fromJson(json);
}
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static nlohmann::json itemtoJson(const T& item){
return item;
}
static nlohmann::json itemtoJson(const ModelBase& item){
return item.toJson();
}
public:
template<typename T>
static std::map<std::string, T> & fromJson(nlohmann::json& json) {
std::map<std::string, T> val;
if (!json.empty()) {
for (auto &item : json.items()) {
T entry = item.value();
val.insert(val.end(),
std::pair<std::string, T>(item.key(), entry));
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(std::map<std::string, T> val) {
nlohmann::json json;
for (auto const& item : val) {
nlohmann::json jitem = item.second;
json[item.first] = jitem;
}
return json;
}
template<typename T>
static std::map<std::string, T> fromJson(const nlohmann::json& json) {
std::map<std::string, T> val;
if (!json.empty()) {
for (const auto& item : json.items()) {
T entry;
itemfromJson(entry, item.value());
val.insert(val.end(),
std::pair<std::string, T>(item.key(), entry));
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(const std::map<std::string, T>& val) {
nlohmann::json json;
for (const auto& item : val) {
nlohmann::json jitem = itemtoJson(item.second);
json[item.first] = jitem;
}
return json;
}
};
{{#modelNamespaceDeclarations}}

2
samples/server/petstore/cpp-pistache/api/PetApi.h
View File

@ -22,9 +22,9 @@
#include <pistache/http.h>
#include <pistache/router.h>
#include <pistache/http_headers.h>
#include <pistache/optional.h>
#include "ApiResponse.h"
#include "Pet.h"
#include <string>

2
samples/server/petstore/cpp-pistache/api/StoreApi.h
View File

@ -22,9 +22,9 @@
#include <pistache/http.h>
#include <pistache/router.h>
#include <pistache/http_headers.h>
#include <pistache/optional.h>
#include "Order.h"
#include <map>
#include <string>

4
samples/server/petstore/cpp-pistache/api/UserApi.cpp
View File

@ -71,7 +71,7 @@ void UserApi::create_users_with_array_input_handler(const Pistache::Rest::Reques
try {
nlohmann::json request_body = nlohmann::json::parse(request.body());
user = ModelArrayHelper::fromJson<User>(request_body);
user = ArrayHelper::fromJson<User>(request_body);
this->create_users_with_array_input(user, response);
} catch (std::runtime_error & e) {
//send a 400 error
@ -87,7 +87,7 @@ void UserApi::create_users_with_list_input_handler(const Pistache::Rest::Request
try {
nlohmann::json request_body = nlohmann::json::parse(request.body());
user = ModelArrayHelper::fromJson<User>(request_body);
user = ArrayHelper::fromJson<User>(request_body);
this->create_users_with_list_input(user, response);
} catch (std::runtime_error & e) {
//send a 400 error

2
samples/server/petstore/cpp-pistache/api/UserApi.h
View File

@ -22,9 +22,9 @@
#include <pistache/http.h>
#include <pistache/router.h>
#include <pistache/http_headers.h>
#include <pistache/optional.h>
#include "User.h"
#include <string>
#include <vector>

2
samples/server/petstore/cpp-pistache/model/ApiResponse.cpp
View File

@ -59,7 +59,7 @@ nlohmann::json ApiResponse::toJson() const
return val;
}
void ApiResponse::fromJson(nlohmann::json& val)
void ApiResponse::fromJson(const nlohmann::json& val)
{
if(val.find("code") != val.end())
{

2
samples/server/petstore/cpp-pistache/model/ApiResponse.h
View File

@ -44,7 +44,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// ApiResponse members

2
samples/server/petstore/cpp-pistache/model/Category.cpp
View File

@ -53,7 +53,7 @@ nlohmann::json Category::toJson() const
return val;
}
void Category::fromJson(nlohmann::json& val)
void Category::fromJson(const nlohmann::json& val)
{
if(val.find("id") != val.end())
{

2
samples/server/petstore/cpp-pistache/model/Category.h
View File

@ -44,7 +44,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// Category members

163
samples/server/petstore/cpp-pistache/model/ModelBase.h
View File

@ -39,7 +39,7 @@ public:
virtual void validate() = 0;
virtual nlohmann::json toJson() const = 0;
virtual void fromJson(nlohmann::json& json) = 0;
virtual void fromJson(const nlohmann::json& json) = 0;
static std::string toJson( std::string const& value );
static std::string toJson( std::time_t const& value );
@ -50,100 +50,85 @@ public:
static nlohmann::json toJson(ModelBase const& content );
};
class ModelArrayHelper {
public:
template<typename T>
static std::vector<T> fromJson(nlohmann::json& json) {
T *ptrTest;
std::vector<T> val;
if (dynamic_cast<ModelBase*>(ptrTest) != nullptr) {
if (!json.empty()) {
for (auto &item : json.items()) {
T entry;
entry.fromJson(item.value());
val.push_back(entry);
}
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(std::vector<T> val) {
nlohmann::json json;
for(auto item : val){
json.push_back(item.toJson());
}
return json;
}
};
class ArrayHelper {
private:
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static void itemFromJson(T& item, const nlohmann::json& json){
item = json;
}
static void itemFromJson(ModelBase& item, const nlohmann::json& json){
item.fromJson(json);
}
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static nlohmann::json itemtoJson(const T& item){
return item;
}
static nlohmann::json itemtoJson(const ModelBase& item){
return item.toJson();
}
public:
template<typename T>
static std::vector<T> fromJson(nlohmann::json& json) {
std::vector<T> val;
nlohmann::from_json(json, val);
return val;
}
template<typename T>
static nlohmann::json toJson(std::vector<T> val) {
nlohmann::json json;
nlohmann::to_json(json, val);
return json;
}
};
class ModelMapHelper {
public:
template<typename T>
static std::map<std::string, T> & fromJson(nlohmann::json& json) {
T *ptrTest;
std::map<std::string, T> val;
if (dynamic_cast<ModelBase*>(ptrTest) != nullptr) {
if (!json.empty()) {
for (auto &item : json.items()) {
T entry;
entry.fromJson(item.value());
val.insert(val.end(),
std::pair<std::string, T>(item.key(), entry));
}
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(std::map<std::string, T> val) {
nlohmann::json json;
for (auto const& item : val) {
json[item.first] = item.second.toJson();
}
return json;
}
template<typename T>
static std::vector<T> fromJson(const nlohmann::json& json) {
std::vector<T> val;
if (!json.empty()) {
for (const auto& item : json.items()) {
T entry;
itemFromJson(entry, item.value());
val.push_back(entry);
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(const std::vector<T>& val) {
nlohmann::json json;
for(const auto& item : val){
json.push_back(itemtoJson(item));
}
return json;
}
};
class MapHelper {
private:
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static void itemFromJson(T &item, const nlohmann::json& json){
item = json;
}
static void itemFromJson(ModelBase &item, const nlohmann::json& json){
item.fromJson(json);
}
template<typename T, typename std::enable_if<!std::is_base_of<ModelBase, T>::value>::value>
static nlohmann::json itemtoJson(const T& item){
return item;
}
static nlohmann::json itemtoJson(const ModelBase& item){
return item.toJson();
}
public:
template<typename T>
static std::map<std::string, T> & fromJson(nlohmann::json& json) {
std::map<std::string, T> val;
if (!json.empty()) {
for (auto &item : json.items()) {
T entry = item.value();
val.insert(val.end(),
std::pair<std::string, T>(item.key(), entry));
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(std::map<std::string, T> val) {
nlohmann::json json;
for (auto const& item : val) {
nlohmann::json jitem = item.second;
json[item.first] = jitem;
}
return json;
}
template<typename T>
static std::map<std::string, T> fromJson(const nlohmann::json& json) {
std::map<std::string, T> val;
if (!json.empty()) {
for (const auto& item : json.items()) {
T entry;
itemfromJson(entry, item.value());
val.insert(val.end(),
std::pair<std::string, T>(item.key(), entry));
}
}
return val;
}
template<typename T>
static nlohmann::json toJson(const std::map<std::string, T>& val) {
nlohmann::json json;
for (const auto& item : val) {
nlohmann::json jitem = itemtoJson(item.second);
json[item.first] = jitem;
}
return json;
}
};
}

2
samples/server/petstore/cpp-pistache/model/Order.cpp
View File

@ -77,7 +77,7 @@ nlohmann::json Order::toJson() const
return val;
}
void Order::fromJson(nlohmann::json& val)
void Order::fromJson(const nlohmann::json& val)
{
if(val.find("id") != val.end())
{

2
samples/server/petstore/cpp-pistache/model/Order.h
View File

@ -44,7 +44,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// Order members

45
samples/server/petstore/cpp-pistache/model/Pet.cpp
View File

@ -59,7 +59,8 @@ nlohmann::json Pet::toJson() const
jsonArray.push_back(ModelBase::toJson(item));
}
val["photoUrls"] = jsonArray;
}
}
{
nlohmann::json jsonArray;
for( auto& item : m_Tags )
@ -70,7 +71,7 @@ nlohmann::json Pet::toJson() const
if(jsonArray.size() > 0)
{
val["tags"] = jsonArray;
}
}
}
if(m_StatusIsSet)
{
@ -81,7 +82,7 @@ nlohmann::json Pet::toJson() const
return val;
}
void Pet::fromJson(nlohmann::json& val)
void Pet::fromJson(const nlohmann::json& val)
{
if(val.find("id") != val.end())
{
@ -100,33 +101,31 @@ void Pet::fromJson(nlohmann::json& val)
setName(val.at("name"));
{
m_PhotoUrls.clear();
nlohmann::json jsonArray;
for( auto& item : val["photoUrls"] )
{
m_PhotoUrls.push_back(item);
}
for( auto& item : val["photoUrls"] )
{
m_PhotoUrls.push_back(item);
}
}
{
m_Tags.clear();
nlohmann::json jsonArray;
if(val.find("tags") != val.end())
{
for( auto& item : val["tags"] )
{
if(item.is_null())
for( auto& item : val["tags"] )
{
m_Tags.push_back( Tag() );
if(item.is_null())
{
m_Tags.push_back( Tag() );
}
else
{
Tag newItem;
newItem.fromJson(item);
m_Tags.push_back( newItem );
}
}
else
{
Tag newItem;
newItem.fromJson(item);
m_Tags.push_back( newItem );
}
}
}
}
if(val.find("status") != val.end())

2
samples/server/petstore/cpp-pistache/model/Pet.h
View File

@ -47,7 +47,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// Pet members

2
samples/server/petstore/cpp-pistache/model/Tag.cpp
View File

@ -53,7 +53,7 @@ nlohmann::json Tag::toJson() const
return val;
}
void Tag::fromJson(nlohmann::json& val)
void Tag::fromJson(const nlohmann::json& val)
{
if(val.find("id") != val.end())
{

2
samples/server/petstore/cpp-pistache/model/Tag.h
View File

@ -44,7 +44,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// Tag members

2
samples/server/petstore/cpp-pistache/model/User.cpp
View File

@ -89,7 +89,7 @@ nlohmann::json User::toJson() const
return val;
}
void User::fromJson(nlohmann::json& val)
void User::fromJson(const nlohmann::json& val)
{
if(val.find("id") != val.end())
{

2
samples/server/petstore/cpp-pistache/model/User.h
View File

@ -44,7 +44,7 @@ public:
void validate() override;
nlohmann::json toJson() const override;
void fromJson(nlohmann::json& json) override;
void fromJson(const nlohmann::json& json) override;
/////////////////////////////////////////////
/// User members