mirror/oatpp
2
0
Fork 0
mirror of https://github.com/oatpp/oatpp.git synced 2025-03-31 18:30:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

Better json-mapper. Support for Map<String, ...> Serialization/Deserialization

Browse Source
This commit is contained in:
lganzzzo 2018-07-06 02:39:26 +03:00
parent fbf016107b
commit 5957798e0e
11 changed files with 543 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/data/mapping/type/List.hpp
View File

@ -22,8 +22,8 @@
*
***************************************************************************/
#ifndef oatpp_data_type_List_hpp
#define oatpp_data_type_List_hpp
#ifndef oatpp_data_mapping_type_List_hpp
#define oatpp_data_mapping_type_List_hpp
#include "./Type.hpp"
@ -101,4 +101,4 @@ namespace __class {
}}}}
#endif /* List_hpp */
#endif /* oatpp_data_mapping_type_List_hpp */

25
core/data/mapping/type/ListMap.cpp Normal file
View File

@ -0,0 +1,25 @@
/***************************************************************************
*
* Project _____ __ ____ _ _
* ( _ ) /__\ (_ _)_| |_ _| |_
* )(_)( /(__)\ )( (_ _)(_ _)
* (_____)(__)(__)(__) |_| |_|
*
*
* Copyright 2018-present, Leonid Stryzhevskyi, <lganzzzo@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
***************************************************************************/
#include "ListMap.hpp"

102
core/data/mapping/type/ListMap.hpp Normal file
View File

@ -0,0 +1,102 @@
/***************************************************************************
*
* Project _____ __ ____ _ _
* ( _ ) /__\ (_ _)_| |_ _| |_
* )(_)( /(__)\ )( (_ _)(_ _)
* (_____)(__)(__)(__) |_| |_|
*
*
* Copyright 2018-present, Leonid Stryzhevskyi, <lganzzzo@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
***************************************************************************/
#ifndef oatpp_data_mapping_type_ListMap_hpp
#define oatpp_data_mapping_type_ListMap_hpp
#include "./Type.hpp"
#include "oatpp/core/collection/ListMap.hpp"
namespace oatpp { namespace data { namespace mapping { namespace type {
namespace __class {
class AbstractListMap {
public:
constexpr static const char* const CLASS_NAME = "ListMap";
};
template<class Key, class Value>
class ListMap; // FWD
}
template<class Key, class Value>
class ListMap : public oatpp::collection::ListMap<Key, Value> {
friend __class::ListMap<Key, Value>;
public:
typedef oatpp::data::mapping::type::ObjectWrapper<ListMap, __class::ListMap<Key, Value>> ObjectWrapper;
public:
OBJECT_POOL(DTO_LISTMAP_POOL, ListMap, 32)
SHARED_OBJECT_POOL(SHARED_DTO_LISTMAP_POOL, ListMap, 32)
protected:
static AbstractObjectWrapper Z__CLASS_OBJECT_CREATOR(){
return AbstractObjectWrapper(SHARED_DTO_LISTMAP_POOL::allocateShared(), Z__CLASS_GET_TYPE());
}
static Type* Z__CLASS_GET_TYPE(){
static Type type(__class::AbstractListMap::CLASS_NAME, &Z__CLASS_OBJECT_CREATOR);
if(type.params.empty()){
type.params.push_back(Key::Class::getType());
type.params.push_back(Value::Class::getType());
}
return &type;
}
public:
ListMap()
{}
public:
static ObjectWrapper createShared(){
return ObjectWrapper(SHARED_DTO_LISTMAP_POOL::allocateShared());
}
virtual void putPolymorphicItem(const AbstractObjectWrapper& key, const AbstractObjectWrapper& value){
auto keyPtr = std::static_pointer_cast<typename Key::ObjectType>(key.getPtr());
auto valuePtr = std::static_pointer_cast<typename Value::ObjectType>(value.getPtr());
this->put(Key(keyPtr, key.valueType), Value(valuePtr, value.valueType));
}
};
namespace __class {
template<class Key, class Value>
class ListMap : public AbstractListMap{
public:
static Type* getType(){
static Type* type = static_cast<Type*>(oatpp::data::mapping::type::ListMap<Key, Value>::Z__CLASS_GET_TYPE());
return type;
}
};
}
}}}}
#endif /* oatpp_data_mapping_type_ListMap_hpp */

3
core/data/mapping/type/Object.hpp
View File

@ -28,6 +28,7 @@
#include "./Type.hpp"
#include "./Primitive.hpp"
#include "./ListMap.hpp"
#include "./List.hpp"
#include "oatpp/core/base/memory/ObjectPool.hpp"
@ -65,6 +66,8 @@ public:
typedef oatpp::data::mapping::type::Boolean Boolean;
template <class T>
using List = oatpp::data::mapping::type::List<T>;
template <class Value>
using Fields = oatpp::data::mapping::type::ListMap<String, Value>;
protected:
static Type::Properties* Z__CLASS_EXTEND(Type::Properties* map, Type::Properties* extensionMap) {
map->insert(extensionMap->begin(), extensionMap->end());

9
core/data/mapping/type/Primitive.hpp
View File

@ -174,12 +174,17 @@ public:
return *this;
}
ObjectWrapper& operator = (const ObjectWrapper &other){
this->m_ptr = other.m_ptr;
return *this;
}
bool operator==(const ObjectWrapper &other) const {
return getValue() == other->getValue();
return this->m_ptr->getValue() == other->getValue();
}
bool operator!=(const ObjectWrapper &other) const {
return getValue() != other->getValue();
return this->m_ptr->getValue() != other->getValue();
}
inline operator ValueType() const {

12
parser/json/Utils.cpp
View File

@ -200,11 +200,11 @@ v_int32 Utils::escapeUtf8Char(p_char8 sequence, p_char8 buffer){
}
}
oatpp::String Utils::escapeString(p_char8 data, v_int32 size) {
oatpp::String Utils::escapeString(p_char8 data, v_int32 size, bool copyAsOwnData) {
v_int32 safeSize;
v_int32 escapedSize = calcEscapedStringSize(data, size, safeSize);
if(escapedSize == size) {
return String((const char*)data, size, true);
return String((const char*)data, size, copyAsOwnData);
}
auto result = String(escapedSize);
v_int32 i = 0;
@ -322,8 +322,7 @@ void Utils::unescapeStringToBuffer(p_char8 data, v_int32 size, p_char8 resultDat
}
oatpp::String Utils::unescapeString(p_char8 data, v_int32 size,
const char* & error, v_int32& errorPosition) {
oatpp::String Utils::unescapeString(p_char8 data, v_int32 size, const char* & error, v_int32& errorPosition) {
v_int32 unescapedSize = calcUnescapedStringSize(data, size, error, errorPosition);
if(error != nullptr){
@ -339,8 +338,8 @@ oatpp::String Utils::unescapeString(p_char8 data, v_int32 size,
}
std::string Utils::unescapeStringToStdString(p_char8 data, v_int32 size,
const char* & error, v_int32& errorPosition){
std::string Utils::unescapeStringToStdString(p_char8 data, v_int32 size, const char* & error, v_int32& errorPosition){
v_int32 unescapedSize = calcUnescapedStringSize(data, size, error, errorPosition);
if(error != nullptr){
return "";
@ -353,6 +352,7 @@ std::string Utils::unescapeStringToStdString(p_char8 data, v_int32 size,
unescapeStringToBuffer(data, size, (p_char8) result.data());
}
return result;
}
p_char8 Utils::preparseString(ParsingCaret& caret, v_int32& size){

6
parser/json/Utils.hpp
View File

@ -48,8 +48,10 @@ private:
static void unescapeStringToBuffer(p_char8 data, v_int32 size, p_char8 resultData);
static p_char8 preparseString(ParsingCaret& caret, v_int32& size);
public:
static String escapeString(p_char8 data, v_int32 size);
/**
* if(copyAsOwnData == false && escapedString == initialString) then result string will point to initial data
*/
static String escapeString(p_char8 data, v_int32 size, bool copyAsOwnData = true);
static String unescapeString(p_char8 data, v_int32 size, const char* & error, v_int32& errorPosition);
static std::string unescapeStringToStdString(p_char8 data, v_int32 size,
const char* & error, v_int32& errorPosition);

71
parser/json/mapping/Deserializer.cpp
View File

@ -185,6 +185,16 @@ Deserializer::AbstractObjectWrapper Deserializer::readListValue(const Type* cons
}
}
Deserializer::AbstractObjectWrapper Deserializer::readListMapValue(const Type* const type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config){
if(caret.proceedIfFollowsText("null")){
return AbstractObjectWrapper::empty();
} else {
return readListMap(type, caret, config);
}
}
Deserializer::AbstractObjectWrapper Deserializer::readValue(const Type* const type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config){
@ -206,6 +216,8 @@ Deserializer::AbstractObjectWrapper Deserializer::readValue(const Type* const ty
return readObjectValue(type, caret, config);
} else if(typeName == oatpp::data::mapping::type::__class::AbstractList::CLASS_NAME){
return readListValue(type, caret, config);
} else if(typeName == oatpp::data::mapping::type::__class::AbstractListMap::CLASS_NAME){
return readListMapValue(type, caret, config);
} else {
skipValue(caret);
}
@ -256,6 +268,63 @@ Deserializer::AbstractObjectWrapper Deserializer::readList(const Type* type,
}
Deserializer::AbstractObjectWrapper Deserializer::readListMap(const Type* type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config){
if(caret.canContinueAtChar('{', 1)) {
auto mapWrapper = type->creator();
oatpp::data::mapping::type::PolymorphicWrapper<AbstractListMap>
map(std::static_pointer_cast<AbstractListMap>(mapWrapper.getPtr()), mapWrapper.valueType);
auto it = type->params.begin();
Type* keyType = *it ++;
if(keyType->name != oatpp::data::mapping::type::__class::String::CLASS_NAME){
throw std::runtime_error("[oatpp::parser::json::mapping::Deserializer::readListMap()]: Invalid json map key. Key should be String");
}
Type* valueType = *it;
while (!caret.isAtChar('}') && caret.canContinue()) {
caret.findNotBlankChar();
auto key = Utils::parseString(caret);
if(caret.hasError()){
return AbstractObjectWrapper::empty();
}
caret.findNotBlankChar();
if(!caret.canContinueAtChar(':', 1)){
caret.setError(ERROR_PARSER_OBJECT_SCOPE_COLON_MISSING);
return AbstractObjectWrapper::empty();
}
caret.findNotBlankChar();
map->putPolymorphicItem(key, readValue(valueType, caret, config));
caret.findNotBlankChar();
caret.canContinueAtChar(',', 1);
}
if(!caret.canContinueAtChar('}', 1)){
if(!caret.hasError()){
caret.setError(ERROR_PARSER_OBJECT_SCOPE_CLOSE);
}
return AbstractObjectWrapper::empty();
}
return AbstractObjectWrapper(map.getPtr(), map.valueType);
} else {
caret.setError(ERROR_PARSER_OBJECT_SCOPE_OPEN);
}
return AbstractObjectWrapper::empty();
}
Deserializer::AbstractObjectWrapper Deserializer::readObject(const Type* type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config){
@ -303,7 +372,7 @@ Deserializer::AbstractObjectWrapper Deserializer::readObject(const Type* type,
caret.findNotBlankChar();
caret.canContinueAtChar(',', 1);
};
}
if(!caret.canContinueAtChar('}', 1)){
if(!caret.hasError()){

11
parser/json/mapping/Deserializer.hpp
View File

@ -55,6 +55,7 @@ private:
typedef oatpp::data::mapping::type::Boolean Boolean;
typedef oatpp::data::mapping::type::List<AbstractObjectWrapper> AbstractList;
typedef oatpp::data::mapping::type::ListMap<String, AbstractObjectWrapper> AbstractListMap;
public:
@ -99,6 +100,10 @@ private:
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config);
static AbstractObjectWrapper readListMapValue(const Type* const type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config);
static AbstractObjectWrapper readValue(const Type* const type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config);
@ -107,6 +112,10 @@ private:
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config);
static AbstractObjectWrapper readListMap(const Type* const type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config);
static AbstractObjectWrapper readObject(const Type* const type,
oatpp::parser::ParsingCaret& caret,
const std::shared_ptr<Config>& config);
@ -120,6 +129,8 @@ public:
return readObject(type, caret, config);
} else if(type->name == oatpp::data::mapping::type::__class::AbstractList::CLASS_NAME){
return readList(type, caret, config);
} else if(type->name == oatpp::data::mapping::type::__class::AbstractListMap::CLASS_NAME){
return readListMap(type, caret, config);
}
return AbstractObjectWrapper::empty();
}

257
parser/json/mapping/Serializer.cpp
View File

@ -28,23 +28,29 @@
namespace oatpp { namespace parser { namespace json { namespace mapping {
void Serializer::writeStringValue(oatpp::data::stream::OutputStream* stream, p_char8 data, v_int32 size) {
auto encodedValue = Utils::escapeString(data, size, false);
stream->writeChar('\"');
stream->write(encodedValue);
stream->writeChar('\"');
}
void Serializer::writeStringValue(oatpp::data::stream::OutputStream* stream, const char* data) {
writeStringValue(stream, (p_char8)data, (v_int32)std::strlen(data));
}
void Serializer::writeString(oatpp::data::stream::OutputStream* stream,
void* object,
Property* field,
const std::shared_ptr<Config>& config) {
auto value = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(field->get(object));
if(value) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": ", 3);
auto encodedValue = Utils::escapeString(value->getData(), value->getSize());
stream->writeChar('\"');
stream->write(encodedValue);
stream->writeChar('\"');
writeStringValue(stream, field->name);
stream->write(": ", 2);
writeStringValue(stream, value->getData(), value->getSize());
} else if(config->includeNullFields) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": null", 7);
writeStringValue(stream, field->name);
stream->write(": null", 6);
}
}
@ -54,14 +60,12 @@ void Serializer::writeObject(oatpp::data::stream::OutputStream* stream,
const std::shared_ptr<Config>& config){
auto value = oatpp::data::mapping::type::static_wrapper_cast<Object>(field->get(object));
if(value) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": ", 3);
writeStringValue(stream, field->name);
stream->write(": ", 2);
writeObject(stream, field->type, value.get(), config);
} else if(config->includeNullFields) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": null", 7);
writeStringValue(stream, field->name);
stream->write(": null", 6);
}
}
@ -76,10 +80,7 @@ void Serializer::writeListOfString(oatpp::data::stream::OutputStream* stream,
auto value = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getData());
if(value) {
(first) ? first = false : stream->write(", ", 2);
auto encodedValue = Utils::escapeString(value->getData(), value->getSize());
stream->writeChar('\"');
stream->write(encodedValue);
stream->writeChar('\"');
writeStringValue(stream, value->getData(), value->getSize());
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
stream->write("null", 4);
@ -144,6 +145,32 @@ void Serializer::writeListOfList(oatpp::data::stream::OutputStream* stream,
stream->writeChar(']');
}
void Serializer::writeListOfListMap(oatpp::data::stream::OutputStream* stream,
AbstractList* list,
const Type* const type,
const std::shared_ptr<Config>& config){
stream->writeChar('[');
bool first = true;
auto curr = list->getFirstNode();
while(curr != nullptr){
auto value = oatpp::data::mapping::type::static_wrapper_cast<AbstractListMap>(curr->getData());
if(value) {
(first) ? first = false : stream->write(", ", 2);
writeListMapCollection(stream, value.get(), type, config);
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
stream->write("null", 4);
}
curr = curr->getNext();
}
stream->writeChar(']');
}
void Serializer::writeListCollection(oatpp::data::stream::OutputStream* stream,
AbstractList* list,
@ -169,6 +196,8 @@ void Serializer::writeListCollection(oatpp::data::stream::OutputStream* stream,
writeListOfObject(stream, list, itemType, config);
} else if(itemTypeName == oatpp::data::mapping::type::__class::AbstractList::CLASS_NAME) {
writeListOfList(stream, list, itemType, config);
} else if(itemTypeName == oatpp::data::mapping::type::__class::AbstractListMap::CLASS_NAME) {
writeListOfListMap(stream, list, itemType, config);
}
}
@ -179,14 +208,188 @@ void Serializer::writeList(oatpp::data::stream::OutputStream* stream,
const std::shared_ptr<Config>& config){
auto value = oatpp::data::mapping::type::static_wrapper_cast<AbstractList>(field->get(object));
if(value) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": ", 3);
writeStringValue(stream, field->name);
stream->write(": ", 2);
writeListCollection(stream, value.get(), field->type, config);
} else if(config->includeNullFields) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": null", 7);
writeStringValue(stream, field->name);
stream->write(": null", 6);
}
}
void Serializer::writeListMapOfString(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const std::shared_ptr<Config>& config) {
stream->writeChar('{');
bool first = true;
auto curr = map->getFirstEntry();
while(curr != nullptr){
auto value = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getValue());
if(value) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": ", 2);
writeStringValue(stream, value->getData(), value->getSize());
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": null", 6);
}
curr = curr->getNext();
}
stream->writeChar('}');
}
void Serializer::writeListMapOfObject(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config){
stream->writeChar('{');
bool first = true;
auto curr = map->getFirstEntry();
while(curr != nullptr){
auto value = oatpp::data::mapping::type::static_wrapper_cast<Object>(curr->getValue());
if(value) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": ", 2);
writeObject(stream, type, value.get(), config);
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": null", 6);
}
curr = curr->getNext();
}
stream->writeChar('}');
}
void Serializer::writeListMapOfList(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config){
stream->writeChar('{');
bool first = true;
auto curr = map->getFirstEntry();
while(curr != nullptr){
auto value = oatpp::data::mapping::type::static_wrapper_cast<AbstractList>(curr->getValue());
if(value) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": ", 2);
writeListCollection(stream, value.get(), type, config);
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": null", 6);
}
curr = curr->getNext();
}
stream->writeChar('}');
}
void Serializer::writeListMapOfListMap(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config){
stream->writeChar('{');
bool first = true;
auto curr = map->getFirstEntry();
while(curr != nullptr){
auto value = oatpp::data::mapping::type::static_wrapper_cast<AbstractListMap>(curr->getValue());
if(value) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": ", 2);
writeListMapCollection(stream, value.get(), type, config);
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": null", 6);
}
curr = curr->getNext();
}
stream->writeChar('}');
}
void Serializer::writeListMapCollection(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config){
auto it = type->params.begin();
Type* keyType = *it ++;
auto keyTypeName = keyType->name;
Type* valueType = *it;
auto valueTypeName = valueType->name;
if(keyTypeName != oatpp::data::mapping::type::__class::String::CLASS_NAME){
throw std::runtime_error("[oatpp::parser::json::mapping::Serializer::writeListMapCollection()]: Invalid json map key. Key should be String");
}
if(valueTypeName == oatpp::data::mapping::type::__class::String::CLASS_NAME){
writeListMapOfString(stream, map, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::Int32::CLASS_NAME) {
writeListMapOfSimpleData<oatpp::data::mapping::type::Int32::ObjectType>(stream, map, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::Int64::CLASS_NAME) {
writeListMapOfSimpleData<oatpp::data::mapping::type::Int64::ObjectType>(stream, map, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::Float32::CLASS_NAME) {
writeListMapOfSimpleData<oatpp::data::mapping::type::Float32::ObjectType>(stream, map, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::Float64::CLASS_NAME) {
writeListMapOfSimpleData<oatpp::data::mapping::type::Float64::ObjectType>(stream, map, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::Boolean::CLASS_NAME) {
writeListMapOfSimpleData<oatpp::data::mapping::type::Boolean::ObjectType>(stream, map, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::AbstractObject::CLASS_NAME) {
writeListMapOfObject(stream, map, valueType, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::AbstractList::CLASS_NAME) {
writeListMapOfList(stream, map, valueType, config);
} else if(valueTypeName == oatpp::data::mapping::type::__class::AbstractListMap::CLASS_NAME) {
writeListMapOfListMap(stream, map, valueType, config);
}
}
void Serializer::writeListMap(oatpp::data::stream::OutputStream* stream,
void* object,
Property* field,
const std::shared_ptr<Config>& config){
auto value = oatpp::data::mapping::type::static_wrapper_cast<AbstractListMap>(field->get(object));
if(value) {
writeStringValue(stream, field->name);
stream->write(": ", 2);
writeListMapCollection(stream, value.get(), field->type, config);
} else if(config->includeNullFields) {
writeStringValue(stream, field->name);
stream->write(": null", 6);
}
}
@ -227,6 +430,8 @@ void Serializer::writeObject(oatpp::data::stream::OutputStream* stream,
writeObject(stream, object, field, config);
} else if(typeName == oatpp::data::mapping::type::__class::AbstractList::CLASS_NAME) {
writeList(stream, object, field, config);
} else if(typeName == oatpp::data::mapping::type::__class::AbstractListMap::CLASS_NAME) {
writeListMap(stream, object, field, config);
}
}

89
parser/json/mapping/Serializer.hpp
View File

@ -25,6 +25,7 @@
#ifndef oatpp_parser_json_mapping_Serializer_hpp
#define oatpp_parser_json_mapping_Serializer_hpp
#include "oatpp/core/data/mapping/type/ListMap.hpp"
#include "oatpp/core/data/mapping/type/List.hpp"
#include "oatpp/core/data/mapping/type/Object.hpp"
#include "oatpp/core/data/mapping/type/Primitive.hpp"
@ -45,10 +46,16 @@ public:
typedef oatpp::data::mapping::type::Type::Properties Properties;
typedef oatpp::data::mapping::type::Object Object;
typedef oatpp::String String;
typedef oatpp::data::mapping::type::List<
oatpp::data::mapping::type::AbstractObjectWrapper
> AbstractList;
typedef oatpp::data::mapping::type::ListMap<
oatpp::data::mapping::type::AbstractObjectWrapper,
oatpp::data::mapping::type::AbstractObjectWrapper
> AbstractListMap;
public:
class Config : public oatpp::base::Controllable {
@ -65,10 +72,11 @@ public:
};
public:
typedef oatpp::String String;
private:
static void writeStringValue(oatpp::data::stream::OutputStream* stream, p_char8 data, v_int32 size);
static void writeStringValue(oatpp::data::stream::OutputStream* stream, const char* data);
static void writeString(oatpp::data::stream::OutputStream* stream,
void* object,
Property* field,
@ -81,14 +89,12 @@ private:
const std::shared_ptr<Config>& config){
auto value = oatpp::data::mapping::type::static_wrapper_cast<T>(field->get(object));
if(value) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": ", 3);
writeStringValue(stream, field->name);
stream->write(": ", 2);
stream->writeAsString(value.get()->getValue());
} else if(config->includeNullFields) {
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": null", 7);
writeStringValue(stream, field->name);
stream->write(": null", 6);
}
}
@ -137,6 +143,11 @@ private:
const Type* const type,
const std::shared_ptr<Config>& config);
static void writeListOfListMap(oatpp::data::stream::OutputStream* stream,
AbstractList* list,
const Type* const type,
const std::shared_ptr<Config>& config);
static void writeListCollection(oatpp::data::stream::OutputStream* stream,
AbstractList* list,
const Type* const type,
@ -147,6 +158,66 @@ private:
Property* field,
const std::shared_ptr<Config>& config);
static void writeListMapOfString(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const std::shared_ptr<Config>& config);
template<class T>
static void writeListMapOfSimpleData(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const std::shared_ptr<Config>& config){
stream->writeChar('{');
bool first = true;
auto curr = map->getFirstEntry();
while(curr != nullptr){
auto value = oatpp::data::mapping::type::static_wrapper_cast<T>(curr->getValue());
if(value) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": ", 2);
stream->writeAsString(value.get()->getValue());
} else if(config->includeNullFields) {
(first) ? first = false : stream->write(", ", 2);
auto key = oatpp::data::mapping::type::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getKey());
writeStringValue(stream, key->getData(), key->getSize());
stream->write(": null", 6);
}
curr = curr->getNext();
}
stream->writeChar('}');
}
static void writeListMapOfObject(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config);
static void writeListMapOfList(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config);
static void writeListMapOfListMap(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config);
static void writeListMapCollection(oatpp::data::stream::OutputStream* stream,
AbstractListMap* map,
const Type* const type,
const std::shared_ptr<Config>& config);
static void writeListMap(oatpp::data::stream::OutputStream* stream,
void* object,
Property* field,
const std::shared_ptr<Config>& config);
static void writeObject(oatpp::data::stream::OutputStream* stream,
const Type* const type,
Object* object,
@ -162,6 +233,8 @@ public:
writeObject(stream.get(), type, static_cast<Object*>(object.get()), config);
} else if(type->name == oatpp::data::mapping::type::__class::AbstractList::CLASS_NAME) {
writeListCollection(stream.get(), static_cast<AbstractList*>(object.get()), type, config);
} else if(type->name == oatpp::data::mapping::type::__class::AbstractListMap::CLASS_NAME) {
writeListMapCollection(stream.get(), static_cast<AbstractListMap*>(object.get()), type, config);
} else {
throw std::runtime_error("[oatpp::parser::json::mapping::Serializer::serialize()]: Unknown parameter type");
}