416 lines
9.9 KiB
C++
416 lines
9.9 KiB
C++
/*! \file pijson.h
|
|
* \ingroup Serialization
|
|
* \brief
|
|
* \~english JSON serialization
|
|
* \~russian Сериализация JSON
|
|
*/
|
|
/*
|
|
PIP - Platform Independent Primitives
|
|
JSON serialization
|
|
Ivan Pelipenko peri4ko@yandex.ru
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef pijsonserialization_H
|
|
#define pijsonserialization_H
|
|
|
|
#include "pijson.h"
|
|
|
|
|
|
// ---
|
|
// serialize, PIJSON = piSerializeJSON(T)
|
|
// ---
|
|
|
|
|
|
// enum & arithmetic
|
|
|
|
template<typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
|
|
inline PIJSON piSerializeJSON(const T & v) {
|
|
return PIJSON() = (int)v;
|
|
}
|
|
|
|
template<typename T,
|
|
typename std::enable_if<!std::is_enum<T>::value, int>::type = 0,
|
|
typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
|
|
inline PIJSON piSerializeJSON(const T & v) {
|
|
return PIJSON() = v;
|
|
}
|
|
|
|
template<typename T,
|
|
typename std::enable_if<!std::is_enum<T>::value, int>::type = 0,
|
|
typename std::enable_if<!std::is_arithmetic<T>::value, int>::type = 0>
|
|
inline PIJSON piSerializeJSON(const T & v) {
|
|
static_assert(std::is_enum<T>::value || std::is_arithmetic<T>::value,
|
|
"[piSerializeJSON] Error: using undeclared piSerializeJSON() for complex type!");
|
|
return {};
|
|
}
|
|
|
|
|
|
// known types
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PIVariant & v) {
|
|
return PIJSON() = v;
|
|
}
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const complex<T> & v) {
|
|
PIJSON ret;
|
|
ret << v.real() << v.imag();
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PIFlags<T> & v) {
|
|
return PIJSON() = (int)v;
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PIString & v) {
|
|
return PIJSON() = v;
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PIConstChars & v) {
|
|
return PIJSON() = v.toString();
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PIByteArray & v) {
|
|
return PIJSON() = PIStringAscii(v.toBase64());
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PISystemTime & v) {
|
|
PIJSON ret;
|
|
ret["s"] = v.seconds;
|
|
ret["ns"] = v.nanoseconds;
|
|
return ret;
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PITime & v) {
|
|
PIJSON ret;
|
|
ret["h"] = v.hours;
|
|
ret["m"] = v.minutes;
|
|
ret["s"] = v.seconds;
|
|
ret["z"] = v.milliseconds;
|
|
return ret;
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PIDate & v) {
|
|
PIJSON ret;
|
|
ret["y"] = v.year;
|
|
ret["M"] = v.month;
|
|
ret["d"] = v.day;
|
|
return ret;
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PIDateTime & v) {
|
|
PIJSON ret;
|
|
ret["y"] = v.year;
|
|
ret["M"] = v.month;
|
|
ret["d"] = v.day;
|
|
ret["h"] = v.hours;
|
|
ret["m"] = v.minutes;
|
|
ret["s"] = v.seconds;
|
|
ret["z"] = v.milliseconds;
|
|
return ret;
|
|
}
|
|
|
|
template<>
|
|
inline PIJSON piSerializeJSON(const PINetworkAddress & v) {
|
|
return PIJSON() = v.toString();
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PIPoint<T> & v) {
|
|
PIJSON ret;
|
|
ret["x"] = piSerializeJSON(v.x);
|
|
ret["y"] = piSerializeJSON(v.y);
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PILine<T> & v) {
|
|
PIJSON ret;
|
|
ret["p0"] = piSerializeJSON(v.p0);
|
|
ret["p1"] = piSerializeJSON(v.p1);
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PIRect<T> & v) {
|
|
PIJSON ret;
|
|
ret["bl"] = piSerializeJSON(v.bottomLeft());
|
|
ret["tr"] = piSerializeJSON(v.topRigth());
|
|
return ret;
|
|
}
|
|
|
|
|
|
// containers
|
|
|
|
template<typename T1, typename T2>
|
|
inline PIJSON piSerializeJSON(const PIPair<T1, T2> & v) {
|
|
PIJSON ret;
|
|
ret << piSerializeJSON(v.first) << piSerializeJSON(v.second);
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PIVector<T> & v) {
|
|
if (v.isEmpty()) return PIJSON::newArray();
|
|
PIJSON ret;
|
|
for (const auto & i: v)
|
|
ret << piSerializeJSON(i);
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PIDeque<T> & v) {
|
|
if (v.isEmpty()) return PIJSON::newArray();
|
|
PIJSON ret;
|
|
for (const auto & i: v)
|
|
ret << piSerializeJSON(i);
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PIVector2D<T> & v) {
|
|
PIJSON ret;
|
|
ret["cols"] = v.cols();
|
|
ret["rows"] = v.rows();
|
|
ret["mat"] = piSerializeJSON(v.plainVector());
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
inline PIJSON piSerializeJSON(const PISet<T> & v) {
|
|
if (v.isEmpty()) return PIJSON::newArray();
|
|
PIJSON ret;
|
|
for (const auto & i: v)
|
|
ret << piSerializeJSON(i);
|
|
return ret;
|
|
}
|
|
|
|
template<typename K, typename T>
|
|
inline PIJSON piSerializeJSON(const PIMap<K, T> & v) {
|
|
if (v.isEmpty()) return PIJSON::newObject();
|
|
PIJSON ret;
|
|
auto it = v.makeIterator();
|
|
while (it.next())
|
|
ret[PIVariant(it.key()).toString()] = piSerializeJSON(it.value());
|
|
return ret;
|
|
}
|
|
|
|
|
|
// ---
|
|
// deserialize, piDeserializeJSON(T, PIJSON)
|
|
// ---
|
|
|
|
|
|
// enum & arithmetic
|
|
|
|
template<typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
|
|
inline void piDeserializeJSON(T & v, const PIJSON & js) {
|
|
v = (T)js.toInt();
|
|
}
|
|
|
|
template<typename T,
|
|
typename std::enable_if<!std::is_enum<T>::value, int>::type = 0,
|
|
typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
|
|
inline void piDeserializeJSON(T & v, const PIJSON & js) {
|
|
v = js.value().value<T>();
|
|
}
|
|
|
|
template<typename T,
|
|
typename std::enable_if<!std::is_enum<T>::value, int>::type = 0,
|
|
typename std::enable_if<!std::is_arithmetic<T>::value, int>::type = 0>
|
|
inline void piDeserializeJSON(T & v, const PIJSON & js) {
|
|
static_assert(std::is_enum<T>::value || std::is_arithmetic<T>::value,
|
|
"[piDeserializeJSON] Error: using undeclared piDeserializeJSON() for complex type!");
|
|
v = {};
|
|
}
|
|
|
|
|
|
// known types
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PIVariant & v, const PIJSON & js) {
|
|
v = js.value();
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(complex<T> & v, const PIJSON & js) {
|
|
T c[2];
|
|
piDeserializeJSON(c[0], js[0]);
|
|
piDeserializeJSON(c[1], js[1]);
|
|
v = complex<T>(c[0], c[1]);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PIFlags<T> & v, const PIJSON & js) {
|
|
v = js.toInt();
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PIString & v, const PIJSON & js) {
|
|
v = js.toString();
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PIByteArray & v, const PIJSON & js) {
|
|
v = PIByteArray::fromBase64(js.toString());
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PISystemTime & v, const PIJSON & js) {
|
|
piDeserializeJSON(v.seconds, js["s"]);
|
|
piDeserializeJSON(v.nanoseconds, js["ns"]);
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PITime & v, const PIJSON & js) {
|
|
v.hours = js["h"].toInt();
|
|
v.minutes = js["m"].toInt();
|
|
v.seconds = js["s"].toInt();
|
|
v.milliseconds = js["z"].toInt();
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PIDate & v, const PIJSON & js) {
|
|
v.year = js["y"].toInt();
|
|
v.month = js["M"].toInt();
|
|
v.day = js["d"].toInt();
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PIDateTime & v, const PIJSON & js) {
|
|
v.year = js["y"].toInt();
|
|
v.month = js["M"].toInt();
|
|
v.day = js["d"].toInt();
|
|
v.hours = js["h"].toInt();
|
|
v.minutes = js["m"].toInt();
|
|
v.seconds = js["s"].toInt();
|
|
v.milliseconds = js["z"].toInt();
|
|
}
|
|
|
|
template<>
|
|
inline void piDeserializeJSON(PINetworkAddress & v, const PIJSON & js) {
|
|
v = PINetworkAddress(js.toString());
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PIPoint<T> & v, const PIJSON & js) {
|
|
piDeserializeJSON(v.x, js["x"]);
|
|
piDeserializeJSON(v.y, js["y"]);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PILine<T> & v, const PIJSON & js) {
|
|
piDeserializeJSON(v.p0, js["p0"]);
|
|
piDeserializeJSON(v.p1, js["p1"]);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PIRect<T> & v, const PIJSON & js) {
|
|
PIPoint<T> bl, tr;
|
|
piDeserializeJSON(bl, js["bl"]);
|
|
piDeserializeJSON(tr, js["tr"]);
|
|
v = PIRect<T>(bl, tr);
|
|
}
|
|
|
|
|
|
// containers
|
|
|
|
template<typename T1, typename T2>
|
|
inline void piDeserializeJSON(PIPair<T1, T2> & v, const PIJSON & js) {
|
|
v = {};
|
|
if (!js.isArray()) return;
|
|
piDeserializeJSON(v.first, js[0]);
|
|
piDeserializeJSON(v.second, js[1]);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PIVector<T> & v, const PIJSON & js) {
|
|
v.clear();
|
|
if (!js.isArray()) return;
|
|
v.resize(js.size());
|
|
for (int i = 0; i < js.size(); ++i)
|
|
piDeserializeJSON(v[i], js[i]);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PIDeque<T> & v, const PIJSON & js) {
|
|
v.clear();
|
|
if (!js.isArray()) return;
|
|
v.resize(js.size());
|
|
for (int i = 0; i < js.size(); ++i)
|
|
piDeserializeJSON(v[i], js[i]);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PIVector2D<T> & v, const PIJSON & js) {
|
|
v.clear();
|
|
if (!js.isObject()) return;
|
|
v.resize(js["rows"].toInt(), js["cols"].toInt());
|
|
const auto & mat(js["mat"]);
|
|
if (!mat.isArray()) return;
|
|
piDeserializeJSON(v.plainVector(), mat);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void piDeserializeJSON(PISet<T> & v, const PIJSON & js) {
|
|
v.clear();
|
|
if (!js.isArray()) return;
|
|
T _t;
|
|
for (int i = 0; i < js.size(); ++i) {
|
|
piDeserializeJSON(_t, js[i]);
|
|
v << _t;
|
|
}
|
|
}
|
|
|
|
template<typename K, typename T>
|
|
inline void piDeserializeJSON(PIMap<K, T> & v, const PIJSON & js) {
|
|
v.clear();
|
|
if (!js.isObject()) return;
|
|
const auto & obj(js.object());
|
|
auto it = obj.makeIterator();
|
|
while (it.next())
|
|
piDeserializeJSON(v[PIVariant(it.key()).value<K>()], it.value());
|
|
}
|
|
|
|
|
|
// ---
|
|
// PIJSON static wrapper
|
|
// ---
|
|
|
|
|
|
template<typename T>
|
|
PIJSON PIJSON::serialize(const T & v) {
|
|
return piSerializeJSON(v);
|
|
}
|
|
|
|
template<typename T>
|
|
T PIJSON::deserialize(const PIJSON & json) {
|
|
T ret;
|
|
piDeserializeJSON(ret, json);
|
|
return ret;
|
|
}
|
|
|
|
|
|
#endif // pijsonserialization_h
|