SHS/pip
4
3
Fork 0
Code Issues 16 Pull Requests 1 Actions Releases Wiki Activity

merged AI doc, some new pages

Browse Source
This commit is contained in:
Пелипенко Иван
2026-03-12 14:46:57 +03:00
parent 07ae277f9e
commit ed13838237
206 changed files with 14088 additions and 5152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
libs/main/serialization/pijsonserialization.h
View File

@@ -1,12 +1,16 @@
/*! \file pijson.h
* \ingroup Serialization
* \brief
* \~english JSON serialization
* \~russian Сериализация JSON
*/
//! \~\file pijsonserialization.h
//! \~\ingroup Serialization
//! \~\brief
//! \~english Generic JSON serialization helpers
//! \~russian Вспомогательные шаблоны для сериализации JSON
//! \details
//! \~english
//! This file provides template functions for serializing and deserializing various types to and from PIJSON format.
//! \~russian
//! Этот файл предоставляет шаблонные функции для сериализации и десериализации различных типов в формат PIJSON и из него.
/*
PIP - Platform Independent Primitives
JSON serialization
Generic JSON serialization helpers
Ivan Pelipenko peri4ko@yandex.ru
This program is free software: you can redistribute it and/or modify
@@ -36,11 +40,15 @@
// enum & arithmetic
//! \~english Serializes enum values as JSON numbers.
//! \~russian Сериализует значения перечислений как JSON-числа.
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;
}
//! \~english Serializes arithmetic values as JSON scalars.
//! \~russian Сериализует арифметические значения как JSON-скаляры.
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>
@@ -48,6 +56,8 @@ inline PIJSON piSerializeJSON(const T & v) {
return PIJSON() = v;
}
//! \~english Fallback overload that intentionally fails for unsupported complex types.
//! \~russian Резервная перегрузка, которая намеренно завершает компиляцию ошибкой для неподдерживаемых сложных типов.
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>
@@ -60,14 +70,20 @@ inline PIJSON piSerializeJSON(const T & v) {
// known types
//! \~english Returns JSON node unchanged.
//! \~russian Возвращает JSON-узел без изменений.
inline PIJSON piSerializeJSON(const PIJSON & v) {
return v;
}
template<>
//! \~english Serializes %PIVariant as the matching scalar JSON node.
//! \~russian Сериализует %PIVariant в соответствующий скалярный JSON-узел.
inline PIJSON piSerializeJSON(const PIVariant & v) {
return PIJSON() = v;
}
template<typename T>
//! \~english Serializes complex number as array [real, imag].
//! \~russian Сериализует комплексное число как массив [real, imag].
inline PIJSON piSerializeJSON(const complex<T> & v) {
PIJSON ret;
ret << v.real() << v.imag();
@@ -75,26 +91,36 @@ inline PIJSON piSerializeJSON(const complex<T> & v) {
}
template<typename T>
//! \~english Serializes %PIFlags as an integer mask.
//! \~russian Сериализует %PIFlags как целочисленную маску.
inline PIJSON piSerializeJSON(const PIFlags<T> & v) {
return PIJSON() = (int)v;
}
template<>
//! \~english Serializes %PIString as JSON string.
//! \~russian Сериализует %PIString как JSON-строку.
inline PIJSON piSerializeJSON(const PIString & v) {
return PIJSON() = v;
}
template<>
//! \~english Serializes %PIConstChars as JSON string.
//! \~russian Сериализует %PIConstChars как JSON-строку.
inline PIJSON piSerializeJSON(const PIConstChars & v) {
return PIJSON() = v.toString();
}
template<>
//! \~english Serializes %PIByteArray as Base64 string.
//! \~russian Сериализует %PIByteArray как строку Base64.
inline PIJSON piSerializeJSON(const PIByteArray & v) {
return PIJSON() = PIStringAscii(v.toBase64());
}
template<>
//! \~english Serializes %PISystemTime as object with fields \c s and \c ns.
//! \~russian Сериализует %PISystemTime как объект с полями \c s и \c ns.
inline PIJSON piSerializeJSON(const PISystemTime & v) {
PIJSON ret;
ret["s"] = v.seconds;
@@ -103,6 +129,8 @@ inline PIJSON piSerializeJSON(const PISystemTime & v) {
}
template<>
//! \~english Serializes %PITime as object with fields \c h, \c m, \c s and \c z.
//! \~russian Сериализует %PITime как объект с полями \c h, \c m, \c s и \c z.
inline PIJSON piSerializeJSON(const PITime & v) {
PIJSON ret;
ret["h"] = v.hours;
@@ -113,6 +141,8 @@ inline PIJSON piSerializeJSON(const PITime & v) {
}
template<>
//! \~english Serializes %PIDate as object with fields \c y, \c M and \c d.
//! \~russian Сериализует %PIDate как объект с полями \c y, \c M и \c d.
inline PIJSON piSerializeJSON(const PIDate & v) {
PIJSON ret;
ret["y"] = v.year;
@@ -122,6 +152,8 @@ inline PIJSON piSerializeJSON(const PIDate & v) {
}
template<>
//! \~english Serializes %PIDateTime as object with fields \c y, \c M, \c d, \c h, \c m, \c s and \c z.
//! \~russian Сериализует %PIDateTime как объект с полями \c y, \c M, \c d, \c h, \c m, \c s и \c z.
inline PIJSON piSerializeJSON(const PIDateTime & v) {
PIJSON ret;
ret["y"] = v.year;
@@ -135,11 +167,15 @@ inline PIJSON piSerializeJSON(const PIDateTime & v) {
}
template<>
//! \~english Serializes %PINetworkAddress as string.
//! \~russian Сериализует %PINetworkAddress как строку.
inline PIJSON piSerializeJSON(const PINetworkAddress & v) {
return PIJSON() = v.toString();
}
template<typename T>
//! \~english Serializes %PIPoint as object with fields \c x and \c y.
//! \~russian Сериализует %PIPoint как объект с полями \c x и \c y.
inline PIJSON piSerializeJSON(const PIPoint<T> & v) {
PIJSON ret;
ret["x"] = piSerializeJSON(v.x);
@@ -148,6 +184,8 @@ inline PIJSON piSerializeJSON(const PIPoint<T> & v) {
}
template<typename T>
//! \~english Serializes %PILine as object with fields \c p0 and \c p1.
//! \~russian Сериализует %PILine как объект с полями \c p0 и \c p1.
inline PIJSON piSerializeJSON(const PILine<T> & v) {
PIJSON ret;
ret["p0"] = piSerializeJSON(v.p0);
@@ -156,6 +194,8 @@ inline PIJSON piSerializeJSON(const PILine<T> & v) {
}
template<typename T>
//! \~english Serializes %PIRect as object with fields \c bl and \c tr.
//! \~russian Сериализует %PIRect как объект с полями \c bl и \c tr.
inline PIJSON piSerializeJSON(const PIRect<T> & v) {
PIJSON ret;
ret["bl"] = piSerializeJSON(v.bottomLeft());
@@ -166,6 +206,8 @@ inline PIJSON piSerializeJSON(const PIRect<T> & v) {
// containers
//! \~english Serializes %PIPair as two-element array.
//! \~russian Сериализует %PIPair как массив из двух элементов.
template<typename T1, typename T2>
inline PIJSON piSerializeJSON(const PIPair<T1, T2> & v) {
PIJSON ret;
@@ -174,6 +216,8 @@ inline PIJSON piSerializeJSON(const PIPair<T1, T2> & v) {
}
template<typename T>
//! \~english Serializes %PIVector as JSON array.
//! \~russian Сериализует %PIVector как JSON-массив.
inline PIJSON piSerializeJSON(const PIVector<T> & v) {
if (v.isEmpty()) return PIJSON::newArray();
PIJSON ret;
@@ -183,6 +227,8 @@ inline PIJSON piSerializeJSON(const PIVector<T> & v) {
}
template<typename T>
//! \~english Serializes %PIDeque as JSON array.
//! \~russian Сериализует %PIDeque как JSON-массив.
inline PIJSON piSerializeJSON(const PIDeque<T> & v) {
if (v.isEmpty()) return PIJSON::newArray();
PIJSON ret;
@@ -192,6 +238,8 @@ inline PIJSON piSerializeJSON(const PIDeque<T> & v) {
}
template<typename T>
//! \~english Serializes %PIVector2D as object with \c rows, \c cols and flattened \c mat.
//! \~russian Сериализует %PIVector2D как объект с \c rows, \c cols и плоским массивом \c mat.
inline PIJSON piSerializeJSON(const PIVector2D<T> & v) {
PIJSON ret;
ret["cols"] = static_cast<uint>(v.cols());
@@ -201,6 +249,8 @@ inline PIJSON piSerializeJSON(const PIVector2D<T> & v) {
}
template<typename T>
//! \~english Serializes %PISet as JSON array.
//! \~russian Сериализует %PISet как JSON-массив.
inline PIJSON piSerializeJSON(const PISet<T> & v) {
if (v.isEmpty()) return PIJSON::newArray();
PIJSON ret;
@@ -210,6 +260,8 @@ inline PIJSON piSerializeJSON(const PISet<T> & v) {
}
template<typename K, typename T>
//! \~english Serializes %PIMap as JSON object with stringified keys.
//! \~russian Сериализует %PIMap как JSON-объект со строковыми ключами.
inline PIJSON piSerializeJSON(const PIMap<K, T> & v) {
if (v.isEmpty()) return PIJSON::newObject();
PIJSON ret;
@@ -220,6 +272,8 @@ inline PIJSON piSerializeJSON(const PIMap<K, T> & v) {
}
template<typename T>
//! \~english Serializes %PIMathVector as JSON array.
//! \~russian Сериализует %PIMathVector как JSON-массив.
inline PIJSON piSerializeJSON(const PIMathVector<T> & v) {
PIJSON ret;
for (uint i = 0; i < v.size(); ++i)
@@ -228,6 +282,8 @@ inline PIJSON piSerializeJSON(const PIMathVector<T> & v) {
}
template<uint Size, typename T>
//! \~english Serializes fixed-size %PIMathVectorT as JSON array.
//! \~russian Сериализует %PIMathVectorT фиксированного размера как JSON-массив.
inline PIJSON piSerializeJSON(const PIMathVectorT<Size, T> & v) {
PIJSON ret;
for (uint i = 0; i < v.size(); ++i)
@@ -243,11 +299,15 @@ inline PIJSON piSerializeJSON(const PIMathVectorT<Size, T> & v) {
// enum & arithmetic
//! \~english Deserializes enum value from JSON number.
//! \~russian Десериализует значение перечисления из JSON-числа.
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();
}
//! \~english Deserializes arithmetic value from JSON scalar.
//! \~russian Десериализует арифметическое значение из JSON-скаляра.
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>
@@ -255,6 +315,8 @@ inline void piDeserializeJSON(T & v, const PIJSON & js) {
v = js.value().value<T>();
}
//! \~english Fallback overload that intentionally fails for unsupported complex types.
//! \~russian Резервная перегрузка, которая намеренно завершает компиляцию ошибкой для неподдерживаемых сложных типов.
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>
@@ -267,15 +329,21 @@ inline void piDeserializeJSON(T & v, const PIJSON & js) {
// known types
//! \~english Copies JSON node as-is.
//! \~russian Копирует JSON-узел без изменений.
inline void piDeserializeJSON(PIJSON & v, const PIJSON & js) {
v = js;
}
template<>
//! \~english Extracts scalar value from JSON node into %PIVariant.
//! \~russian Извлекает скалярное значение JSON-узла в %PIVariant.
inline void piDeserializeJSON(PIVariant & v, const PIJSON & js) {
v = js.value();
}
template<typename T>
//! \~english Deserializes complex number from array [real, imag].
//! \~russian Десериализует комплексное число из массива [real, imag].
inline void piDeserializeJSON(complex<T> & v, const PIJSON & js) {
if (!js.isArray()) return;
piDeserializeJSON(reinterpret_cast<T(&)[2]>(v)[0], js[0]);
@@ -283,27 +351,37 @@ inline void piDeserializeJSON(complex<T> & v, const PIJSON & js) {
}
template<typename T>
//! \~english Deserializes %PIFlags from integer mask.
//! \~russian Десериализует %PIFlags из целочисленной маски.
inline void piDeserializeJSON(PIFlags<T> & v, const PIJSON & js) {
v = js.toInt();
}
template<>
//! \~english Deserializes %PIString from JSON string representation.
//! \~russian Десериализует %PIString из строкового представления JSON.
inline void piDeserializeJSON(PIString & v, const PIJSON & js) {
v = js.toString();
}
template<>
//! \~english Deserializes %PIByteArray from Base64 string.
//! \~russian Десериализует %PIByteArray из строки Base64.
inline void piDeserializeJSON(PIByteArray & v, const PIJSON & js) {
v = PIByteArray::fromBase64(js.toString());
}
template<>
//! \~english Deserializes %PISystemTime from object with fields \c s and \c ns.
//! \~russian Десериализует %PISystemTime из объекта с полями \c s и \c ns.
inline void piDeserializeJSON(PISystemTime & v, const PIJSON & js) {
piDeserializeJSON(v.seconds, js["s"]);
piDeserializeJSON(v.nanoseconds, js["ns"]);
}
template<>
//! \~english Deserializes %PITime from object with fields \c h, \c m, \c s and \c z.
//! \~russian Десериализует %PITime из объекта с полями \c h, \c m, \c s и \c z.
inline void piDeserializeJSON(PITime & v, const PIJSON & js) {
v.hours = js["h"].toInt();
v.minutes = js["m"].toInt();
@@ -312,6 +390,8 @@ inline void piDeserializeJSON(PITime & v, const PIJSON & js) {
}
template<>
//! \~english Deserializes %PIDate from object with fields \c y, \c M and \c d.
//! \~russian Десериализует %PIDate из объекта с полями \c y, \c M и \c d.
inline void piDeserializeJSON(PIDate & v, const PIJSON & js) {
v.year = js["y"].toInt();
v.month = js["M"].toInt();
@@ -319,6 +399,8 @@ inline void piDeserializeJSON(PIDate & v, const PIJSON & js) {
}
template<>
//! \~english Deserializes %PIDateTime from object with fields \c y, \c M, \c d, \c h, \c m, \c s and \c z.
//! \~russian Десериализует %PIDateTime из объекта с полями \c y, \c M, \c d, \c h, \c m, \c s и \c z.
inline void piDeserializeJSON(PIDateTime & v, const PIJSON & js) {
v.year = js["y"].toInt();
v.month = js["M"].toInt();
@@ -330,23 +412,31 @@ inline void piDeserializeJSON(PIDateTime & v, const PIJSON & js) {
}
template<>
//! \~english Deserializes %PINetworkAddress from string.
//! \~russian Десериализует %PINetworkAddress из строки.
inline void piDeserializeJSON(PINetworkAddress & v, const PIJSON & js) {
v = PINetworkAddress(js.toString());
}
template<typename T>
//! \~english Deserializes %PIPoint from object with fields \c x and \c y.
//! \~russian Десериализует %PIPoint из объекта с полями \c x и \c y.
inline void piDeserializeJSON(PIPoint<T> & v, const PIJSON & js) {
piDeserializeJSON(v.x, js["x"]);
piDeserializeJSON(v.y, js["y"]);
}
template<typename T>
//! \~english Deserializes %PILine from object with fields \c p0 and \c p1.
//! \~russian Десериализует %PILine из объекта с полями \c p0 и \c p1.
inline void piDeserializeJSON(PILine<T> & v, const PIJSON & js) {
piDeserializeJSON(v.p0, js["p0"]);
piDeserializeJSON(v.p1, js["p1"]);
}
template<typename T>
//! \~english Deserializes %PIRect from object with fields \c bl and \c tr.
//! \~russian Десериализует %PIRect из объекта с полями \c bl и \c tr.
inline void piDeserializeJSON(PIRect<T> & v, const PIJSON & js) {
PIPoint<T> bl, tr;
piDeserializeJSON(bl, js["bl"]);
@@ -357,6 +447,8 @@ inline void piDeserializeJSON(PIRect<T> & v, const PIJSON & js) {
// containers
//! \~english Deserializes %PIPair from two-element array.
//! \~russian Десериализует %PIPair из массива из двух элементов.
template<typename T1, typename T2>
inline void piDeserializeJSON(PIPair<T1, T2> & v, const PIJSON & js) {
v = {};
@@ -366,6 +458,8 @@ inline void piDeserializeJSON(PIPair<T1, T2> & v, const PIJSON & js) {
}
template<typename T>
//! \~english Deserializes %PIVector from JSON array.
//! \~russian Десериализует %PIVector из JSON-массива.
inline void piDeserializeJSON(PIVector<T> & v, const PIJSON & js) {
v.clear();
if (!js.isArray()) return;
@@ -375,6 +469,8 @@ inline void piDeserializeJSON(PIVector<T> & v, const PIJSON & js) {
}
template<typename T>
//! \~english Deserializes %PIDeque from JSON array.
//! \~russian Десериализует %PIDeque из JSON-массива.
inline void piDeserializeJSON(PIDeque<T> & v, const PIJSON & js) {
v.clear();
if (!js.isArray()) return;
@@ -384,6 +480,8 @@ inline void piDeserializeJSON(PIDeque<T> & v, const PIJSON & js) {
}
template<typename T>
//! \~english Deserializes %PIVector2D from object with \c rows, \c cols and flattened \c mat.
//! \~russian Десериализует %PIVector2D из объекта с \c rows, \c cols и плоским массивом \c mat.
inline void piDeserializeJSON(PIVector2D<T> & v, const PIJSON & js) {
v.clear();
if (!js.isObject()) return;
@@ -394,6 +492,8 @@ inline void piDeserializeJSON(PIVector2D<T> & v, const PIJSON & js) {
}
template<typename T>
//! \~english Deserializes %PISet from JSON array.
//! \~russian Десериализует %PISet из JSON-массива.
inline void piDeserializeJSON(PISet<T> & v, const PIJSON & js) {
v.clear();
if (!js.isArray()) return;
@@ -405,6 +505,8 @@ inline void piDeserializeJSON(PISet<T> & v, const PIJSON & js) {
}
template<typename K, typename T>
//! \~english Deserializes %PIMap from JSON object with stringified keys.
//! \~russian Десериализует %PIMap из JSON-объекта со строковыми ключами.
inline void piDeserializeJSON(PIMap<K, T> & v, const PIJSON & js) {
v.clear();
if (!js.isObject()) return;
@@ -415,6 +517,8 @@ inline void piDeserializeJSON(PIMap<K, T> & v, const PIJSON & js) {
}
template<typename T>
//! \~english Deserializes dynamic %PIMathVector from JSON array.
//! \~russian Десериализует динамический %PIMathVector из JSON-массива.
inline void piDeserializeJSON(PIMathVector<T> & v, const PIJSON & js) {
v = {};
if (!js.isArray()) return;
@@ -424,6 +528,8 @@ inline void piDeserializeJSON(PIMathVector<T> & v, const PIJSON & js) {
}
template<uint Size, typename T>
//! \~english Deserializes fixed-size %PIMathVectorT from JSON array, truncating extra items.
//! \~russian Десериализует %PIMathVectorT фиксированного размера из JSON-массива, отбрасывая лишние элементы.
inline void piDeserializeJSON(PIMathVectorT<Size, T> & v, const PIJSON & js) {
v = PIMathVectorT<Size, T>();
if (!js.isArray()) return;
@@ -439,11 +545,15 @@ inline void piDeserializeJSON(PIMathVectorT<Size, T> & v, const PIJSON & js) {
template<typename T>
//! \~english Convenience wrapper around \a piSerializeJSON().
//! \~russian Вспомогательная обертка над \a piSerializeJSON().
PIJSON PIJSON::serialize(const T & v) {
return piSerializeJSON(v);
}
template<typename T>
//! \~english Convenience wrapper around \a piDeserializeJSON().
//! \~russian Вспомогательная обертка над \a piDeserializeJSON().
T PIJSON::deserialize(const PIJSON & json) {
T ret;
piDeserializeJSON(ret, json);