упрощаем переход от Json к c++ структурам и обратно (николай гродзицкий)

Упрощаем переход от
JSON к C++ структурам и
обратно
Николай Гродзицкий

О чем пойдет речь?
2

DTO
struct message_source_t{
// Worker thread.
std::int32_t m_thread_id;
// Sender.
std::string m_subsystem;
};
struct message_t{
// Who sent a message.
message_source_t m_from;
// When the message was sent (unixtime).
std::tm m_when;
// Message text.
std::string m_text;
}; 3

DTO
// Worker thread.
// Sender.
};
struct message_t{
std::tm m_when;
// Message text.
std::string m_text;
};
JSON
“JSON (JavaScript Object Notation) is a
lightweight data-interchange format.”
http://www.json.org/
4

DTO
// Worker thread.
// Sender.
};
struct message_t{
std::tm m_when;
// Message text.
std::string m_text;
};
JSON
“JSON (JavaScript Object Notation) is a
lightweight data-interchange format.”
http://www.json.org/
{
"from" :
{
"thread_id" : 4242,
"sybsystem" : "json_dto"
},
"when" : "2016.09.28 19:55:00" ,
"text" : "Hello world!"
}
5

Это кому-нибудь нужно?
6

Да, похоже, что нужно:
● http://stackoverflow.com/questions/8220130/converting-c-class-to-json
● http://stackoverflow.com/questions/17549906/c-json-serialization
● http://stackoverflow.com/questions/35955137/convert-json-string-to-c-object-u
sing-casablanca-rest-sdk
7

8

I'd like to create a JSON string containing the instance variables of my class.
For example,
class Example {
std::string string;
std::map<std::string, std:string> map;
std::vector<int> vector;
};
would become:
{
"string":"the-string-value",
"map": {
"key1":"val1",
"key2":"val2"
},
"vector":[1,2,3,4]
}
9

“I want a way to serialize and deserialize Objects to JSON, as automatic as
possible.”
“Serialize: For me, the ideal way is that if I call in an instance JSONSerialize() it
returns an string with a JSON object that has all the public properties of the object
as "name_of_property": "value".”
“Deserialize: Just make an instance of the given object (let's say a dog) and call
JSONDeserialize(json_string), and that should fill all the public properties, creating
the needed objects in case that the properties are not primitives, or the needed
collections.”
10

“Is there any simple way to convert a json string in an object and back as shown in
this example? (http://www.newtonsoft.com/json/help/html/serializingjson.htm)”
11

В целом, хочется для заданной
структуры (класса) иметь
возможность конвертировать
инстанс в JSON и наоборот
получить инстанс из JSON.
При этом чтобы дополнительного
кода требовалось как можно
меньше.
12

Что такое json_dto?
13

● Нет, это не еще один JSON парсер
14

○ В качестве парсера используется RapidJSON
15

Выбор был сделан на основе nativejson-benchmark
16

● Инструмент для отображения DTO в JSON и обратно по заданным
правилам
17

правилам
○ Header-only (C++14)
18

правилам
■ зависит только от RapidJSON (тоже header-only)
19

правилам
○ Требует немного дополнительного кода
20

правилам
■ Механика описания правил позаимствована у Boost Serialization
21

правилам
■ Механика описания правил позаимствована у Boost Serialization
■ Для одного DTO требуется написать одну функцию
22

правилам
○ Интуитивно понятная поддержка типов
23

правилам
■ Простые типы: String, Number, Bool
24

правилам
■ Массивы (Array)
25

правилам
■ Массивы (Array)
■ Объекты (Object)
26

правилам
○ Поддержка null-полей
27

правилам
○ Поддержка null-полей
○ Опциональные поля и значения по умолчанию
28

Давайте посмотрим,
что умеет json_dto
29

Hello world!
struct message_t
{
std::string m_from;
std::string m_text;
};
30

Hello world!
struct message_t
{
std::string m_from;
std::string m_text;
};
{
"from" : "<from>",
"text" : "<text>"
}
31

Hello world!
struct message_t
{
std::string m_from;
std::string m_text;
};
#include <json_dto/pub.hpp>
// ...
struct message_t
{
std::string m_from;
std::string m_text;
template < typename JSON_IO >
void
json_io( JSON_IO & io )
{
io
& json_dto::mandatory( "from", m_from )
& json_dto::mandatory( "text", m_text );
}
};
32

Hello world!
Чтение:
const std::string json_data{
R"({
"from" : "json_dto",
})" };
auto msg =
json_dto::from_json< message_t >(
json_data );
Запись:
auto json_str = json_dto::to_json( msg );
#include <json_dto/pub.hpp >
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
33

Hello world!
Чтение:
R"({
})" };
auto msg =
json_data );
Запись:
template <
typename TYPE,
unsigned RAPIDJSON_PARSEFLAGS =
rapidjson::kParseDefaultFlags >
TYPE
from_json( const std::string & json );
34

Hello world!
Чтение:
R"({
})" };
auto msg =
json_data );
Запись:
template < typename DTO >
std::string
to_json( const DTO & dto );
35

Какую роль играет json_io()
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
36

Это входная точка для json_dto. #include <json_dto/pub.hpp>
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
37

Это входная точка для json_dto, она служит
для описания:
● как читать DTO из JSON;
● как писать DTO в JSON.
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
38

Шаблонной она является, для того чтобы
иметь всего одну логику для записи и чтения.
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
39

Шаблонной она является, для того чтобы
иметь всего одну логику для записи и чтения.
json_dto подставляет в нее объекты двух
типов:
● json_dto::json_input_t
● json_dto::json_output_t
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
40

Внутри json_io()
// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
41

// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
42
io & binder

// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
43
io & binder
json_input_t
json_ouput_t

// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
44
io & binder
json_input_t
json_ouput_t
Аналог
operator<<
operator>>

// ...
struct message_t
{
std::string m_from;
std::string m_text;
void
{
io
}
};
45
io & binder
json_input_t
json_ouput_t
Аналог
operator<<
operator>>
Привязка

Какие бывают привязки
46

● mandatory (обязательные)
template <
typename FIELD_TYPE,
typename VALIDATOR = empty_validator_t >
auto
mandatory(
string_ref_t field_name,
FIELD_TYPE & field,
VALIDATOR validator = VALIDATOR{} );
struct message_t
{
std::string m_from{};
std::string m_text{};
std::string m_text_format{ "text/plain" };
bool m_is_private{ false };
void
{
io
& json_dto::mandatory( "text", m_text )
& json_dto::optional(
"text_format" ,
m_text_format,
"text/plain" )
& json_dto::optional_no_default(
"is_private" ,
m_is_private );
}
};
47

● optional (необязательные со
значением по умолчанию)
template <
typename
FIELD_DEFAULT_VALUE_TYPE,
auto
optional(
FIELD_TYPE & field,
FIELD_DEFAULT_VALUE_TYPE
default_value,
struct message_t
{
void
{
io
"text_format" ,
m_text_format,
"text/plain" )
"is_private" ,
m_is_private );
}
};
48

Пусть мы имеем:
auto msg =
json_dto::from_json<message_t>(json );
тогда:
1. {"from":"...","text":"..." }
msg.m_text_format == "text/plain"
2. {"from":"...","text":"...",
"text_format": "text/html" }
msg.m_text_format == "text/html"
struct message_t
{
void
{
io
"text_format" ,
m_text_format,
"text/plain" )
"is_private" ,
m_is_private );
}
};
49

● optional_no _default
(необязательные, без
значения по умолчанию)
template <
auto
optional_no_default(
FIELD_TYPE & field,
struct message_t
{
void
{
io
"text_format" ,
m_text_format,
"text/plain" )
"is_private" ,
m_is_private );
}
};
50

Почему отдельные имена
optional_no_default() и optional()
template <
typename FIELD_DEFAULT_VALUE_TYPE,
typename VALIDATOR = empty_validator_t
>
auto
optional(
FIELD_TYPE & field,
FIELD_DEFAULT_VALUE_TYPE default_value,
template <
typename VALIDATOR = empty_validator_t
>
auto
optional_no_default(
FIELD_TYPE & field,
51

● mandatory (обязательные)
● optional (необязательные со значением по умолчанию)
● optional_no _default (необязательные, без значения по умолчанию)
52

Поддерживаемые типы
53

Простые типы
C++
?
http://json.org/
JSON
54

C++
● Bool: bool;
http://json.org/
JSON
55

C++
● Bool: bool;
● Number:
std::int16_t,
std::uint16_t,
std::int32_t,
std::uint32_t,
std::int64_t,
std::uint64_t,
double;
http://json.org/
JSON
56

C++
● Bool: bool;
● Numeric:
std::int16_t,
std::uint16_t,
std::int32_t,
std::uint32_t,
std::int64_t,
std::uint64_t,
double;
● String: std::string
http://json.org/
JSON
57

“Сложные” типы
C++
В json_dto также поддерживаются:
● Массивы
● Вложенные DTO
http://json.org/
JSON
58

“Сложные” типы
C++
В json_dto также поддерживаются:
● Массивы
● Вложенные DTO
А также в состав json_dto входит
обертка для обработки null-значений
http://json.org/
JSON
59

Поддержка массивов
json_dto автоматически понимает, что значение поля должно быть массивом,
если в качестве второго аргумента для привязки указывается ссылка на
std::vector< ELEMENT_TYPE > &
Например:
struct str_array_t
{
std::vector< std::string > m_strings;
void
{
io & json_dto::mandatory( "strings", m_strings );
}
};
60

Но есть два существенных ограничения:
61

● При чтении массива все элементы должны быть одного типа
62

● При чтении массива все элементы должны быть одного типа
● Значение по умолчанию для массивов в общем случае не работает
63

Поддержка вложенных DTO
Вложенные объекты поддерживаются
аналогично простым типам.
Достаточно чтобы тип был уже интегрирован
с json_dto.
64

struct needle_t
{
std::string m_death{};
void
{
io & json_dto::mandatory(
"death", m_death );
}
};
65

struct egg_t
{
needle_t m_needle{};
void
{
"needle", m_needle );
}
};
struct needle_t
{
void
{
"death", m_death );
}
};
66

struct duck_t
{
egg_t m_egg{};
void
{
"egg", m_egg );
}
};
struct needle_t
{
void
{
io & json_dto::mandatory( "death", m_death );
}
};
struct egg_t
{
void
{
io & json_dto::mandatory( "needle",m_needle
);
}
}; 67

struct duck_t
{
egg_t m_egg{};
void
{
"egg", m_egg );
}
};
struct needle_t
{
void
{
io & json_dto::mandatory( "death", m_death );
}
};
struct egg_t
{
void
{
io & json_dto::mandatory( "needle",m_needle
);
}
}; 68

Обработка null-значений
Для поддержки null значений в json_dto предусмотрен класс
json_dto::nullable_t<T>.
69

Интерфейс json_dto::nullable_t<T> подражает std::optional
(C++17).
70

Интерфейс json_dto::nullable_t<T> подражает std::optional
(C++17).
Требует явного объявления члена-данных с типом
71

struct message_t
{
std::string m_from;
std::string m_text;
json_dto::nullable_t<
std::vector< std::string > >
m_tags;
void
{
io
"tags", m_tags, nullptr );
}
};
72

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
& json_dto::mandatory( "from", m_from
)
& json_dto::mandatory( "text", m_text
)
}
};
{
"text" : "Hello CoreHard!",
"tags" :
[
"C++",
"JSON",
"CoreHard.by"
]
}
73

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
{
"text" : "Hello world!",
"tags" :
[
"C++",
"JSON",
"CoreHard.by"
]
}
{
"tags" : null
}
74

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
{
"tags" :
[
"C++",
"JSON",
"CoreHard.by"
]
}
{
"tags" : null
}
{
} 75

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
auto msg =
json_data );
// ...
if( msg.m_tags )
{
for( const auto & tag : *msg.m_tags )
{
do_smth( tag );
}
}
else
do_smth_else();
76

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
auto msg =
json_data );
// ...
if( msg.m_tags )
{
{
do_smth( tag );
}
}
else
do_smth_else();
nullable_t:: operator bool () const;
77

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
auto msg =
json_data );
// ...
if( msg.m_tags )
{
{
do_smth( tag );
}
}
else
do_smth_else();
const FIELD_TYPE &
nullable_t:: operator * () const; 78

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
message_t msg = create_msg( /* ... */ );
// ...
msg.m_tags.reset();
// ...
msg.m_tags =
std::vector< std::string >{ "1", "23" };
msg.m_tags->push_back( "42" );
void
nullable_t::reset(); 79

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
// ...
msg.m_tags.reset();
// ...
msg.m_tags =
nullable_t &
nullable_t::operator= ( FIELD_TYPE && value ); 80

struct message_t
{
std::string m_from;
std::string m_text;
m_tags;
void
{
io
)
)
}
};
// ...
msg.m_tags.reset();
// ...
msg.m_tags =
FIELD_TYPE *
nullable_t:: operator-> (); 81

Что еще?
Есть возможность задать неинтрузивный json_io().
Еще есть валидаторы, которые можно задавать самому, но есть и немного
стандартных.
Можно определять способ чтения и записи кастомных типов.
82

Неинтрузивный json_io()
struct message_t
{
};
83

struct message_t
{
};
84
namespace json_dto
{
void
json_io( JSON_IO & io, message_t & msg )
{
io
& json_dto::mandatory( "from", msg.m_from )
& json_dto::mandatory( "text", msg.m_text )
"text_format" ,
msg.m_text_format,
"text/plain" )
"is_private" ,
msg.m_is_private );
}
} /* namespace json_dto */

struct message_t
{
};
85
namespace json_dto
{
void
{
io
"text_format" ,
msg.m_text_format,
"text/plain" )
"is_private" ,
msg.m_is_private );
}

struct message_t
{
};
86
namespace json_dto
{
void
{
io
"text_format" ,
msg.m_text_format,
"text/plain" )
"is_private" ,
msg.m_is_private );
}

Поддержка кастомных типов
87

struct message_t
{
std::string m_from;
std::tm m_when;
std::string m_text;
void
{
io
& json_dto::mandatory( "when", m_when )
}
};
88

struct message_t
{
std::string m_from;
std::tm m_when;
std::string m_text;
void
{
io
}
};
89

struct message_t
{
std::string m_from;
std::tm m_when;
std::string m_text;
void
{
io
}
};
namespace json_dto
{
template <>
void
read_json_value(
const rapidjson::Value & object,
std::tm & v )
{
// ...
}
template <>
void
write_json_value(
const std::tm & v,
rapidjson::Value & object,
rapidjson::MemoryPoolAllocator<> &allocator )
{
// ...
}
90

Валидаторы
Функциональный объект (function object), который получает один параметр.
Если значение корректно, то валидатор просто штатно завершает свою
работу.
Если значение некорректное, то валидатор должен выбросить исключение.
91

io
& json_dto::optional( "log_level", m_log_level, nullptr );
92

io
& json_dto::optional( "log_level", m_log_level, nullptr );
io
& json_dto::mandatory(
"from", m_from,
[]( const auto & from ){
if( from.empty() ) throw std::runtime_error{ "from cannot be empty" };
} )
& json_dto::mandatory( "text", m_text, check_all_7bit )
"log_level", m_log_level,nullptr,
json_dto::one_of_constraint(
{ std::string{ "trace" }, std::string{ "info" },std::string{ "error" } } ) );
93

Спасибо!
Николай Гродзицкий
ngrodzitski@gmail.com
https://bitbucket.org/sobjectizerteam/json_dto-0.1
https://github.com/miloyip/rapidjson
http://www.boost.org/doc/libs/1_62_0/libs/serialization/doc/index.html
http://en.cppreference.com/w/cpp/utility/optional
Альтернативы: https://github.com/Loki-Astari/ThorsSerializer.git
94

упрощаем переход от Json к c++ структурам и обратно (николай гродзицкий)

Recommended

Recommended

More Related Content

What's hot

What's hot (7)

Viewers also liked

Viewers also liked (15)

Similar to упрощаем переход от Json к c++ структурам и обратно (николай гродзицкий)

Similar to упрощаем переход от Json к c++ структурам и обратно (николай гродзицкий) (20)

More from corehard_by

More from corehard_by (20)

упрощаем переход от Json к c++ структурам и обратно (николай гродзицкий)