qt-migration-legatus/qt6-after/qt6-migrated-legatus/build4/Lts/Services/ProjectDataManagement/pdm_json.cpp

/**
  * Json <-> DDS conversion routines
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2017-11-30
  */


// filename: pdm_json.cpp

#include "pdm_json.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <LtsUtilsCore/dds_vector.h>
#include <dds/core/String.hpp>

namespace ProjectDataManagement
{
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);
}


// BiteComponentText
QJsonObject toJson(const BiteComponentText &element)
{
  QJsonObject obj;
  obj[QStringLiteral("canDeviceId")] = element.canDeviceId;
  obj[QStringLiteral("subDeviceId")] = element.subDeviceId;
  obj[QStringLiteral("errorNumber")] = element.errorNumber;
  return obj;
}

template<>
BiteComponentText fromJson(const QJsonValue &value, type<BiteComponentText>)
{
  const QJsonObject objElement(value.toObject());
  BiteComponentText element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("canDeviceId"))); element.canDeviceId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("subDeviceId"))); element.subDeviceId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("errorNumber"))); element.errorNumber = val.toInt(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <BiteComponentText > &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<BiteComponentText> fromJson(const QJsonValue &value, type< std::vector <BiteComponentText > >)
{
  std::vector < BiteComponentText > 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<BiteComponentText>{}));
  return ret;
}




// BuildingChargeEffect
QJsonObject toJson(const BuildingChargeEffect &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("destructiveFactor")] = element.destructiveFactor;
  obj[QStringLiteral("penetrationFactor")] = element.penetrationFactor;
  obj[QStringLiteral("hitSound")] = element.hitSound;
  obj[QStringLiteral("difcueLight")] = element.difcueLight;
  obj[QStringLiteral("difcuePyro")] = element.difcuePyro;
  return obj;
}

template<>
BuildingChargeEffect fromJson(const QJsonValue &value, type<BuildingChargeEffect>)
{
  const QJsonObject objElement(value.toObject());
  BuildingChargeEffect element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("destructiveFactor"))); element.destructiveFactor = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("penetrationFactor"))); element.penetrationFactor = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("hitSound"))); element.hitSound = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("difcueLight"))); element.difcueLight = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("difcuePyro"))); element.difcuePyro = val.toBool(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <BuildingChargeEffect > &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<BuildingChargeEffect> fromJson(const QJsonValue &value, type< std::vector <BuildingChargeEffect > >)
{
  std::vector < BuildingChargeEffect > 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<BuildingChargeEffect>{}));
  return ret;
}




// CanComponentString
QJsonObject toJson(const CanComponentString &element)
{
  QJsonObject obj;
  obj[QStringLiteral("pdm_bitMask")] = static_cast<qint64>(element.pdm_bitMask);
  obj[QStringLiteral("canDeviceId")] = element.canDeviceId;
  obj[QStringLiteral("subDeviceId")] = element.subDeviceId;
  return obj;
}

template<>
CanComponentString fromJson(const QJsonValue &value, type<CanComponentString>)
{
  const QJsonObject objElement(value.toObject());
  CanComponentString element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("pdm_bitMask"))); element.pdm_bitMask = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("canDeviceId"))); element.canDeviceId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("subDeviceId"))); element.subDeviceId = val.toInt(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <CanComponentString > &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<CanComponentString> fromJson(const QJsonValue &value, type< std::vector <CanComponentString > >)
{
  std::vector < CanComponentString > 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<CanComponentString>{}));
  return ret;
}




// ChargeType
QJsonObject toJson(const ChargeType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("shortName")] = QString::fromStdString(element.shortName);
  obj[QStringLiteral("predefinedName")] = QString::fromStdString(element.predefinedName);
  obj[QStringLiteral("disEntity")] = QString::fromStdString(element.disEntity);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  obj[QStringLiteral("legacyId")] = element.legacyId;
  return obj;
}

template<>
ChargeType fromJson(const QJsonValue &value, type<ChargeType>)
{
  const QJsonObject objElement(value.toObject());
  ChargeType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("shortName"))); element.shortName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("predefinedName"))); element.predefinedName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("disEntity"))); element.disEntity = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("legacyId"))); element.legacyId = val.toInt(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <ChargeType > &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<ChargeType> fromJson(const QJsonValue &value, type< std::vector <ChargeType > >)
{
  std::vector < ChargeType > 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<ChargeType>{}));
  return ret;
}




// ChargeTypeIgniterTypeIgniterFunction
QJsonObject toJson(const ChargeTypeIgniterTypeIgniterFunction &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("igniterTypeId")] = element.igniterTypeId;
  obj[QStringLiteral("igniterFunctionId")] = element.igniterFunctionId;
  obj[QStringLiteral("igniterFunctionBaseId")] = toJson(static_cast<int>(element.igniterFunctionBaseId));
  obj[QStringLiteral("impactArea")] = QString::fromStdString(element.impactArea);
  obj[QStringLiteral("impactRadius")] = element.impactRadius;
  obj[QStringLiteral("hazardDistance")] = element.hazardDistance;
  obj[QStringLiteral("chargeLegacyId")] = element.chargeLegacyId;
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
ChargeTypeIgniterTypeIgniterFunction fromJson(const QJsonValue &value, type<ChargeTypeIgniterTypeIgniterFunction>)
{
  const QJsonObject objElement(value.toObject());
  ChargeTypeIgniterTypeIgniterFunction element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("igniterTypeId"))); element.igniterTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("igniterFunctionId"))); element.igniterFunctionId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("igniterFunctionBaseId"))); element.igniterFunctionBaseId = static_cast<ProjectDataManagement::IgniterFunctionBase>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("impactArea"))); element.impactArea = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("impactRadius"))); element.impactRadius = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("hazardDistance"))); element.hazardDistance = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeLegacyId"))); element.chargeLegacyId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <ChargeTypeIgniterTypeIgniterFunction > &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<ChargeTypeIgniterTypeIgniterFunction> fromJson(const QJsonValue &value, type< std::vector <ChargeTypeIgniterTypeIgniterFunction > >)
{
  std::vector < ChargeTypeIgniterTypeIgniterFunction > 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<ChargeTypeIgniterTypeIgniterFunction>{}));
  return ret;
}




// ChargeTypeLoadType
QJsonObject toJson(const ChargeTypeLoadType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("loadTypeId")] = element.loadTypeId;
  obj[QStringLiteral("numbers")] = toJson(element.numbers);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
ChargeTypeLoadType fromJson(const QJsonValue &value, type<ChargeTypeLoadType>)
{
  const QJsonObject objElement(value.toObject());
  ChargeTypeLoadType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loadTypeId"))); element.loadTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("numbers"))); element.numbers = fromJson<std::vector<int32_t>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <ChargeTypeLoadType > &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<ChargeTypeLoadType> fromJson(const QJsonValue &value, type< std::vector <ChargeTypeLoadType > >)
{
  std::vector < ChargeTypeLoadType > 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<ChargeTypeLoadType>{}));
  return ret;
}




// EquipmentSystemEventFilter
QJsonObject toJson(const EquipmentSystemEventFilter &element)
{
  QJsonObject obj;
  obj[QStringLiteral("equipmentFunctionId")] = element.equipmentFunctionId;
  obj[QStringLiteral("subDeviceId")] = element.subDeviceId;
  obj[QStringLiteral("deviceSpecificCode")] = element.deviceSpecificCode;
  obj[QStringLiteral("hgrMineSearchFilterType")] = toJson(static_cast<int>(element.hgrMineSearchFilterType));
  return obj;
}

template<>
EquipmentSystemEventFilter fromJson(const QJsonValue &value, type<EquipmentSystemEventFilter>)
{
  const QJsonObject objElement(value.toObject());
  EquipmentSystemEventFilter element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("equipmentFunctionId"))); element.equipmentFunctionId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("subDeviceId"))); element.subDeviceId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("deviceSpecificCode"))); element.deviceSpecificCode = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("hgrMineSearchFilterType"))); element.hgrMineSearchFilterType = static_cast<ProjectDataManagement::HgrMineSearchFilterType>(val.toInt()); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <EquipmentSystemEventFilter > &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<EquipmentSystemEventFilter> fromJson(const QJsonValue &value, type< std::vector <EquipmentSystemEventFilter > >)
{
  std::vector < EquipmentSystemEventFilter > 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<EquipmentSystemEventFilter>{}));
  return ret;
}




// EventFilterHgrMineSearch
QJsonObject toJson(const EventFilterHgrMineSearch &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("hgrMineSearchFilterType")] = toJson(static_cast<int>(element.hgrMineSearchFilterType));
  return obj;
}

template<>
EventFilterHgrMineSearch fromJson(const QJsonValue &value, type<EventFilterHgrMineSearch>)
{
  const QJsonObject objElement(value.toObject());
  EventFilterHgrMineSearch element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("hgrMineSearchFilterType"))); element.hgrMineSearchFilterType = static_cast<ProjectDataManagement::HgrMineSearchFilterType>(val.toInt()); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <EventFilterHgrMineSearch > &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<EventFilterHgrMineSearch> fromJson(const QJsonValue &value, type< std::vector <EventFilterHgrMineSearch > >)
{
  std::vector < EventFilterHgrMineSearch > 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<EventFilterHgrMineSearch>{}));
  return ret;
}




// FirePurpose
QJsonObject toJson(const FirePurpose &element)
{
  QJsonObject obj;
  obj[QStringLiteral("description")] = QString::fromStdString(element.description);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
FirePurpose fromJson(const QJsonValue &value, type<FirePurpose>)
{
  const QJsonObject objElement(value.toObject());
  FirePurpose element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("description"))); element.description = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <FirePurpose > &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<FirePurpose> fromJson(const QJsonValue &value, type< std::vector <FirePurpose > >)
{
  std::vector < FirePurpose > 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<FirePurpose>{}));
  return ret;
}




// GearType
QJsonObject toJson(const GearType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("gearClassId")] = toJson(static_cast<int>(element.gearClassId));
  obj[QStringLiteral("tasCode")] = element.tasCode;
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
GearType fromJson(const QJsonValue &value, type<GearType>)
{
  const QJsonObject objElement(value.toObject());
  GearType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("gearClassId"))); element.gearClassId = static_cast<ProjectDataManagement::GearClass>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("tasCode"))); element.tasCode = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <GearType > &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<GearType> fromJson(const QJsonValue &value, type< std::vector <GearType > >)
{
  std::vector < GearType > 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<GearType>{}));
  return ret;
}




// GearTypeChargeType
QJsonObject toJson(const GearTypeChargeType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("maxRange")] = element.maxRange;
  obj[QStringLiteral("gearTypeId")] = element.gearTypeId;
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
GearTypeChargeType fromJson(const QJsonValue &value, type<GearTypeChargeType>)
{
  const QJsonObject objElement(value.toObject());
  GearTypeChargeType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("maxRange"))); element.maxRange = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("gearTypeId"))); element.gearTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <GearTypeChargeType > &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<GearTypeChargeType> fromJson(const QJsonValue &value, type< std::vector <GearTypeChargeType > >)
{
  std::vector < GearTypeChargeType > 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<GearTypeChargeType>{}));
  return ret;
}




// IgniterFunction
QJsonObject toJson(const IgniterFunction &element)
{
  QJsonObject obj;
  obj[QStringLiteral("shortName")] = QString::fromStdString(element.shortName);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
IgniterFunction fromJson(const QJsonValue &value, type<IgniterFunction>)
{
  const QJsonObject objElement(value.toObject());
  IgniterFunction element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("shortName"))); element.shortName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <IgniterFunction > &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<IgniterFunction> fromJson(const QJsonValue &value, type< std::vector <IgniterFunction > >)
{
  std::vector < IgniterFunction > 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<IgniterFunction>{}));
  return ret;
}




// IgniterType
QJsonObject toJson(const IgniterType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("shortName")] = QString::fromStdString(element.shortName);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
IgniterType fromJson(const QJsonValue &value, type<IgniterType>)
{
  const QJsonObject objElement(value.toObject());
  IgniterType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("shortName"))); element.shortName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <IgniterType > &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<IgniterType> fromJson(const QJsonValue &value, type< std::vector <IgniterType > >)
{
  std::vector < IgniterType > 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<IgniterType>{}));
  return ret;
}




// LanguageHmi
QJsonObject toJson(const LanguageHmi &element)
{
  QJsonObject obj;
  obj[QStringLiteral("isoCode")] = QString::fromStdString(element.isoCode);
  obj[QStringLiteral("dbLocale")] = QString::fromStdString(element.dbLocale);
  return obj;
}

template<>
LanguageHmi fromJson(const QJsonValue &value, type<LanguageHmi>)
{
  const QJsonObject objElement(value.toObject());
  LanguageHmi element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("isoCode"))); element.isoCode = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("dbLocale"))); element.dbLocale = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <LanguageHmi > &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<LanguageHmi> fromJson(const QJsonValue &value, type< std::vector <LanguageHmi > >)
{
  std::vector < LanguageHmi > 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<LanguageHmi>{}));
  return ret;
}




// LanguageXdu
QJsonObject toJson(const LanguageXdu &element)
{
  QJsonObject obj;
  obj[QStringLiteral("isoCode")] = QString::fromStdString(element.isoCode);
  return obj;
}

template<>
LanguageXdu fromJson(const QJsonValue &value, type<LanguageXdu>)
{
  const QJsonObject objElement(value.toObject());
  LanguageXdu element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("isoCode"))); element.isoCode = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <LanguageXdu > &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<LanguageXdu> fromJson(const QJsonValue &value, type< std::vector <LanguageXdu > >)
{
  std::vector < LanguageXdu > 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<LanguageXdu>{}));
  return ret;
}




// LoadType
QJsonObject toJson(const LoadType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("shortName")] = QString::fromStdString(element.shortName);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
LoadType fromJson(const QJsonValue &value, type<LoadType>)
{
  const QJsonObject objElement(value.toObject());
  LoadType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("shortName"))); element.shortName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <LoadType > &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<LoadType> fromJson(const QJsonValue &value, type< std::vector <LoadType > >)
{
  std::vector < LoadType > 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<LoadType>{}));
  return ret;
}




// NuclearPreset
QJsonObject toJson(const NuclearPreset &element)
{
  QJsonObject obj;
  obj[QStringLiteral("detonationValue")] = element.detonationValue;
  obj[QStringLiteral("impactRadius")] = element.impactRadius;
  obj[QStringLiteral("borderLengthInner")] = element.borderLengthInner;
  obj[QStringLiteral("borderLengthOuter")] = element.borderLengthOuter;
  return obj;
}

template<>
NuclearPreset fromJson(const QJsonValue &value, type<NuclearPreset>)
{
  const QJsonObject objElement(value.toObject());
  NuclearPreset element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("detonationValue"))); element.detonationValue = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("impactRadius"))); element.impactRadius = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("borderLengthInner"))); element.borderLengthInner = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("borderLengthOuter"))); element.borderLengthOuter = val.toDouble(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <NuclearPreset > &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<NuclearPreset> fromJson(const QJsonValue &value, type< std::vector <NuclearPreset > >)
{
  std::vector < NuclearPreset > 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<NuclearPreset>{}));
  return ret;
}




// PdmBase
QJsonObject toJson(const PdmBase &element)
{
  QJsonObject obj;
  obj[QStringLiteral("id")] = element.id;
  return obj;
}

template<>
PdmBase fromJson(const QJsonValue &value, type<PdmBase>)
{
  const QJsonObject objElement(value.toObject());
  PdmBase element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("id"))); element.id = val.toInt(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <PdmBase > &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<PdmBase> fromJson(const QJsonValue &value, type< std::vector <PdmBase > >)
{
  std::vector < PdmBase > 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<PdmBase>{}));
  return ret;
}




// PdmBaseName
QJsonObject toJson(const PdmBaseName &element)
{
  QJsonObject obj;
  obj[QStringLiteral("name")] = QString::fromStdString(element.name);
  return obj;
}

template<>
PdmBaseName fromJson(const QJsonValue &value, type<PdmBaseName>)
{
  const QJsonObject objElement(value.toObject());
  PdmBaseName element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("name"))); element.name = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <PdmBaseName > &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<PdmBaseName> fromJson(const QJsonValue &value, type< std::vector <PdmBaseName > >)
{
  std::vector < PdmBaseName > 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<PdmBaseName>{}));
  return ret;
}




// RadioGroup
QJsonObject toJson(const RadioGroup &element)
{
  QJsonObject obj;
  obj[QStringLiteral("base_group")] = element.base_group;
  obj[QStringLiteral("issi")] = element.issi;
  obj[QStringLiteral("group_issi1")] = element.group_issi1;
  obj[QStringLiteral("group_issi2")] = element.group_issi2;
  obj[QStringLiteral("radioHostname")] = QString::fromStdString(element.radioHostname);
  obj[QStringLiteral("radioPort")] = element.radioPort;
  obj[QStringLiteral("radioBackupHostname")] = QString::fromStdString(element.radioBackupHostname);
  obj[QStringLiteral("radioBackupPort")] = element.radioBackupPort;
  return obj;
}

template<>
RadioGroup fromJson(const QJsonValue &value, type<RadioGroup>)
{
  const QJsonObject objElement(value.toObject());
  RadioGroup element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("base_group"))); element.base_group = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("issi"))); element.issi = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("group_issi1"))); element.group_issi1 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("group_issi2"))); element.group_issi2 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radioHostname"))); element.radioHostname = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radioPort"))); element.radioPort = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radioBackupHostname"))); element.radioBackupHostname = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radioBackupPort"))); element.radioBackupPort = val.toInt(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <RadioGroup > &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<RadioGroup> fromJson(const QJsonValue &value, type< std::vector <RadioGroup > >)
{
  std::vector < RadioGroup > 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<RadioGroup>{}));
  return ret;
}




// SanitationInjury
QJsonObject toJson(const SanitationInjury &element)
{
  QJsonObject obj;
  obj[QStringLiteral("kind")] = element.kind;
  obj[QStringLiteral("place1")] = element.place1;
  obj[QStringLiteral("place2")] = element.place2;
  obj[QStringLiteral("vbg")] = element.vbg;
  return obj;
}

template<>
SanitationInjury fromJson(const QJsonValue &value, type<SanitationInjury>)
{
  const QJsonObject objElement(value.toObject());
  SanitationInjury element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("kind"))); element.kind = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("place1"))); element.place1 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("place2"))); element.place2 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vbg"))); element.vbg = val.toInt(); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <SanitationInjury > &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<SanitationInjury> fromJson(const QJsonValue &value, type< std::vector <SanitationInjury > >)
{
  std::vector < SanitationInjury > 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<SanitationInjury>{}));
  return ret;
}




// SanitationInjuryKind
QJsonObject toJson(const SanitationInjuryKind &element)
{
  QJsonObject obj;
  obj[QStringLiteral("version")] = QString::fromStdString(element.version);
  return obj;
}

template<>
SanitationInjuryKind fromJson(const QJsonValue &value, type<SanitationInjuryKind>)
{
  const QJsonObject objElement(value.toObject());
  SanitationInjuryKind element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("version"))); element.version = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <SanitationInjuryKind > &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<SanitationInjuryKind> fromJson(const QJsonValue &value, type< std::vector <SanitationInjuryKind > >)
{
  std::vector < SanitationInjuryKind > 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<SanitationInjuryKind>{}));
  return ret;
}




// SanitationInjuryPlace1
QJsonObject toJson(const SanitationInjuryPlace1 &element)
{
  QJsonObject obj;
  obj[QStringLiteral("version")] = QString::fromStdString(element.version);
  return obj;
}

template<>
SanitationInjuryPlace1 fromJson(const QJsonValue &value, type<SanitationInjuryPlace1>)
{
  const QJsonObject objElement(value.toObject());
  SanitationInjuryPlace1 element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("version"))); element.version = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <SanitationInjuryPlace1 > &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<SanitationInjuryPlace1> fromJson(const QJsonValue &value, type< std::vector <SanitationInjuryPlace1 > >)
{
  std::vector < SanitationInjuryPlace1 > 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<SanitationInjuryPlace1>{}));
  return ret;
}




// SanitationInjuryPlace2
QJsonObject toJson(const SanitationInjuryPlace2 &element)
{
  QJsonObject obj;
  obj[QStringLiteral("version")] = QString::fromStdString(element.version);
  return obj;
}

template<>
SanitationInjuryPlace2 fromJson(const QJsonValue &value, type<SanitationInjuryPlace2>)
{
  const QJsonObject objElement(value.toObject());
  SanitationInjuryPlace2 element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("version"))); element.version = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <SanitationInjuryPlace2 > &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<SanitationInjuryPlace2> fromJson(const QJsonValue &value, type< std::vector <SanitationInjuryPlace2 > >)
{
  std::vector < SanitationInjuryPlace2 > 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<SanitationInjuryPlace2>{}));
  return ret;
}




// SanitationMaterial
QJsonObject toJson(const SanitationMaterial &element)
{
  QJsonObject obj;
  obj[QStringLiteral("description")] = QString::fromStdString(element.description);
  obj[QStringLiteral("version")] = QString::fromStdString(element.version);
  return obj;
}

template<>
SanitationMaterial fromJson(const QJsonValue &value, type<SanitationMaterial>)
{
  const QJsonObject objElement(value.toObject());
  SanitationMaterial element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("description"))); element.description = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("version"))); element.version = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <SanitationMaterial > &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<SanitationMaterial> fromJson(const QJsonValue &value, type< std::vector <SanitationMaterial > >)
{
  std::vector < SanitationMaterial > 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<SanitationMaterial>{}));
  return ret;
}




// SanitationProcedure
QJsonObject toJson(const SanitationProcedure &element)
{
  QJsonObject obj;
  obj[QStringLiteral("type")] = QString::fromStdString(element.type);
  obj[QStringLiteral("pdm_typeId")] = element.pdm_typeId;
  obj[QStringLiteral("minimumQualification")] = element.minimumQualification;
  obj[QStringLiteral("longName")] = QString::fromStdString(element.longName);
  obj[QStringLiteral("dataCode")] = static_cast<qint64>(element.dataCode);
  obj[QStringLiteral("version")] = QString::fromStdString(element.version);
  return obj;
}

template<>
SanitationProcedure fromJson(const QJsonValue &value, type<SanitationProcedure>)
{
  const QJsonObject objElement(value.toObject());
  SanitationProcedure element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("type"))); element.type = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("pdm_typeId"))); element.pdm_typeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("minimumQualification"))); element.minimumQualification = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("longName"))); element.longName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("dataCode"))); element.dataCode = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("version"))); element.version = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <SanitationProcedure > &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<SanitationProcedure> fromJson(const QJsonValue &value, type< std::vector <SanitationProcedure > >)
{
  std::vector < SanitationProcedure > 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<SanitationProcedure>{}));
  return ret;
}




// TargetSubType
QJsonObject toJson(const TargetSubType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("abbreviation")] = QString::fromStdString(element.abbreviation);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
TargetSubType fromJson(const QJsonValue &value, type<TargetSubType>)
{
  const QJsonObject objElement(value.toObject());
  TargetSubType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("abbreviation"))); element.abbreviation = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <TargetSubType > &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<TargetSubType> fromJson(const QJsonValue &value, type< std::vector <TargetSubType > >)
{
  std::vector < TargetSubType > 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<TargetSubType>{}));
  return ret;
}




// TargetType
QJsonObject toJson(const TargetType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("abbreviation")] = QString::fromStdString(element.abbreviation);
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
TargetType fromJson(const QJsonValue &value, type<TargetType>)
{
  const QJsonObject objElement(value.toObject());
  TargetType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("abbreviation"))); element.abbreviation = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <TargetType > &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<TargetType> fromJson(const QJsonValue &value, type< std::vector <TargetType > >)
{
  std::vector < TargetType > 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<TargetType>{}));
  return ret;
}




// TargetTypeTargetSubType
QJsonObject toJson(const TargetTypeTargetSubType &element)
{
  QJsonObject obj;
  obj[QStringLiteral("targetTypeId")] = element.targetTypeId;
  obj[QStringLiteral("targetSubTypeId")] = element.targetSubTypeId;
  obj[QStringLiteral("properties")] = QString::fromStdString(element.properties);
  return obj;
}

template<>
TargetTypeTargetSubType fromJson(const QJsonValue &value, type<TargetTypeTargetSubType>)
{
  const QJsonObject objElement(value.toObject());
  TargetTypeTargetSubType element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("targetTypeId"))); element.targetTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("targetSubTypeId"))); element.targetSubTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("properties"))); element.properties = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <TargetTypeTargetSubType > &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<TargetTypeTargetSubType> fromJson(const QJsonValue &value, type< std::vector <TargetTypeTargetSubType > >)
{
  std::vector < TargetTypeTargetSubType > 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<TargetTypeTargetSubType>{}));
  return ret;
}




// TranslationBlob
QJsonObject toJson(const TranslationBlob &element)
{
  QJsonObject obj;
  obj[QStringLiteral("payload")] = toJson(element.payload);
  obj[QStringLiteral("md5sum")] = QString::fromStdString(element.md5sum);
  return obj;
}

template<>
TranslationBlob fromJson(const QJsonValue &value, type<TranslationBlob>)
{
  const QJsonObject objElement(value.toObject());
  TranslationBlob element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("payload"))); element.payload = fromJson<std::vector<uint8_t>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("md5sum"))); element.md5sum = fromJson<std::string>(val); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <TranslationBlob > &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<TranslationBlob> fromJson(const QJsonValue &value, type< std::vector <TranslationBlob > >)
{
  std::vector < TranslationBlob > 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<TranslationBlob>{}));
  return ret;
}




// VulnerabilityKind
QJsonObject toJson(const VulnerabilityKind &element)
{
  QJsonObject obj;
  obj[QStringLiteral("playerTypeClassId")] = element.playerTypeClassId;
  obj[QStringLiteral("taVulnerabilityKind")] = element.taVulnerabilityKind;
  obj[QStringLiteral("vulnerabilityClassId")] = toJson(static_cast<int>(element.vulnerabilityClassId));
  return obj;
}

template<>
VulnerabilityKind fromJson(const QJsonValue &value, type<VulnerabilityKind>)
{
  const QJsonObject objElement(value.toObject());
  VulnerabilityKind element;

  
  { const QJsonValue val(objElement.value(QStringLiteral("playerTypeClassId"))); element.playerTypeClassId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("taVulnerabilityKind"))); element.taVulnerabilityKind = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityClassId"))); element.vulnerabilityClassId = static_cast<ProjectDataManagement::VulnerabilityClass>(val.toInt()); } 

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <VulnerabilityKind > &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<VulnerabilityKind> fromJson(const QJsonValue &value, type< std::vector <VulnerabilityKind > >)
{
  std::vector < VulnerabilityKind > 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<VulnerabilityKind>{}));
  return ret;
}





} // namespace ProjectDataManagement