161 lines
3.4 KiB
Plaintext
Executable File
161 lines
3.4 KiB
Plaintext
Executable File
/**
|
|
* Json <-> DDS conversion routines
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Christian Ehrlicher, SLSE, 2017-11-30
|
|
*/
|
|
|
|
{% autoescape off %}
|
|
// filename: {{ namespace_abbr }}_json.cpp
|
|
|
|
#include "{{ namespace_abbr }}_json.h"
|
|
#include <QJsonArray>
|
|
#include <QJsonObject>
|
|
#include <QJsonDocument>
|
|
#include <LtsUtilsCore/dds_vector.h>
|
|
#include <dds/core/String.hpp>
|
|
|
|
namespace {{ namespace }}
|
|
{
|
|
template<>
|
|
int fromJson(const QJsonValue &val, type<int>)
|
|
{
|
|
return val.toInt();
|
|
}
|
|
|
|
template<>
|
|
double fromJson(const QJsonValue &val, type<double>)
|
|
{
|
|
return val.toDouble();
|
|
}
|
|
|
|
template<>
|
|
qint64 fromJson(const QJsonValue &val, type<qint64>)
|
|
{
|
|
return val.toString().toLongLong();
|
|
}
|
|
|
|
QJsonValue toJson(int vec)
|
|
{
|
|
return QJsonValue(vec);
|
|
}
|
|
QJsonValue toJson(double vec)
|
|
{
|
|
return QJsonValue(vec);
|
|
}
|
|
QJsonValue toJson(qint64 vec)
|
|
{
|
|
return QJsonValue(QString::number(vec));
|
|
}
|
|
|
|
// std::string
|
|
QJsonValue toJson(const std::string &element)
|
|
{
|
|
return QJsonValue(QString::fromStdString(element));
|
|
}
|
|
template<>
|
|
std::string fromJson(const QJsonValue &val, type<std::string>)
|
|
{
|
|
return val.toString().toStdString();
|
|
}
|
|
|
|
// std::vector<T>
|
|
template<typename T>
|
|
QJsonArray toJson(const std::vector<T> &vec)
|
|
{
|
|
QJsonArray arr;
|
|
for (const auto &element : vec)
|
|
arr.push_back(toJson(element));
|
|
return arr;
|
|
}
|
|
|
|
template<typename T>
|
|
std::vector<T> fromJson(const QJsonValue &val, type<std::vector<T>>)
|
|
{
|
|
std::vector<T> ret;
|
|
if (!val.isArray())
|
|
return ret;
|
|
const QJsonArray array(val.toArray());
|
|
ret.reserve(array.size());
|
|
for(int i = 0; i < array.size(); ++i)
|
|
ret.push_back(fromJson(array.at(i), type<T>{}));
|
|
return ret;
|
|
}
|
|
|
|
// dds::core:vector<uint8_t> (bytestream)
|
|
inline QJsonValue toJson(const std::vector<uint8_t> &element)
|
|
{
|
|
return QJsonValue(QString::fromLatin1(QByteArray::fromRawData(reinterpret_cast<const char *>(&element.at(0)),
|
|
static_cast<int>(element.size())).toBase64()));
|
|
}
|
|
template<>
|
|
std::vector<uint8_t> fromJson(const QJsonValue &val, type<std::vector<uint8_t>>)
|
|
{
|
|
const QByteArray ba(QByteArray::fromBase64(val.toString().toLatin1()));
|
|
return LtsUtils::convert<std::vector<uint8_t>>(ba);
|
|
}
|
|
|
|
{% for dt in jsonTopics %}
|
|
// {{ dt.name }}
|
|
QJsonObject toJson(const {{ dt.name }} &element)
|
|
{
|
|
QJsonObject obj;
|
|
{% for row in dt.cppMember %}
|
|
{{ row.ddsToJsonElement }};
|
|
{% endfor %}
|
|
return obj;
|
|
}
|
|
|
|
template<>
|
|
{{ dt.name }} fromJson(const QJsonValue &value, type<{{ dt.name }}>)
|
|
{
|
|
const QJsonObject objElement(value.toObject());
|
|
{{ dt.name }} element;
|
|
|
|
{% for row in dt.cppMember %}
|
|
{ {{ row.jsonElementToDds }}; } {% endfor %}
|
|
|
|
return element;
|
|
}
|
|
|
|
//
|
|
// extensions to support sequence of seqence of Non-POD :
|
|
//
|
|
|
|
QJsonValue toJson(const std::vector <{{ dt.name }} > &element)
|
|
{
|
|
|
|
if (element.size() == 0)
|
|
return QJsonValue();
|
|
QJsonArray array;
|
|
for(size_t i = 0; i < element.size(); ++i)
|
|
array.push_back(toJson(element.at(i)));
|
|
|
|
return array;
|
|
}
|
|
|
|
template<>
|
|
std::vector<{{ dt.name }}> fromJson(const QJsonValue &value, type< std::vector <{{ dt.name }} > >)
|
|
{
|
|
std::vector < {{ dt.name }} > ret;
|
|
if (value.isNull())
|
|
return ret;
|
|
if (!value.isArray())
|
|
return ret;
|
|
|
|
const QJsonArray array = value.toArray();
|
|
ret.reserve(array.size());
|
|
for(const auto &ele : array)
|
|
ret.push_back(fromJson(ele, type<{{ dt.name }}>{}));
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
{% endfor %}
|
|
|
|
} // namespace {{ namespace }}
|
|
|
|
{% endautoescape %}
|