/**
* @brief ClassMethod::fromJson
* @param src
* @param errorList
*/
void ClassMethod::fromJson(const QJsonObject &src, QStringList &errorList)
{
BasicElement::fromJson(src, errorList);
utility::checkAndSet(src, sectionMark, errorList, [&src, this](){
m_Section = static_cast<Section>(src[sectionMark].toInt());
});
utility::checkAndSet(src, typeMark, errorList, [&src, this](){
m_Type = static_cast<ClassMethodType>(src[typeMark].toInt());
});
utility::checkAndSet(src, csMark, errorList, [&src, this](){
m_ConstStatus = src[csMark].toBool();
});
utility::checkAndSet(src, signalMark, errorList, [&src, this](){
m_SignalStatus = src[signalMark].toBool();
});
utility::checkAndSet(src, slotMark, errorList, [&src, this](){
m_SlotStatus = src[slotMark].toBool();
});
utility::checkAndSet(src, rtMark, errorList, [&src, &errorList, this](){
m_ReturnTypeId.fromJson(src[rtMark], errorList);
});
utility::checkAndSet(src, rhsiMark, errorList, [&src, this](){
m_RhsIdentificator = static_cast<RhsIdentificator>(src[rhsiMark].toInt());
});
m_Parameters.clear();
utility::checkAndSet(src, paramsMark, errorList, [&src, &errorList, this](){
if (src[paramsMark].isArray()) {
SharedField parameter;
for (auto &&value : src[paramsMark].toArray()) {
parameter = std::make_shared<Field>();
parameter->fromJson(value.toObject(), errorList);
m_Parameters << parameter;
}
} else {
errorList << "Error: \"Parameters\" is not array";
}
});
m_LhsIdentificators.clear();
utility::checkAndSet(src, lhsMark, errorList, [&src, &errorList, this](){
if (src[lhsMark].isArray()) {
for (auto &&value : src[lhsMark].toArray())
m_LhsIdentificators.insert(static_cast<LhsIdentificator>(value.toInt()));
} else {
errorList << "Error: \"Lhs identificators\" is not array";
}
});
}
/**
* @brief Union::fromJson
* @param src
* @param errorList
*/
void Union::fromJson(const QJsonObject &src, QStringList &errorList)
{
Type::fromJson(src, errorList);
m_Fields.clear();
Util::checkAndSet(src, "Fields", errorList, [&src, &errorList, this](){
if (src["Fields"].isArray()) {
SharedField f;
for (auto &&value : src["Fields"].toArray()) {
f = std::make_shared<Field>();
f->fromJson(value.toObject(), errorList);
m_Fields.append(f);
}
} else {
errorList << "Error: \"Fields\" is not array";
}
});
}
/**
* @brief Class::fromJson
* @param src
* @param errorList
*/
void Class::fromJson(const QJsonObject &src, QStringList &errorList)
{
Type::fromJson(src, errorList);
utility::checkAndSet(src, "Kind", errorList, [&src, this](){
m_Kind = static_cast<Kind>(src["Kind"].toInt());
});
utility::checkAndSet(src, "Final status", errorList, [&src, this](){
m_FinalStatus = src["Final status"].toBool();
});
m_Parents.clear();
utility::checkAndSet(src, "Parents", errorList, [&src, &errorList, this](){
Parent p;
QJsonObject o;
if (src["Parents"].isArray()) {
for (auto &&value : src["Parents"].toArray()) {
o = value.toObject();
utility::checkAndSet(o, "Id", errorList, [&o, &p, this](){
p.first = o["Id"].toString();
});
utility::checkAndSet(o, "Section", errorList, [&o, &p, this](){
p.second = static_cast<Section>(o["Section"].toInt());
});
m_Parents.append(p);
}
} else {
errorList << "Error: \"Parents\" is not array";
}
});
m_Methods.clear();
utility::checkAndSet(src, "Methods", errorList, [&src, &errorList, this](){
if (src["Methods"].isArray()) {
SharedMethod method;
QJsonObject obj;
for (auto &&value : src["Methods"].toArray()) {
obj = value.toObject();
utility::checkAndSet(obj, "Type", errorList,
[&obj, &errorList, &method, this](){
method = utility::makeMethod(static_cast<ClassMethodType>(obj["Type"].toInt()));
method->fromJson(obj, errorList);
m_Methods << method;
});
}
} else {
errorList << "Error: \"Methods\" is not array";
}
});
m_Fields.clear();
utility::checkAndSet(src, "Fields", errorList, [&src, &errorList, this](){
if (src["Fields"].isArray()) {
SharedField field;
for (auto &&value : src["Fields"].toArray()) {
field = std::make_shared<Field>();
field->fromJson(value.toObject(), errorList);
m_Fields << field;
}
} else {
errorList << "Error: \"Fields\" is not array";
}
});
m_Properties.clear();
utility::checkAndSet(src, "Properties", errorList, [&src, &errorList, this](){
if (src["Properties"].isArray()) {
SharedProperty property;
for (auto &&value : src["Properties"].toArray()) {
property = std::make_shared<Property>();
property->fromJson(value.toObject(), errorList);
m_Properties << property;
}
} else {
errorList << "Error: \"Properties\" is not array";
}
});
}
