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


// filename: tab_json.cpp

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

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


// BatteryAlarm
QJsonObject toJson(const BatteryAlarm &element)
{
  QJsonObject obj;
  obj[QStringLiteral("batteryPort")] = element.batteryPort;
  obj[QStringLiteral("description")] = QString::fromStdString(element.description);
  obj[QStringLiteral("acknowledge")] = element.acknowledge;
  obj[QStringLiteral("condition")] = element.condition;
  obj[QStringLiteral("uniqueAlarmNumber")] = element.uniqueAlarmNumber;
  obj[QStringLiteral("alarmTime")] = static_cast<qint64>(element.alarmTime);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("batteryPort"))); element.batteryPort = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("description"))); element.description = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("acknowledge"))); element.acknowledge = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("condition"))); element.condition = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("uniqueAlarmNumber"))); element.uniqueAlarmNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("alarmTime"))); element.alarmTime = val.toDouble(); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("batteryStates"))); element.batteryStates = fromJson<std::vector<TrainingAreaBase::BatteryState>>(val); } 

  return element;
}

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

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




// BatteryState
QJsonObject toJson(const BatteryState &element)
{
  QJsonObject obj;
  obj[QStringLiteral("batteryPort")] = element.batteryPort;
  obj[QStringLiteral("batteryPercent")] = element.batteryPercent;
  obj[QStringLiteral("temperature")] = element.temperature;
  obj[QStringLiteral("frequency")] = element.frequency;
  obj[QStringLiteral("generic")] = element.generic;
  obj[QStringLiteral("current")] = element.current;
  obj[QStringLiteral("switchOrValue")] = element.switchOrValue;
  obj[QStringLiteral("voltage")] = element.voltage;
  obj[QStringLiteral("serialNumber")] = QString::fromStdString(element.serialNumber);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("batteryPort"))); element.batteryPort = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("batteryPercent"))); element.batteryPercent = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("temperature"))); element.temperature = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("frequency"))); element.frequency = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("generic"))); element.generic = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("current"))); element.current = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("switchOrValue"))); element.switchOrValue = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("voltage"))); element.voltage = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("serialNumber"))); element.serialNumber = fromJson<std::string>(val); } 

  return element;
}

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

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




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

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

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

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("id"))); element.id = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("connections"))); element.connections = fromJson<std::vector<TrainingAreaBase::ConnectionState>>(val); } 

  return element;
}

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

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




// Core::GeoPosition
QJsonObject toJson(const Core::GeoPosition &element)
{
  QJsonObject obj;
  obj[QStringLiteral("z")] = element.z;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("z"))); element.z = val.toDouble(); } 

  return element;
}

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

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




// Core::GeoPosition2D
QJsonObject toJson(const Core::GeoPosition2D &element)
{
  QJsonObject obj;
  obj[QStringLiteral("lon")] = element.lon;
  obj[QStringLiteral("lat")] = element.lat;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("lon"))); element.lon = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("lat"))); element.lat = val.toDouble(); } 

  return element;
}

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

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




// Core::GeoPositionRelativeTime
QJsonObject toJson(const Core::GeoPositionRelativeTime &element)
{
  QJsonObject obj;
  obj[QStringLiteral("relativeTime")] = static_cast<qint64>(element.relativeTime);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("relativeTime"))); element.relativeTime = val.toDouble(); } 

  return element;
}

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

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




// Core::Orientation
QJsonObject toJson(const Core::Orientation &element)
{
  QJsonObject obj;
  obj[QStringLiteral("heave")] = element.heave;
  obj[QStringLiteral("pitch")] = element.pitch;
  obj[QStringLiteral("roll")] = element.roll;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("heave"))); element.heave = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("pitch"))); element.pitch = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("roll"))); element.roll = val.toDouble(); } 

  return element;
}

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

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




// Core::RelativePosition
QJsonObject toJson(const Core::RelativePosition &element)
{
  QJsonObject obj;
  obj[QStringLiteral("offsetX")] = element.offsetX;
  obj[QStringLiteral("offsetY")] = element.offsetY;
  obj[QStringLiteral("offsetZ")] = element.offsetZ;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("offsetX"))); element.offsetX = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("offsetY"))); element.offsetY = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("offsetZ"))); element.offsetZ = val.toDouble(); } 

  return element;
}

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

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




// CtaDataError
QJsonObject toJson(const CtaDataError &element)
{
  QJsonObject obj;
  obj[QStringLiteral("reason")] = toJson(static_cast<int>(element.reason));
  obj[QStringLiteral("originTelegramId")] = element.originTelegramId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("reason"))); element.reason = static_cast<ProjectDataManagement::DataErrorReason>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("originTelegramId"))); element.originTelegramId = val.toInt(); } 

  return element;
}

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

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




// DefinitionIed
QJsonObject toJson(const DefinitionIed &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("type")] = element.type;
  obj[QStringLiteral("remoteTrigger")] = element.remoteTrigger;
  obj[QStringLiteral("switchTrigger")] = element.switchTrigger;
  obj[QStringLiteral("lightBarrierTrigger")] = element.lightBarrierTrigger;
  obj[QStringLiteral("tautWireTrigger")] = element.tautWireTrigger;
  obj[QStringLiteral("explosiveForce")] = element.explosiveForce;
  obj[QStringLiteral("partyId")] = element.partyId;
  obj[QStringLiteral("pairingState")] = element.pairingState;
  if (element.pairedId.is_set()) obj[QStringLiteral("pairedId")] = *element.pairedId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("type"))); element.type = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("remoteTrigger"))); element.remoteTrigger = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("switchTrigger"))); element.switchTrigger = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("lightBarrierTrigger"))); element.lightBarrierTrigger = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("tautWireTrigger"))); element.tautWireTrigger = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("explosiveForce"))); element.explosiveForce = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("partyId"))); element.partyId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("pairingState"))); element.pairingState = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("pairedId"))); if (!val.isNull()) element.pairedId = val.toInt(); } 

  return element;
}

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

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




// Dispersion
QJsonObject toJson(const Dispersion &element)
{
  QJsonObject obj;
  obj[QStringLiteral("longitudinal")] = element.longitudinal;
  obj[QStringLiteral("lateral")] = element.lateral;
  obj[QStringLiteral("longitudinalH")] = element.longitudinalH;
  obj[QStringLiteral("lateralH")] = element.lateralH;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("longitudinal"))); element.longitudinal = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("lateral"))); element.lateral = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("longitudinalH"))); element.longitudinalH = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("lateralH"))); element.lateralH = val.toDouble(); } 

  return element;
}

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

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




// DusSingleMineState
QJsonObject toJson(const DusSingleMineState &element)
{
  QJsonObject obj;
  obj[QStringLiteral("mineId")] = element.mineId;
  obj[QStringLiteral("effectStart")] = static_cast<qint64>(element.effectStart);
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("state")] = element.state;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("mineId"))); element.mineId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectStart"))); element.effectStart = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("state"))); element.state = val.toBool(); } 

  return element;
}

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

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




// EX_CeaseFiring
QJsonObject toJson(const EX_CeaseFiring &element)
{
  QJsonObject obj;
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("effectorId")] = toJson(static_cast<int>(element.effectorId));
  obj[QStringLiteral("category")] = toJson(static_cast<int>(element.category));
  obj[QStringLiteral("reference")] = QString::fromStdString(element.reference);
  obj[QStringLiteral("targetPosNumber")] = element.targetPosNumber;
  obj[QStringLiteral("coordinate")] = toJson(element.coordinate);
  obj[QStringLiteral("radius")] = element.radius;
  obj[QStringLiteral("unloadRound")] = element.unloadRound;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectorId"))); element.effectorId = static_cast<ProjectDataManagement::L27_EffectorId>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("category"))); element.category = static_cast<ProjectDataManagement::L22_FireHaltCategory>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reference"))); element.reference = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("targetPosNumber"))); element.targetPosNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinate"))); element.coordinate = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radius"))); element.radius = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("unloadRound"))); element.unloadRound = val.toInt(); } 

  return element;
}

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

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




// EX_DoNotFire
QJsonObject toJson(const EX_DoNotFire &element)
{
  QJsonObject obj;
  obj[QStringLiteral("reference")] = QString::fromStdString(element.reference);
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("effectorId")] = toJson(static_cast<int>(element.effectorId));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("reference"))); element.reference = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectorId"))); element.effectorId = static_cast<ProjectDataManagement::L27_EffectorId>(val.toInt()); } 

  return element;
}

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

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




// EX_ExplorationResult
QJsonObject toJson(const EX_ExplorationResult &element)
{
  QJsonObject obj;
  obj[QStringLiteral("reconnaissanceUnit")] = toJson(element.reconnaissanceUnit);
  obj[QStringLiteral("loadingArea")] = toJson(element.loadingArea);
  obj[QStringLiteral("positions")] = toJson(element.positions);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("reconnaissanceUnit"))); element.reconnaissanceUnit = fromJson<TrainingAreaBase::L29_ReconnaissanceUnit>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loadingArea"))); element.loadingArea = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("positions"))); element.positions = fromJson<std::vector<TrainingAreaBase::L30_reconnaissancePositionArea>>(val); } 

  return element;
}

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

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




// EX_Fire
QJsonObject toJson(const EX_Fire &element)
{
  QJsonObject obj;
  obj[QStringLiteral("reference")] = QString::fromStdString(element.reference);
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("effectorId")] = toJson(static_cast<int>(element.effectorId));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("reference"))); element.reference = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectorId"))); element.effectorId = static_cast<ProjectDataManagement::L27_EffectorId>(val.toInt()); } 

  return element;
}

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

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




// EX_GuidingLines
QJsonObject toJson(const EX_GuidingLines &element)
{
  QJsonObject obj;
  obj[QStringLiteral("kindGuidingLine")] = toJson(static_cast<int>(element.kindGuidingLine));
  obj[QStringLiteral("name")] = QString::fromStdString(element.name);
  obj[QStringLiteral("reportNumber")] = element.reportNumber;
  obj[QStringLiteral("partOfTroup")] = toJson(element.partOfTroup);
  obj[QStringLiteral("startTime")] = element.startTime;
  obj[QStringLiteral("endTime")] = element.endTime;
  obj[QStringLiteral("coordinates")] = toJson(element.coordinates);
  obj[QStringLiteral("center")] = toJson(element.center);
  obj[QStringLiteral("radius")] = element.radius;
  obj[QStringLiteral("height")] = element.height;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("kindGuidingLine"))); element.kindGuidingLine = static_cast<ProjectDataManagement::L25_KindGuidingLine>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("name"))); element.name = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reportNumber"))); element.reportNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("partOfTroup"))); element.partOfTroup = fromJson<TrainingAreaBase::L31_MailAddress>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("startTime"))); element.startTime = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("endTime"))); element.endTime = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinates"))); element.coordinates = fromJson<std::vector<Core::GeoPosition2D>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("center"))); element.center = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radius"))); element.radius = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("height"))); element.height = val.toInt(); } 

  return element;
}

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

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




// EX_GuidingLinesAndBoundaries
QJsonObject toJson(const EX_GuidingLinesAndBoundaries &element)
{
  QJsonObject obj;
  obj[QStringLiteral("kind")] = toJson(static_cast<int>(element.kind));
  obj[QStringLiteral("name")] = QString::fromStdString(element.name);
  obj[QStringLiteral("reportNumber")] = element.reportNumber;
  obj[QStringLiteral("partOfTroup")] = toJson(element.partOfTroup);
  obj[QStringLiteral("startTinme")] = element.startTinme;
  obj[QStringLiteral("endTinme")] = element.endTinme;
  obj[QStringLiteral("coordinates")] = toJson(element.coordinates);
  obj[QStringLiteral("center")] = toJson(element.center);
  obj[QStringLiteral("radius")] = element.radius;
  obj[QStringLiteral("maxHeight")] = element.maxHeight;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("kind"))); element.kind = static_cast<ProjectDataManagement::L25_KindGuidingLine>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("name"))); element.name = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reportNumber"))); element.reportNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("partOfTroup"))); element.partOfTroup = fromJson<TrainingAreaBase::L31_MailAddress>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("startTinme"))); element.startTinme = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("endTinme"))); element.endTinme = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinates"))); element.coordinates = fromJson<std::vector<Core::GeoPosition2D>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("center"))); element.center = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radius"))); element.radius = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("maxHeight"))); element.maxHeight = val.toInt(); } 

  return element;
}

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

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




// EX_MessageRevocation
QJsonObject toJson(const EX_MessageRevocation &element)
{
  QJsonObject obj;
  obj[QStringLiteral("messageSource")] = toJson(element.messageSource);
  obj[QStringLiteral("messageIdentifier")] = element.messageIdentifier;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("messageSource"))); element.messageSource = fromJson<TrainingAreaBase::L31_MailAddress>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("messageIdentifier"))); element.messageIdentifier = val.toInt(); } 

  return element;
}

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

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




// EX_ReportEffectorUnit
QJsonObject toJson(const EX_ReportEffectorUnit &element)
{
  QJsonObject obj;
  obj[QStringLiteral("effectingSystemType")] = toJson(static_cast<int>(element.effectingSystemType));
  obj[QStringLiteral("status")] = toJson(static_cast<int>(element.status));
  obj[QStringLiteral("unit")] = toJson(element.unit);
  obj[QStringLiteral("center")] = toJson(element.center);
  obj[QStringLiteral("coordinates")] = toJson(element.coordinates);
  obj[QStringLiteral("charges")] = toJson(element.charges);
  obj[QStringLiteral("effectableArea")] = toJson(element.effectableArea);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("effectingSystemType"))); element.effectingSystemType = static_cast<ProjectDataManagement::L26_EffectingSystemType>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("status"))); element.status = static_cast<ProjectDataManagement::L28_Status>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("unit"))); element.unit = fromJson<TrainingAreaBase::L3_Unit>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("center"))); element.center = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinates"))); element.coordinates = fromJson<std::vector<Core::GeoPosition>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("charges"))); element.charges = fromJson<TrainingAreaBase::L8_Charges>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectableArea"))); element.effectableArea = fromJson<TrainingAreaBase::L18_EffectableArea>(val); } 

  return element;
}

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

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




// EX_StartFiring
QJsonObject toJson(const EX_StartFiring &element)
{
  QJsonObject obj;
  obj[QStringLiteral("reference")] = QString::fromStdString(element.reference);
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("effectorId")] = toJson(static_cast<int>(element.effectorId));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("reference"))); element.reference = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectorId"))); element.effectorId = static_cast<ProjectDataManagement::L27_EffectorId>(val.toInt()); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 

  return element;
}

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

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




// Equipment
QJsonObject toJson(const Equipment &element)
{
  QJsonObject obj;
  obj[QStringLiteral("equipmentFunctionId")] = element.equipmentFunctionId;
  obj[QStringLiteral("subDeviceId")] = element.subDeviceId;
  obj[QStringLiteral("unqiueId")] = element.unqiueId;
  return obj;
}

template<>
Equipment fromJson(const QJsonValue &value, type<Equipment>)
{
  const QJsonObject objElement(value.toObject());
  Equipment 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("unqiueId"))); element.unqiueId = val.toInt(); } 

  return element;
}

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

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




// EquipmentBase
QJsonObject toJson(const EquipmentBase &element)
{
  QJsonObject obj;
  obj[QStringLiteral("equipmentNumber")] = element.equipmentNumber;
  obj[QStringLiteral("sampleTime")] = static_cast<qint64>(element.sampleTime);
  return obj;
}

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

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

  return element;
}

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

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




// EquipmentBite
QJsonObject toJson(const EquipmentBite &element)
{
  QJsonObject obj;
  obj[QStringLiteral("registerType")] = element.registerType;
  obj[QStringLiteral("biteState")] = element.biteState;
  obj[QStringLiteral("configState")] = element.configState;
  obj[QStringLiteral("batteryState")] = element.batteryState;
  obj[QStringLiteral("configError")] = element.configError;
  obj[QStringLiteral("biteErrors")] = toJson(element.biteErrors);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("registerType"))); element.registerType = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("biteState"))); element.biteState = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("configState"))); element.configState = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("batteryState"))); element.batteryState = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("configError"))); element.configError = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("biteErrors"))); element.biteErrors = fromJson<std::vector<TrainingAreaBase::EquipmentBiteError>>(val); } 

  return element;
}

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

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




// EquipmentBiteError
QJsonObject toJson(const EquipmentBiteError &element)
{
  QJsonObject obj;
  obj[QStringLiteral("errorNumber")] = element.errorNumber;
  obj[QStringLiteral("canDeviceNumber")] = element.canDeviceNumber;
  obj[QStringLiteral("subdeviceNumber")] = element.subdeviceNumber;
  obj[QStringLiteral("uniqueId")] = element.uniqueId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("errorNumber"))); element.errorNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("canDeviceNumber"))); element.canDeviceNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("subdeviceNumber"))); element.subdeviceNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("uniqueId"))); element.uniqueId = val.toInt(); } 

  return element;
}

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

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




// EquipmentConfigurationReport
QJsonObject toJson(const EquipmentConfigurationReport &element)
{
  QJsonObject obj;
  obj[QStringLiteral("canStartupTime")] = element.canStartupTime;
  obj[QStringLiteral("equipmentType")] = element.equipmentType;
  obj[QStringLiteral("loginWaittimeBitweenTrys")] = element.loginWaittimeBitweenTrys;
  obj[QStringLiteral("loginMaxRetryCount")] = element.loginMaxRetryCount;
  obj[QStringLiteral("loginMasteringFlag")] = element.loginMasteringFlag;
  obj[QStringLiteral("canDeviceConfiguration")] = element.canDeviceConfiguration;
  obj[QStringLiteral("displayDeviceVoiceOutput")] = element.displayDeviceVoiceOutput;
  obj[QStringLiteral("displayDeviceLanguage")] = toJson(static_cast<int>(element.displayDeviceLanguage));
  obj[QStringLiteral("pyrotechnics")] = element.pyrotechnics;
  obj[QStringLiteral("mineHandgrenadeSensorMode")] = toJson(static_cast<int>(element.mineHandgrenadeSensorMode));
  obj[QStringLiteral("mineHandgrenadeSensorEnergySaving")] = element.mineHandgrenadeSensorEnergySaving;
  obj[QStringLiteral("firMode")] = toJson(static_cast<int>(element.firMode));
  obj[QStringLiteral("minelayerMode")] = toJson(static_cast<int>(element.minelayerMode));
  obj[QStringLiteral("specialSensorStandard")] = toJson(static_cast<int>(element.specialSensorStandard));
  obj[QStringLiteral("agdusHwMode")] = toJson(static_cast<int>(element.agdusHwMode));
  obj[QStringLiteral("positionUpdateIntervall")] = toJson(static_cast<int>(element.positionUpdateIntervall));
  obj[QStringLiteral("displayTextMainGroup")] = element.displayTextMainGroup;
  obj[QStringLiteral("displayTextSubGroup")] = element.displayTextSubGroup;
  obj[QStringLiteral("vulnerabilityModelAgdus")] = element.vulnerabilityModelAgdus;
  obj[QStringLiteral("vulnerabilityModelMineIed")] = element.vulnerabilityModelMineIed;
  obj[QStringLiteral("vulnerabilityModelAreaFire")] = element.vulnerabilityModelAreaFire;
  obj[QStringLiteral("vulnerabilityModelOperatingResource")] = element.vulnerabilityModelOperatingResource;
  obj[QStringLiteral("vulnerabilityModelACWeaponry")] = element.vulnerabilityModelACWeaponry;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("canStartupTime"))); element.canStartupTime = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("equipmentType"))); element.equipmentType = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loginWaittimeBitweenTrys"))); element.loginWaittimeBitweenTrys = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loginMaxRetryCount"))); element.loginMaxRetryCount = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loginMasteringFlag"))); element.loginMasteringFlag = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("canDeviceConfiguration"))); element.canDeviceConfiguration = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("displayDeviceVoiceOutput"))); element.displayDeviceVoiceOutput = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("displayDeviceLanguage"))); element.displayDeviceLanguage = static_cast<ProjectDataManagement::LanguageConfiguration>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("pyrotechnics"))); element.pyrotechnics = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mineHandgrenadeSensorMode"))); element.mineHandgrenadeSensorMode = static_cast<TrainingAreaBase::MineHandgrenadeSensorMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mineHandgrenadeSensorEnergySaving"))); element.mineHandgrenadeSensorEnergySaving = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("firMode"))); element.firMode = static_cast<TrainingAreaBase::FirMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("minelayerMode"))); element.minelayerMode = static_cast<TrainingAreaBase::MinelayerMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("specialSensorStandard"))); element.specialSensorStandard = static_cast<TrainingAreaBase::SpecialSensorStandardMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("agdusHwMode"))); element.agdusHwMode = static_cast<TrainingAreaBase::AgdusHwMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("positionUpdateIntervall"))); element.positionUpdateIntervall = static_cast<TrainingAreaBase::PositionUpdateIntervall>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("displayTextMainGroup"))); element.displayTextMainGroup = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("displayTextSubGroup"))); element.displayTextSubGroup = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityModelAgdus"))); element.vulnerabilityModelAgdus = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityModelMineIed"))); element.vulnerabilityModelMineIed = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityModelAreaFire"))); element.vulnerabilityModelAreaFire = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityModelOperatingResource"))); element.vulnerabilityModelOperatingResource = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityModelACWeaponry"))); element.vulnerabilityModelACWeaponry = val.toInt(); } 

  return element;
}

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

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




// EquipmentEvent
QJsonObject toJson(const EquipmentEvent &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("source")] = toJson(element.source);
  obj[QStringLiteral("code")] = element.code;
  if (element.data.is_set()) obj[QStringLiteral("data")] = toJson(*element.data);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("source"))); element.source = fromJson<TrainingAreaBase::Equipment>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("code"))); element.code = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("data"))); if (!val.isNull()) element.data = fromJson<std::vector<uint8_t>>(val); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("gears"))); element.gears = fromJson<std::vector<TrainingAreaBase::Gear>>(val); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("charge"))); element.charge = fromJson<std::vector<TrainingAreaBase::GearCharge>>(val); } 

  return element;
}

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

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




// EquipmentGearEvent
QJsonObject toJson(const EquipmentGearEvent &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeAmount")] = element.chargeAmount;
  obj[QStringLiteral("charge")] = toJson(element.charge);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeAmount"))); element.chargeAmount = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("charge"))); element.charge = fromJson<TrainingAreaBase::GearCharge>(val); } 

  return element;
}

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

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




// EquipmentMessage
QJsonObject toJson(const EquipmentMessage &element)
{
  QJsonObject obj;
  obj[QStringLiteral("subject")] = QString::fromStdString(element.subject);
  obj[QStringLiteral("text")] = QString::fromStdString(element.text);
  obj[QStringLiteral("sender")] = element.sender;
  obj[QStringLiteral("receiver")] = element.receiver;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("subject"))); element.subject = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("text"))); element.text = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("sender"))); element.sender = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("receiver"))); element.receiver = val.toInt(); } 

  return element;
}

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

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




// EquipmentOperationalState
QJsonObject toJson(const EquipmentOperationalState &element)
{
  QJsonObject obj;
  if (element.isManipulation.is_set()) obj[QStringLiteral("isManipulation")] = *element.isManipulation;
  if (element.equipmentFunctionId.is_set()) obj[QStringLiteral("equipmentFunctionId")] = *element.equipmentFunctionId;
  if (element.nbcProtectionActive.is_set()) obj[QStringLiteral("nbcProtectionActive")] = *element.nbcProtectionActive;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("isManipulation"))); if (!val.isNull()) element.isManipulation = val.toBool(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("equipmentFunctionId"))); if (!val.isNull()) element.equipmentFunctionId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("nbcProtectionActive"))); if (!val.isNull()) element.nbcProtectionActive = val.toBool(); } 

  return element;
}

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

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




// EquipmentPosition
QJsonObject toJson(const EquipmentPosition &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  if (element.mountedParticipants.is_set()) obj[QStringLiteral("mountedParticipants")] = toJson(*element.mountedParticipants);
  if (element.orientation.is_set()) obj[QStringLiteral("orientation")] = toJson(*element.orientation);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<TrainingAreaBase::TabPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mountedParticipants"))); if (!val.isNull()) element.mountedParticipants = fromJson<std::vector<int32_t>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("orientation"))); if (!val.isNull()) element.orientation = fromJson<Core::Orientation>(val); } 

  return element;
}

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

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




// EquipmentState
QJsonObject toJson(const EquipmentState &element)
{
  QJsonObject obj;
  obj[QStringLiteral("vulnerabilityState")] = toJson(static_cast<int>(element.vulnerabilityState));
  obj[QStringLiteral("vulnerabilityKindId")] = element.vulnerabilityKindId;
  obj[QStringLiteral("vitality")] = element.vitality;
  obj[QStringLiteral("vulnerabilityBits")] = element.vulnerabilityBits;
  if (element.position.is_set()) obj[QStringLiteral("position")] = toJson(*element.position);
  obj[QStringLiteral("originatorId")] = element.originatorId;
  obj[QStringLiteral("originatorType")] = toJson(static_cast<int>(element.originatorType));
  obj[QStringLiteral("originatorChargeTypeId")] = element.originatorChargeTypeId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityState"))); element.vulnerabilityState = static_cast<ProjectDataManagement::VulnerabilityState>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityKindId"))); element.vulnerabilityKindId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vitality"))); element.vitality = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityBits"))); element.vulnerabilityBits = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); if (!val.isNull()) element.position = fromJson<TrainingAreaBase::TabPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("originatorId"))); element.originatorId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("originatorType"))); element.originatorType = static_cast<ProjectDataManagement::StateChangeOriginator>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("originatorChargeTypeId"))); element.originatorChargeTypeId = val.toInt(); } 

  return element;
}

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

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




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

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

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

  return element;
}

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

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




// ExAwesPlanning
QJsonObject toJson(const ExAwesPlanning &element)
{
  QJsonObject obj;
  obj[QStringLiteral("reference")] = QString::fromStdString(element.reference);
  obj[QStringLiteral("targetData")] = toJson(element.targetData);
  obj[QStringLiteral("firingType")] = element.firingType;
  obj[QStringLiteral("request")] = QString::fromStdString(element.request);
  obj[QStringLiteral("duration")] = element.duration;
  obj[QStringLiteral("fireCommand")] = toJson(element.fireCommand);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("reference"))); element.reference = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("targetData"))); element.targetData = fromJson<TrainingAreaBase::L12_TargetData>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("firingType"))); element.firingType = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("request"))); element.request = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("duration"))); element.duration = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("fireCommand"))); element.fireCommand = fromJson<TrainingAreaBase::L33_FireCommand>(val); } 

  return element;
}

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

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




// ExReportEffector
QJsonObject toJson(const ExReportEffector &element)
{
  QJsonObject obj;
  obj[QStringLiteral("effectingSystemType")] = toJson(static_cast<int>(element.effectingSystemType));
  obj[QStringLiteral("effectorId")] = toJson(static_cast<int>(element.effectorId));
  obj[QStringLiteral("status")] = toJson(static_cast<int>(element.status));
  obj[QStringLiteral("effectorUnit")] = toJson(element.effectorUnit);
  obj[QStringLiteral("charges")] = toJson(element.charges);
  obj[QStringLiteral("coordinate")] = toJson(element.coordinate);
  obj[QStringLiteral("effectableArea")] = toJson(element.effectableArea);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("effectingSystemType"))); element.effectingSystemType = static_cast<ProjectDataManagement::L26_EffectingSystemType>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectorId"))); element.effectorId = static_cast<ProjectDataManagement::L27_EffectorId>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("status"))); element.status = static_cast<ProjectDataManagement::L28_Status>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectorUnit"))); element.effectorUnit = fromJson<TrainingAreaBase::L13_EffectorUnit>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("charges"))); element.charges = fromJson<std::vector<TrainingAreaBase::L8_Charges>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinate"))); element.coordinate = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectableArea"))); element.effectableArea = fromJson<TrainingAreaBase::L18_EffectableArea>(val); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("explorationResult"))); element.explorationResult = fromJson<std::vector<TrainingAreaBase::EX_ExplorationResult>>(val); } 

  return element;
}

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

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




// Ex_ReportSupplyZone
QJsonObject toJson(const Ex_ReportSupplyZone &element)
{
  QJsonObject obj;
  obj[QStringLiteral("effectorUnit")] = toJson(element.effectorUnit);
  obj[QStringLiteral("coordinate")] = toJson(element.coordinate);
  obj[QStringLiteral("charges")] = toJson(element.charges);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("effectorUnit"))); element.effectorUnit = fromJson<TrainingAreaBase::L13_EffectorUnit>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinate"))); element.coordinate = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("charges"))); element.charges = fromJson<TrainingAreaBase::L8_Charges>(val); } 

  return element;
}

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

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




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

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

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

  return element;
}

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

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




// FunctionalAreaEntry
QJsonObject toJson(const FunctionalAreaEntry &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("aesItemId")] = element.aesItemId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("aesItemId"))); element.aesItemId = val.toInt(); } 

  return element;
}

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

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




// Gear
QJsonObject toJson(const Gear &element)
{
  QJsonObject obj;
  obj[QStringLiteral("gearId")] = element.gearId;
  obj[QStringLiteral("gearTypeId")] = element.gearTypeId;
  obj[QStringLiteral("chargeCounting")] = element.chargeCounting;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("gearId"))); element.gearId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("gearTypeId"))); element.gearTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeCounting"))); element.chargeCounting = val.toBool(); } 

  return element;
}

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

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




// GearCharge
QJsonObject toJson(const GearCharge &element)
{
  QJsonObject obj;
  obj[QStringLiteral("gearId")] = element.gearId;
  obj[QStringLiteral("gearTypeId")] = element.gearTypeId;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("remain")] = element.remain;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("gearId"))); element.gearId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("gearTypeId"))); element.gearTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("remain"))); element.remain = val.toInt(); } 

  return element;
}

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

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




// GeopairingData
QJsonObject toJson(const GeopairingData &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("payload")] = toJson(element.payload);
  return obj;
}

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

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

  return element;
}

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

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




// IedBaseData
QJsonObject toJson(const IedBaseData &element)
{
  QJsonObject obj;
  obj[QStringLiteral("iedId")] = element.iedId;
  obj[QStringLiteral("tacticalState")] = element.tacticalState;
  obj[QStringLiteral("statePyrotechnics")] = element.statePyrotechnics;
  return obj;
}

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

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

  return element;
}

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

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




// L12_TargetData
QJsonObject toJson(const L12_TargetData &element)
{
  QJsonObject obj;
  obj[QStringLiteral("number")] = element.number;
  obj[QStringLiteral("geometry")] = toJson(static_cast<int>(element.geometry));
  obj[QStringLiteral("coordinate")] = toJson(element.coordinate);
  obj[QStringLiteral("relativeCoordinate")] = toJson(element.relativeCoordinate);
  obj[QStringLiteral("radius")] = element.radius;
  obj[QStringLiteral("width")] = element.width;
  obj[QStringLiteral("length")] = element.length;
  obj[QStringLiteral("targetAxis")] = element.targetAxis;
  obj[QStringLiteral("zog")] = element.zog;
  obj[QStringLiteral("elements")] = element.elements;
  obj[QStringLiteral("tagetType")] = element.tagetType;
  obj[QStringLiteral("tagetSubtype")] = element.tagetSubtype;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("number"))); element.number = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("geometry"))); element.geometry = static_cast<ProjectDataManagement::L4_TargetGeometry>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("coordinate"))); element.coordinate = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("relativeCoordinate"))); element.relativeCoordinate = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("radius"))); element.radius = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("width"))); element.width = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("length"))); element.length = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("targetAxis"))); element.targetAxis = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("zog"))); element.zog = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("elements"))); element.elements = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("tagetType"))); element.tagetType = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("tagetSubtype"))); element.tagetSubtype = val.toInt(); } 

  return element;
}

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

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




// L13_EffectorUnit
QJsonObject toJson(const L13_EffectorUnit &element)
{
  QJsonObject obj;
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("r")] = element.r;
  obj[QStringLiteral("oi")] = toJson(static_cast<int>(element.oi));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("r"))); element.r = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("oi"))); element.oi = static_cast<ProjectDataManagement::L19_Oi>(val.toInt()); } 

  return element;
}

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

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




// L18_EffectableArea
QJsonObject toJson(const L18_EffectableArea &element)
{
  QJsonObject obj;
  obj[QStringLiteral("direction")] = element.direction;
  obj[QStringLiteral("left")] = element.left;
  obj[QStringLiteral("right")] = element.right;
  return obj;
}

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

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

  return element;
}

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

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




// L29_ReconnaissanceUnit
QJsonObject toJson(const L29_ReconnaissanceUnit &element)
{
  QJsonObject obj;
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("r")] = element.r;
  obj[QStringLiteral("oi")] = toJson(static_cast<int>(element.oi));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("r"))); element.r = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("oi"))); element.oi = static_cast<ProjectDataManagement::L19_Oi>(val.toInt()); } 

  return element;
}

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

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




// L30_reconnaissancePositionArea
QJsonObject toJson(const L30_reconnaissancePositionArea &element)
{
  QJsonObject obj;
  obj[QStringLiteral("direction")] = element.direction;
  obj[QStringLiteral("left")] = element.left;
  obj[QStringLiteral("right")] = element.right;
  return obj;
}

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

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

  return element;
}

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

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




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

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

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

  return element;
}

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

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




// L33_FireCommand
QJsonObject toJson(const L33_FireCommand &element)
{
  QJsonObject obj;
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("type")] = element.type;
  obj[QStringLiteral("L34_effector")] = toJson(element.L34_effector);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("type"))); element.type = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("L34_effector"))); element.L34_effector = fromJson<std::vector<TrainingAreaBase::L34_effector>>(val); } 

  return element;
}

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

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




// L34_effector
QJsonObject toJson(const L34_effector &element)
{
  QJsonObject obj;
  obj[QStringLiteral("effectorId")] = toJson(static_cast<int>(element.effectorId));
  obj[QStringLiteral("targetPos")] = toJson(element.targetPos);
  obj[QStringLiteral("flightTime")] = element.flightTime;
  obj[QStringLiteral("maxHeight")] = element.maxHeight;
  obj[QStringLiteral("direction")] = element.direction;
  obj[QStringLiteral("angleOfFall")] = element.angleOfFall;
  obj[QStringLiteral("firingCommandCharges")] = toJson(element.firingCommandCharges);
  obj[QStringLiteral("trajectory")] = toJson(element.trajectory);
  obj[QStringLiteral("scattering")] = toJson(element.scattering);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("effectorId"))); element.effectorId = static_cast<ProjectDataManagement::L27_EffectorId>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("targetPos"))); element.targetPos = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("flightTime"))); element.flightTime = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("maxHeight"))); element.maxHeight = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("direction"))); element.direction = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("angleOfFall"))); element.angleOfFall = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("firingCommandCharges"))); element.firingCommandCharges = fromJson<TrainingAreaBase::L36_FiringCommandCharges>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("trajectory"))); element.trajectory = fromJson<std::vector<TrainingAreaBase::L35_TrajectoryPoint>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("scattering"))); element.scattering = fromJson<TrainingAreaBase::L39_ScatteringData>(val); } 

  return element;
}

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

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




// L35_TrajectoryPoint
QJsonObject toJson(const L35_TrajectoryPoint &element)
{
  QJsonObject obj;
  obj[QStringLiteral("time")] = element.time;
  obj[QStringLiteral("relPos")] = toJson(element.relPos);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("time"))); element.time = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("relPos"))); element.relPos = fromJson<Core::RelativePosition>(val); } 

  return element;
}

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

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




// L36_FiringCommandCharges
QJsonObject toJson(const L36_FiringCommandCharges &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeType")] = element.chargeType;
  obj[QStringLiteral("loadTypeId")] = element.loadTypeId;
  obj[QStringLiteral("loadNumber")] = element.loadNumber;
  obj[QStringLiteral("igniterTypeId")] = element.igniterTypeId;
  obj[QStringLiteral("igniterFunctionId")] = element.igniterFunctionId;
  obj[QStringLiteral("igniterTime")] = element.igniterTime;
  obj[QStringLiteral("amount")] = element.amount;
  obj[QStringLiteral("interval")] = element.interval;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("chargeType"))); element.chargeType = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loadTypeId"))); element.loadTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loadNumber"))); element.loadNumber = 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("igniterTime"))); element.igniterTime = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("amount"))); element.amount = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("interval"))); element.interval = val.toDouble(); } 

  return element;
}

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

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




// L39_ScatteringData
QJsonObject toJson(const L39_ScatteringData &element)
{
  QJsonObject obj;
  obj[QStringLiteral("mphWidth")] = element.mphWidth;
  obj[QStringLiteral("mphLength")] = element.mphLength;
  obj[QStringLiteral("mphWidthDetonationHeight")] = element.mphWidthDetonationHeight;
  obj[QStringLiteral("mphLengthDetonationHeight")] = element.mphLengthDetonationHeight;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("mphWidth"))); element.mphWidth = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mphLength"))); element.mphLength = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mphWidthDetonationHeight"))); element.mphWidthDetonationHeight = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mphLengthDetonationHeight"))); element.mphLengthDetonationHeight = val.toDouble(); } 

  return element;
}

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

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




// L3_Unit
QJsonObject toJson(const L3_Unit &element)
{
  QJsonObject obj;
  obj[QStringLiteral("identifier")] = QString::fromStdString(element.identifier);
  obj[QStringLiteral("r")] = element.r;
  obj[QStringLiteral("oi")] = toJson(static_cast<int>(element.oi));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("identifier"))); element.identifier = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("r"))); element.r = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("oi"))); element.oi = static_cast<ProjectDataManagement::L19_Oi>(val.toInt()); } 

  return element;
}

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

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




// L8_Charges
QJsonObject toJson(const L8_Charges &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("loadTypeId")] = element.loadTypeId;
  obj[QStringLiteral("igniterTypeId")] = element.igniterTypeId;
  obj[QStringLiteral("count")] = element.count;
  return obj;
}

template<>
L8_Charges fromJson(const QJsonValue &value, type<L8_Charges>)
{
  const QJsonObject objElement(value.toObject());
  L8_Charges 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("igniterTypeId"))); element.igniterTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("count"))); element.count = val.toInt(); } 

  return element;
}

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

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




// LaserDesignation
QJsonObject toJson(const LaserDesignation &element)
{
  QJsonObject obj;
  obj[QStringLiteral("gearId")] = element.gearId;
  obj[QStringLiteral("code")] = element.code;
  obj[QStringLiteral("outputPower")] = element.outputPower;
  obj[QStringLiteral("spotLocation")] = toJson(element.spotLocation);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("gearId"))); element.gearId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("code"))); element.code = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("outputPower"))); element.outputPower = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("spotLocation"))); element.spotLocation = fromJson<Core::GeoPosition2D>(val); } 

  return element;
}

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

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




// MineTriggered
QJsonObject toJson(const MineTriggered &element)
{
  QJsonObject obj;
  obj[QStringLiteral("mineAreaId")] = element.mineAreaId;
  obj[QStringLiteral("mineIndex")] = element.mineIndex;
  if (element.position.is_set()) obj[QStringLiteral("position")] = toJson(*element.position);
  if (element.chargeTypeId.is_set()) obj[QStringLiteral("chargeTypeId")] = *element.chargeTypeId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("mineAreaId"))); element.mineAreaId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mineIndex"))); element.mineIndex = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); if (!val.isNull()) element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); if (!val.isNull()) element.chargeTypeId = val.toInt(); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("throwingType"))); element.throwingType = static_cast<TrainingAreaBase::ThrowingType>(val.toInt()); } 

  return element;
}

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

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




// MinelayerTrailerData
QJsonObject toJson(const MinelayerTrailerData &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("barrierId")] = element.barrierId;
  obj[QStringLiteral("layingDensity")] = element.layingDensity;
  obj[QStringLiteral("effectStart")] = static_cast<qint64>(element.effectStart);
  obj[QStringLiteral("effectDuration")] = element.effectDuration;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("mineCount")] = element.mineCount;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("barrierId"))); element.barrierId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("layingDensity"))); element.layingDensity = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectStart"))); element.effectStart = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("effectDuration"))); element.effectDuration = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("mineCount"))); element.mineCount = val.toInt(); } 

  return element;
}

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

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




// MinelayerTrailerPosition
QJsonObject toJson(const MinelayerTrailerPosition &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("dusSerialNo")] = element.dusSerialNo;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("chargeTypeId"))); element.chargeTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("dusSerialNo"))); element.dusSerialNo = val.toInt(); } 

  return element;
}

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

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




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

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

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

  return element;
}

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

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




// OperatorAction
QJsonObject toJson(const OperatorAction &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("operatorId")] = element.operatorId;
  obj[QStringLiteral("action")] = element.action;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("operatorId"))); element.operatorId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("action"))); element.action = val.toInt(); } 

  return element;
}

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

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




// ParticipantConfigurationReport
QJsonObject toJson(const ParticipantConfigurationReport &element)
{
  QJsonObject obj;
  obj[QStringLiteral("positionIntervallVehicle")] = element.positionIntervallVehicle;
  obj[QStringLiteral("positionIntervallPersonell")] = element.positionIntervallPersonell;
  obj[QStringLiteral("positionIntervallAircraft")] = element.positionIntervallAircraft;
  obj[QStringLiteral("positionTransmissionIntervall")] = element.positionTransmissionIntervall;
  obj[QStringLiteral("heightbarrier")] = element.heightbarrier;
  obj[QStringLiteral("faultPositionHandling")] = toJson(static_cast<int>(element.faultPositionHandling));
  obj[QStringLiteral("switchingPositionIntervall")] = toJson(static_cast<int>(element.switchingPositionIntervall));
  obj[QStringLiteral("waittimeAdditionalBroadcastRequest")] = element.waittimeAdditionalBroadcastRequest;
  obj[QStringLiteral("factorWaittimeIncreaseHighload")] = element.factorWaittimeIncreaseHighload;
  obj[QStringLiteral("waittimeAutomaticVulnerbilityIncreaseLevel1")] = element.waittimeAutomaticVulnerbilityIncreaseLevel1;
  obj[QStringLiteral("waittimeAutomaticVulnerbilityIncreaseLevel2")] = element.waittimeAutomaticVulnerbilityIncreaseLevel2;
  obj[QStringLiteral("waittimeAutomaticVulnerbilityIncreaseLevel3")] = element.waittimeAutomaticVulnerbilityIncreaseLevel3;
  obj[QStringLiteral("opticalCode")] = toJson(static_cast<int>(element.opticalCode));
  obj[QStringLiteral("vulnerabilityModel")] = element.vulnerabilityModel;
  obj[QStringLiteral("validTimeOps")] = element.validTimeOps;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("positionIntervallVehicle"))); element.positionIntervallVehicle = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("positionIntervallPersonell"))); element.positionIntervallPersonell = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("positionIntervallAircraft"))); element.positionIntervallAircraft = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("positionTransmissionIntervall"))); element.positionTransmissionIntervall = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("heightbarrier"))); element.heightbarrier = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("faultPositionHandling"))); element.faultPositionHandling = static_cast<TrainingAreaBase::FaultPositionHandling>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("switchingPositionIntervall"))); element.switchingPositionIntervall = static_cast<TrainingAreaBase::SwitichingPositionIntervall>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("waittimeAdditionalBroadcastRequest"))); element.waittimeAdditionalBroadcastRequest = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("factorWaittimeIncreaseHighload"))); element.factorWaittimeIncreaseHighload = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("waittimeAutomaticVulnerbilityIncreaseLevel1"))); element.waittimeAutomaticVulnerbilityIncreaseLevel1 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("waittimeAutomaticVulnerbilityIncreaseLevel2"))); element.waittimeAutomaticVulnerbilityIncreaseLevel2 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("waittimeAutomaticVulnerbilityIncreaseLevel3"))); element.waittimeAutomaticVulnerbilityIncreaseLevel3 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("opticalCode"))); element.opticalCode = static_cast<TrainingAreaBase::OpticalCode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("vulnerabilityModel"))); element.vulnerabilityModel = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("validTimeOps"))); element.validTimeOps = val.toInt(); } 

  return element;
}

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

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




// ParticipantModeReport
QJsonObject toJson(const ParticipantModeReport &element)
{
  QJsonObject obj;
  obj[QStringLiteral("language")] = toJson(static_cast<int>(element.language));
  obj[QStringLiteral("operationMode")] = toJson(static_cast<int>(element.operationMode));
  obj[QStringLiteral("reactivationDetoxication")] = element.reactivationDetoxication;
  obj[QStringLiteral("reactivationMaintenance")] = element.reactivationMaintenance;
  obj[QStringLiteral("reactivationMedic")] = element.reactivationMedic;
  obj[QStringLiteral("protectionModeVest")] = toJson(static_cast<int>(element.protectionModeVest));
  obj[QStringLiteral("protectionModeHelmet")] = toJson(static_cast<int>(element.protectionModeHelmet));
  obj[QStringLiteral("personellProtectionMode")] = toJson(static_cast<int>(element.personellProtectionMode));
  obj[QStringLiteral("protectionLevel")] = toJson(static_cast<int>(element.protectionLevel));
  obj[QStringLiteral("handgrenadeSearchMode")] = toJson(static_cast<int>(element.handgrenadeSearchMode));
  obj[QStringLiteral("internationalMode")] = toJson(static_cast<int>(element.internationalMode));
  obj[QStringLiteral("abcProtectionMode")] = toJson(static_cast<int>(element.abcProtectionMode));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("language"))); element.language = static_cast<ProjectDataManagement::LanguageConfiguration>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("operationMode"))); element.operationMode = static_cast<ProjectDataManagement::OperationMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reactivationDetoxication"))); element.reactivationDetoxication = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reactivationMaintenance"))); element.reactivationMaintenance = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reactivationMedic"))); element.reactivationMedic = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("protectionModeVest"))); element.protectionModeVest = static_cast<ProjectDataManagement::WphMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("protectionModeHelmet"))); element.protectionModeHelmet = static_cast<ProjectDataManagement::WphMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("personellProtectionMode"))); element.personellProtectionMode = static_cast<ProjectDataManagement::PersonalProtection>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("protectionLevel"))); element.protectionLevel = static_cast<ProjectDataManagement::ProtectionLevel>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("handgrenadeSearchMode"))); element.handgrenadeSearchMode = static_cast<ProjectDataManagement::HandgrenadeSearchMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("internationalMode"))); element.internationalMode = static_cast<ProjectDataManagement::InternationalMode>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("abcProtectionMode"))); element.abcProtectionMode = static_cast<ProjectDataManagement::ABCProtectionMode>(val.toInt()); } 

  return element;
}

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

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




// ParticipantSanitaryMaterialStockReport
QJsonObject toJson(const ParticipantSanitaryMaterialStockReport &element)
{
  QJsonObject obj;
  obj[QStringLiteral("originatorEquipmentNumber")] = element.originatorEquipmentNumber;
  obj[QStringLiteral("qualification")] = toJson(static_cast<int>(element.qualification));
  obj[QStringLiteral("uniqueId")] = element.uniqueId;
  obj[QStringLiteral("sanitaryMaterialCount")] = element.sanitaryMaterialCount;
  obj[QStringLiteral("sanitaryMaterialStock")] = toJson(element.sanitaryMaterialStock);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("originatorEquipmentNumber"))); element.originatorEquipmentNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("qualification"))); element.qualification = static_cast<TrainingAreaBase::Qualification>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("uniqueId"))); element.uniqueId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("sanitaryMaterialCount"))); element.sanitaryMaterialCount = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("sanitaryMaterialStock"))); element.sanitaryMaterialStock = fromJson<std::vector<int32_t>>(val); } 

  return element;
}

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

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




// ParticipantSanitation
QJsonObject toJson(const ParticipantSanitation &element)
{
  QJsonObject obj;
  obj[QStringLiteral("originatorEquipmentNumber")] = element.originatorEquipmentNumber;
  obj[QStringLiteral("qualification")] = toJson(static_cast<int>(element.qualification));
  obj[QStringLiteral("uniqueId")] = element.uniqueId;
  obj[QStringLiteral("proceduresTaken")] = static_cast<qint64>(element.proceduresTaken);
  obj[QStringLiteral("sanitationResult")] = toJson(static_cast<int>(element.sanitationResult));
  obj[QStringLiteral("sanitationEvaluation")] = toJson(static_cast<int>(element.sanitationEvaluation));
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("originatorEquipmentNumber"))); element.originatorEquipmentNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("qualification"))); element.qualification = static_cast<TrainingAreaBase::Qualification>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("uniqueId"))); element.uniqueId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("proceduresTaken"))); element.proceduresTaken = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("sanitationResult"))); element.sanitationResult = static_cast<TrainingAreaBase::SanitationResult>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("sanitationEvaluation"))); element.sanitationEvaluation = static_cast<TrainingAreaBase::SanitationEvaluation>(val.toInt()); } 

  return element;
}

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

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




// ParticipantSanitationRepair
QJsonObject toJson(const ParticipantSanitationRepair &element)
{
  QJsonObject obj;
  obj[QStringLiteral("originatorType")] = toJson(static_cast<int>(element.originatorType));
  obj[QStringLiteral("equipmentNumberOrigin")] = element.equipmentNumberOrigin;
  obj[QStringLiteral("stateStart")] = toJson(static_cast<int>(element.stateStart));
  obj[QStringLiteral("typeOfTreatment")] = element.typeOfTreatment;
  obj[QStringLiteral("triage")] = element.triage;
  obj[QStringLiteral("tyeOfDamage")] = element.tyeOfDamage;
  obj[QStringLiteral("stateResult")] = toJson(static_cast<int>(element.stateResult));
  obj[QStringLiteral("treatmentResult")] = toJson(static_cast<int>(element.treatmentResult));
  obj[QStringLiteral("triagePriority")] = element.triagePriority;
  obj[QStringLiteral("fullState")] = element.fullState;
  obj[QStringLiteral("timeOfTreatment")] = element.timeOfTreatment;
  obj[QStringLiteral("timeOfRecovery")] = element.timeOfRecovery;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("originatorType"))); element.originatorType = static_cast<ProjectDataManagement::StateChangeOriginator>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("equipmentNumberOrigin"))); element.equipmentNumberOrigin = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("stateStart"))); element.stateStart = static_cast<ProjectDataManagement::VulnerabilityState>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("typeOfTreatment"))); element.typeOfTreatment = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("triage"))); element.triage = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("tyeOfDamage"))); element.tyeOfDamage = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("stateResult"))); element.stateResult = static_cast<ProjectDataManagement::VulnerabilityState>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("treatmentResult"))); element.treatmentResult = static_cast<TrainingAreaBase::TreatmentResult>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("triagePriority"))); element.triagePriority = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("fullState"))); element.fullState = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("timeOfTreatment"))); element.timeOfTreatment = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("timeOfRecovery"))); element.timeOfRecovery = val.toInt(); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("equipments"))); element.equipments = fromJson<std::vector<TrainingAreaBase::EquipmentSwVersion>>(val); } 

  return element;
}

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

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




// RestoreRadioReadiness
QJsonObject toJson(const RestoreRadioReadiness &element)
{
  QJsonObject obj;
  obj[QStringLiteral("readinessLossPosition")] = toJson(element.readinessLossPosition);
  obj[QStringLiteral("readinessLossTime")] = element.readinessLossTime;
  obj[QStringLiteral("readinessRestorePosition")] = toJson(element.readinessRestorePosition);
  obj[QStringLiteral("readinessRestoreTime")] = element.readinessRestoreTime;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("readinessLossPosition"))); element.readinessLossPosition = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("readinessLossTime"))); element.readinessLossTime = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("readinessRestorePosition"))); element.readinessRestorePosition = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("readinessRestoreTime"))); element.readinessRestoreTime = val.toInt(); } 

  return element;
}

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

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




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

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("serviceControlState"))); element.serviceControlState = static_cast<TrainingAreaBase::ServiceControlEnum>(val.toInt()); } 

  return element;
}

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

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




// SpecialSensorData
QJsonObject toJson(const SpecialSensorData &element)
{
  QJsonObject obj;
  if (element.position.is_set()) obj[QStringLiteral("position")] = toJson(*element.position);
  obj[QStringLiteral("operationalState")] = element.operationalState;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); if (!val.isNull()) element.position = fromJson<Core::GeoPosition2D>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("operationalState"))); element.operationalState = val.toInt(); } 

  return element;
}

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

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




// StateIed
QJsonObject toJson(const StateIed &element)
{
  QJsonObject obj;
  obj[QStringLiteral("batteryWarnings")] = element.batteryWarnings;
  obj[QStringLiteral("errorStateElectronics")] = element.errorStateElectronics;
  obj[QStringLiteral("errorStatePyrotechnics1")] = element.errorStatePyrotechnics1;
  obj[QStringLiteral("errorStatePyrotechnics2")] = element.errorStatePyrotechnics2;
  obj[QStringLiteral("errorStatePyrotechnics3")] = element.errorStatePyrotechnics3;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("batteryWarnings"))); element.batteryWarnings = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("errorStateElectronics"))); element.errorStateElectronics = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("errorStatePyrotechnics1"))); element.errorStatePyrotechnics1 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("errorStatePyrotechnics2"))); element.errorStatePyrotechnics2 = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("errorStatePyrotechnics3"))); element.errorStatePyrotechnics3 = val.toInt(); } 

  return element;
}

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

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




// TabPosition
QJsonObject toJson(const TabPosition &element)
{
  QJsonObject obj;
  obj[QStringLiteral("position")] = toJson(element.position);
  obj[QStringLiteral("reportingSource")] = toJson(static_cast<int>(element.reportingSource));
  if (element.moutObjectId.is_set()) obj[QStringLiteral("moutObjectId")] = *element.moutObjectId;
  if (element.moutRoomId.is_set()) obj[QStringLiteral("moutRoomId")] = *element.moutRoomId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("position"))); element.position = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("reportingSource"))); element.reportingSource = static_cast<Core::PositionReportingSource>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("moutObjectId"))); if (!val.isNull()) element.moutObjectId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("moutRoomId"))); if (!val.isNull()) element.moutRoomId = val.toInt(); } 

  return element;
}

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

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




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

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

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

  return element;
}

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

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




// TrajectoryAdler
QJsonObject toJson(const TrajectoryAdler &element)
{
  QJsonObject obj;
  obj[QStringLiteral("trajectoryError")] = toJson(static_cast<int>(element.trajectoryError));
  obj[QStringLiteral("positionTarget")] = toJson(element.positionTarget);
  obj[QStringLiteral("weaponSystemType")] = toJson(static_cast<int>(element.weaponSystemType));
  obj[QStringLiteral("flightTime")] = element.flightTime;
  obj[QStringLiteral("peakHeight")] = element.peakHeight;
  obj[QStringLiteral("firingDirection")] = element.firingDirection;
  obj[QStringLiteral("dropAngle")] = element.dropAngle;
  obj[QStringLiteral("geometry")] = toJson(element.geometry);
  obj[QStringLiteral("trajectoryStartTime")] = static_cast<qint64>(element.trajectoryStartTime);
  obj[QStringLiteral("dispersion")] = toJson(element.dispersion);
  obj[QStringLiteral("trajectory")] = toJson(element.trajectory);
  obj[QStringLiteral("partyId")] = element.partyId;
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("trajectoryError"))); element.trajectoryError = static_cast<TrainingAreaBase::TrajectoryError>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("positionTarget"))); element.positionTarget = fromJson<Core::GeoPosition>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("weaponSystemType"))); element.weaponSystemType = static_cast<TrainingAreaBase::WeaponSystemType>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("flightTime"))); element.flightTime = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("peakHeight"))); element.peakHeight = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("firingDirection"))); element.firingDirection = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("dropAngle"))); element.dropAngle = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("geometry"))); element.geometry = fromJson<std::vector<Core::GeoPositionRelativeTime>>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("trajectoryStartTime"))); element.trajectoryStartTime = val.toDouble(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("dispersion"))); element.dispersion = fromJson<TrainingAreaBase::Dispersion>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("trajectory"))); element.trajectory = fromJson<TrainingAreaBase::TrajectoryCalculationData>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("partyId"))); element.partyId = val.toInt(); } 

  return element;
}

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

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




// TrajectoryCalculationData
QJsonObject toJson(const TrajectoryCalculationData &element)
{
  QJsonObject obj;
  obj[QStringLiteral("chargeTypeId")] = element.chargeTypeId;
  obj[QStringLiteral("igniterTypeId")] = element.igniterTypeId;
  obj[QStringLiteral("igniterFunctionId")] = element.igniterFunctionId;
  obj[QStringLiteral("loadTypeId")] = element.loadTypeId;
  obj[QStringLiteral("loadNumber")] = element.loadNumber;
  obj[QStringLiteral("fuseTime")] = element.fuseTime;
  return obj;
}

template<>
TrajectoryCalculationData fromJson(const QJsonValue &value, type<TrajectoryCalculationData>)
{
  const QJsonObject objElement(value.toObject());
  TrajectoryCalculationData 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("loadTypeId"))); element.loadTypeId = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("loadNumber"))); element.loadNumber = val.toInt(); } 
  { const QJsonValue val(objElement.value(QStringLiteral("fuseTime"))); element.fuseTime = val.toInt(); } 

  return element;
}

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

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




// UASMissionStatus
QJsonObject toJson(const UASMissionStatus &element)
{
  QJsonObject obj;
  obj[QStringLiteral("currentTask")] = toJson(static_cast<int>(element.currentTask));
  obj[QStringLiteral("currentMissionName")] = QString::fromStdString(element.currentMissionName);
  obj[QStringLiteral("missionEnded")] = QString::fromStdString(element.missionEnded);
  return obj;
}

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

  
  { const QJsonValue val(objElement.value(QStringLiteral("currentTask"))); element.currentTask = static_cast<ProjectDataManagement::UasActionTask>(val.toInt()); } 
  { const QJsonValue val(objElement.value(QStringLiteral("currentMissionName"))); element.currentMissionName = fromJson<std::string>(val); } 
  { const QJsonValue val(objElement.value(QStringLiteral("missionEnded"))); element.missionEnded = fromJson<std::string>(val); } 

  return element;
}

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

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




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

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

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

  return element;
}

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

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




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

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

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

  return element;
}

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

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





} // namespace TrainingAreaBase