README

• The latest version of nlohmann/json now has all of the functionality provided by this project, making this library obsolete.

This library defines a bunch of generic to_json and from_json functions to easily serialize and deserialize types in any namespace

It depends on nlohmann/json and a few boost headers.

To build the example, you either need a full boost installation available or you can clone this repo recursively and invoke the top level Makefile

Why did I do this? Serialization and deserialization are extremely cumbersome in c++ so I made this utility for myself to easily go to and from json in the most convenient way possible. The only structure that currently maps to json that I have not supported is a C style array, but most modern programs likely use STL containers.

Performance is not a concern for my use cases and I don't think I have seen any examples that are nearly as simple and DRY as this

Example

#include<tuple>
#include<map>
#include<set>
#include<unordered_set>
#include<unordered_map>
#include<array>
#include<list>
#include<forward_list>
#include<memory>
#include<iostream>
#include"boost_fusion_sequence_jsonify.h"using nlohmann::json;
enum Meh
{
EH,
FEH,
GEH,
};
// map Meh values to JSON as stringsNLOHMANN_JSON_SERIALIZE_ENUM( Meh, {
{EH, "EH"},
{FEH, "FEH"},
{GEH, "GEH"},
})
structC
{
int bleh;
std::string breh;
Meh meh;
booloperator==(const C &rhs) const
{
returnthis->bleh == rhs.bleh && this->breh == rhs.breh && this->meh == rhs.meh;
}
booloperator!=(const C &rhs) const
{
return !(*this == rhs);
}
booloperator<(const C &rhs) const
{
returnthis->bleh < rhs.bleh;
}
booloperator>=(const C &rhs) const
{
return !(*this < rhs);
}
};
namespacestd
{
template <>
structhash<C>
{
size_toperator()(const C& c) const
{
// Compute individual hash values for two data members and combine them using XOR and bit shiftingreturn ((hash<int>()(c.bleh) ^ (hash<std::string>()(c.breh )) ^ (hash<Meh>()(c.meh) >> 1)));
}
};
}
BOOST_FUSION_ADAPT_STRUCT(
C,
bleh,
breh,
meh,
)
structB
{
int a;
double b;
std::list<C> c;
};
BOOST_FUSION_ADAPT_STRUCT(
B,
a,
b,
c
)
structA {
int x;
float y;
std::map<int, B> z_int_map;
std::tuple<std::string, B, C> z_tuple;
};
BOOST_FUSION_ADAPT_STRUCT(
A,
x,
y,
z_int_map,
z_tuple,
)
structD {
std::set<C> c_set;
std::unordered_set<C> c_unordered_set;
std::unordered_map<int, C> c_unordered_map;
std::array<B, 2> b_arr;
std::forward_list<A> a_flist;
};
BOOST_FUSION_ADAPT_STRUCT(
D,
c_set,
c_unordered_set,
c_unordered_map,
b_arr,
a_flist,
)
structE {
C *c_raw_ptr;
std::shared_ptr<C> c_shared_ptr;
std::unique_ptr<C> c_unique_ptr;
};
BOOST_FUSION_ADAPT_STRUCT(
E,
c_raw_ptr,
c_shared_ptr,
c_unique_ptr
)
BOOST_FUSION_SEQUENCE_JSONIFY()
intmain()
{
// test smallest inner structure with an enumeration
C c { 1, "brehem", Meh::GEH };
json CToJson = c;
C CfromJson = CToJson.get<C>();
json CToJsonAgain = CfromJson;
// test nested structure with above structure embedded
B b {
666,
666.0,
{ c, c }
};
json BToJson = b;
B BfromJson = BToJson.get<B>();
json jB = b;
json BToJsonAgain = BfromJson;
A a {
1, // x2, //y
{ // z_int_map
{
1, // int key
b // B which contains C
}
},
// z_tuple
std::make_tuple<std::string, B, C>(
"key1", // string keyB(b), // B which contains CC(c) // c again cause why not
),
};
json AToJson = a;
A AfromJson = AToJson.get<A>();
json AToJsonAgain = AfromJson;
D d {
{c, c},
{c, c},
{ {1, c } },
{b, b},
{a, a, a}
};
json DToJson = d;
D DfromJson = DToJson.get<D>();
json DToJsonDagain = DfromJson;
std::cout << DToJson.dump(4) << std::endl;
E e {
newC(c),
std::make_shared<C>(c),
std::make_unique<C>(c)
};
json EToJson = e;
E EfromJson = EToJson.get<E>();
json EToJsonEagain = EfromJson;
std::cout << EToJson.dump(4) << std::endl;
delete e.c_raw_ptr;
delete EfromJson.c_raw_ptr;
return0;
}

Supported container types

Supports all STL containers supported by nlohmann::json with the addition of shared, unique, and raw pointers

Unsupported Types with no plans to be supported

Following Smart pointer types not supported

• weak_ptr // requires a smart pointer to be instantiated
• auto_ptr // will be deprecated so no plan for this

Primitive types not yet supported

• C style arrays (TODO)

Container adaptors not yet supported and not planned to be supported:

• stack
• queue
• priority_queue

Ordered Associative containers not planned to be supported

• multiset no translation to json

Unordered Associative containers not supported and not planned to be supported:

• unordered_multiset no translation to json
• unordered_multimap no translation to json