942 lines
35 KiB
C++
Executable File
942 lines
35 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Read Xml service files
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
#include "XmlReader.h"
|
|
|
|
#include <NGLLogger/NGLLoggerBootstrap.h>
|
|
|
|
#include <QDirIterator>
|
|
#include <QFile>
|
|
#include <QDomDocument>
|
|
#include <QXmlStreamReader>
|
|
#include <ngltools/ngltools_filesystem.h>
|
|
|
|
using namespace CodeGen;
|
|
|
|
|
|
class XmlReaderException : public std::exception
|
|
{
|
|
public:
|
|
explicit XmlReaderException(const QString &msg) noexcept
|
|
: m_msg(msg.toUtf8())
|
|
{}
|
|
|
|
~XmlReaderException() = default;
|
|
|
|
virtual const char *what() const noexcept
|
|
{
|
|
return m_msg.data();
|
|
}
|
|
private:
|
|
const QByteArray m_msg;
|
|
};
|
|
|
|
XmlReader::XmlReader()
|
|
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("CodeGen.XmlReader"))
|
|
{}
|
|
|
|
bool XmlReader::readServiceFile(const QString &svcFile,
|
|
const QString &idlServiceInfoFile,
|
|
const XmlReader *parent)
|
|
{
|
|
m_externalXmlInformations.clear();
|
|
m_idlFiles.clear();
|
|
m_xmlFiles.clear();
|
|
m_usedServices.clear();
|
|
m_fullServiceName2Abbreviation.clear();
|
|
// clean up
|
|
m_svcNamespace.clear();
|
|
m_svcAbbr.clear();
|
|
m_svcProcNames.clear();
|
|
m_customRecordReplay = false;
|
|
m_exerciseDependency = ExerciseDependency::Exercise;
|
|
m_dbClassTables.clear();
|
|
m_struct2BaseClass.clear();
|
|
m_structsToGenerate.clear();
|
|
m_idlStructsToGenerate.clear();
|
|
m_tables.clear();
|
|
m_views.clear();
|
|
m_enumerations.clear();
|
|
m_functionTopics.clear();
|
|
m_externalTopicTypes.clear();
|
|
m_customFunctions.clear();
|
|
m_prio = 0;
|
|
m_svcDevMode = false;
|
|
|
|
// avoid parsing unneeded files
|
|
if (parent)
|
|
{
|
|
m_idlFiles = parent->m_idlFiles;
|
|
m_xmlFiles = parent->m_xmlFiles;
|
|
m_fullServiceName2Abbreviation = parent->m_fullServiceName2Abbreviation;
|
|
m_externalXmlInformations = parent->m_externalXmlInformations;
|
|
}
|
|
|
|
|
|
// load informations about the location of all idl files
|
|
loadIdlInfofile(idlServiceInfoFile);
|
|
|
|
// try to open the service file
|
|
QFile f(svcFile);
|
|
if (!f.exists())
|
|
{
|
|
ERROR_LOG(m_logger) << "Service file '" << svcFile << "' not found!";
|
|
return false;
|
|
}
|
|
if (!f.open(QIODevice::ReadOnly))
|
|
{
|
|
m_errorString = QLatin1String("Can not open service file '") + svcFile +
|
|
QLatin1String("' for reading: ") + f.errorString();
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
INFO_LOG(m_logger) << "SvcFile: " << svcFile;
|
|
|
|
// read content
|
|
QString errMsg;
|
|
int errLine = 0;
|
|
int errColumn = 0;
|
|
QDomDocument doc;
|
|
if (!doc.setContent(&f, &errMsg, &errLine, &errColumn))
|
|
{
|
|
m_errorString = QLatin1String("Error parsing service file '") + svcFile + QLatin1String("': ") +
|
|
errMsg + QLatin1String(" at ") + QString::number(errLine) +
|
|
QLatin1Char(':') + QString::number(errColumn);
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
// now finally read the data
|
|
// what do we expect?
|
|
// - a service name ( plus service abbreviation i.e. AES)
|
|
// - service classes to generate (dbServiceStructs)
|
|
// - database tables to generate (tables)
|
|
// - static enumerations to generate (enumerations)
|
|
// - idl structures for topicTypes (idlStructs)
|
|
// - a devMode attribute which is optional
|
|
QDomElement domRoot = doc.documentElement();
|
|
if (!domRoot.hasAttribute(QStringLiteral("namespace")))
|
|
{
|
|
m_errorString = QLatin1String("Xml file '") + svcFile +
|
|
QLatin1String("' is not a valid service file: service name/namespace is missing");
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
m_svcNamespace = getAttribute(domRoot, QStringLiteral("namespace"));
|
|
m_svcAbbr = getAttribute(domRoot, QStringLiteral("abbreviation")).toLower();
|
|
m_svcProcNames = getAttribute(domRoot, QStringLiteral("procNames")).split(QLatin1Char(','));
|
|
m_customRecordReplay = getAttributeBool(domRoot, QStringLiteral("customRecordReplay"), true, false);
|
|
|
|
QString devModeStr = getAttribute(domRoot, QStringLiteral("devMode"), true);
|
|
m_svcDevMode = devModeStr == QStringLiteral("1") ||
|
|
devModeStr == QStringLiteral("true");
|
|
INFO_LOG(m_logger) << "devMode: " << m_svcDevMode;
|
|
|
|
const QString groupNamesString = getAttribute(domRoot, QStringLiteral("groups"), true);
|
|
if (!groupNamesString.isEmpty())
|
|
{
|
|
m_groupNames = groupNamesString.split(QLatin1Char(','), QString::SkipEmptyParts);
|
|
INFO_LOG(m_logger) << "groups: " << groupNamesString;
|
|
}
|
|
else
|
|
m_groupNames.clear();
|
|
|
|
m_exerciseDependency = string2ExerciseDependency(getAttribute(domRoot, QStringLiteral("exerciseDependency"), true));
|
|
// exerciseIndepenent only if in core/master group AND no other groups
|
|
// core + other groups => one instance of service is svc_0
|
|
// other instances are svc_<exerciseId>
|
|
if (m_groupNames.contains(QStringLiteral("Core")) ||
|
|
m_groupNames.contains(QStringLiteral("Master")))
|
|
{
|
|
if (m_exerciseDependency != ExerciseDependency::Global &&
|
|
m_exerciseDependency != ExerciseDependency::GlobalAndExercise)
|
|
{
|
|
WARNING_LOG(m_logger) << "Service " << getServiceNamespace()
|
|
<< " is not marked as exercise independent but should be started in group Core/Master";
|
|
}
|
|
}
|
|
|
|
INFO_LOG(m_logger) << "exerciseDependency: " << (int)m_exerciseDependency;
|
|
if ( domRoot.hasAttribute(QStringLiteral("prio")))
|
|
{
|
|
m_prio = getAttribute(domRoot, QStringLiteral("prio"), 0).toInt();
|
|
}
|
|
try
|
|
{
|
|
parseDBSserviceStructs(domRoot.firstChildElement(QStringLiteral("dbServiceStructs")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing dbServiceStructs: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
parseDBTables(domRoot.firstChildElement(QStringLiteral("tables")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing dbtables: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
parseDBViews(domRoot.firstChildElement(QStringLiteral("views")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing dbviews: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
parseEnumerations(domRoot.firstChildElement(QStringLiteral("enumerations")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing enumerations: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
parseCustomDtcFunctions(domRoot.firstChildElement(QStringLiteral("customDtcFunctions")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing custom dtc functions: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
parseTopicTypes(domRoot.firstChildElement(QStringLiteral("topicTypes")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing idl strucs: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
parseFunctionTopics(domRoot.firstChildElement(QStringLiteral("functionTopics")));
|
|
}
|
|
catch (const XmlReaderException &ex)
|
|
{
|
|
m_errorString = QLatin1String("Error parsing function topics: ") + QLatin1String(ex.what());
|
|
ERROR_LOG(m_logger) << m_errorString;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
QString XmlReader::getAttribute(const QDomElement &element,
|
|
const QString &attributeName,
|
|
bool bOptional)
|
|
{
|
|
if (!element.hasAttribute(attributeName))
|
|
{
|
|
if (bOptional)
|
|
return QString();
|
|
throw XmlReaderException(QLatin1String("Element ") + element.tagName() +
|
|
QLatin1String(" has no attribute ") + attributeName);
|
|
}
|
|
return element.attribute(attributeName);
|
|
}
|
|
|
|
bool XmlReader::getAttributeBool(const QDomElement &element,
|
|
const QString &attributeName,
|
|
bool bOptional, bool defaultValue)
|
|
{
|
|
QString str = getAttribute(element, attributeName, bOptional);
|
|
if (str.isEmpty())
|
|
return defaultValue;
|
|
bool bOk;
|
|
bool ret = (str.toInt(&bOk) != 0);
|
|
if (!bOk)
|
|
throw XmlReaderException(QLatin1String("Can not parse boolean value: ") + str);
|
|
return ret;
|
|
}
|
|
|
|
int XmlReader::getAttributeInt(const QDomElement &element,
|
|
const QString &attributeName,
|
|
bool bOptional, int defaultValue)
|
|
{
|
|
QString str = getAttribute(element, attributeName, bOptional);
|
|
if (str.isEmpty())
|
|
return defaultValue;
|
|
bool bOk;
|
|
int ret = str.toInt(&bOk);
|
|
if (!bOk)
|
|
{
|
|
//try from base16
|
|
ret = str.toUInt(&bOk,16);
|
|
if(!bOk)
|
|
throw XmlReaderException(QLatin1String("Can not parse int value: ") + str);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void XmlReader::parseDBSserviceStructs(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
// service struct -> table relations
|
|
QDomElement domDbStruct = rootElement.firstChildElement(QStringLiteral("serviceStruct"));
|
|
while (!domDbStruct.isNull())
|
|
{
|
|
ServiceStructInformation ssi;
|
|
ssi.name = getAttribute(domDbStruct, QStringLiteral("name"));
|
|
ssi.primaryTable = getAttribute(domDbStruct, QStringLiteral("table"));
|
|
ssi.hasStaticContent = getAttributeBool(domDbStruct, QStringLiteral("static"), true, false);
|
|
|
|
QDomElement domFunc = domDbStruct.firstChildElement(QStringLiteral("function"));
|
|
while (!domFunc.isNull())
|
|
{
|
|
m_customFunctions += parseCustomFunction(domFunc, CustomServiceFunctionInformation::Type::Db);
|
|
domFunc = domFunc.nextSiblingElement(domFunc.tagName());
|
|
}
|
|
|
|
QDomElement domNotify = domDbStruct.firstChildElement(QStringLiteral("notification"));
|
|
while (!domNotify.isNull())
|
|
{
|
|
ssi.dbNotifications.append(parseDbNotification(domNotify));
|
|
domNotify = domNotify.nextSiblingElement(domNotify.tagName());
|
|
}
|
|
|
|
m_structsToGenerate.push_back(ssi);
|
|
|
|
domDbStruct = domDbStruct.nextSiblingElement(domDbStruct.tagName());
|
|
}
|
|
std::sort(m_structsToGenerate.begin(), m_structsToGenerate.end());
|
|
|
|
// table -> parent table relations
|
|
domDbStruct = rootElement.firstChildElement(QStringLiteral("table"));
|
|
while (!domDbStruct.isNull())
|
|
{
|
|
const QString table = getAttribute(domDbStruct, QStringLiteral("name"));
|
|
const QString parentTable = getAttribute(domDbStruct, QStringLiteral("base"), true);
|
|
m_struct2BaseClass[table] = parentTable;
|
|
|
|
domDbStruct = domDbStruct.nextSiblingElement(domDbStruct.tagName());
|
|
}
|
|
INFO_LOG(m_logger) << "Read " << m_structsToGenerate.size() << " database service struct(s)";
|
|
}
|
|
|
|
void XmlReader::parseDBTables(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
QDomElement domDbTable = rootElement.firstChildElement(QStringLiteral("table"));
|
|
while (!domDbTable.isNull())
|
|
{
|
|
QSharedPointer<TableInformation> ti(new TableInformation);
|
|
ti->name = getAttribute(domDbTable, QStringLiteral("name"));
|
|
ti->structName = QLatin1String("t_") + ti->name;
|
|
ti->comment = getAttribute(domDbTable, QStringLiteral("comment"), true);
|
|
ti->exerciseDependency = string2ExerciseDependency(getAttribute(domDbTable, QStringLiteral("exerciseDependency"), true));
|
|
|
|
QDomElement domColumn = domDbTable.firstChildElement(QStringLiteral("column"));
|
|
while (!domColumn.isNull())
|
|
{
|
|
ti->plainColumns.append(parseTableColumn(domColumn, ti->name));
|
|
domColumn = domColumn.nextSiblingElement(domColumn.tagName());
|
|
}
|
|
|
|
QDomElement domForeignKey = domDbTable.firstChildElement(QStringLiteral("foreignKey"));
|
|
while (!domForeignKey.isNull())
|
|
{
|
|
ti->foreignKeys.append(parseForeignKey(domForeignKey));
|
|
domForeignKey = domForeignKey.nextSiblingElement(domForeignKey.tagName());
|
|
}
|
|
QDomElement domConstraint = domDbTable.firstChildElement(QStringLiteral("constraint"));
|
|
while (!domConstraint.isNull())
|
|
{
|
|
ti->constraints.append(parseConstraint(domConstraint));
|
|
domConstraint = domConstraint.nextSiblingElement(domConstraint.tagName());
|
|
}
|
|
|
|
m_tables.insert(ti->name, ti);
|
|
|
|
domDbTable = domDbTable.nextSiblingElement(domDbTable.tagName());
|
|
}
|
|
|
|
INFO_LOG(m_logger) << "Read " << m_tables.size() << " database table(s)";
|
|
}
|
|
|
|
void XmlReader::parseDBViews(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
QDomElement domDbView = rootElement.firstChildElement(QStringLiteral("view"));
|
|
while (!domDbView.isNull())
|
|
{
|
|
QSharedPointer<ViewInformation> vi(new ViewInformation);
|
|
vi->name = getAttribute(domDbView, QStringLiteral("name"));
|
|
vi->structName = QLatin1String("v_") + vi->name;
|
|
vi->baseSchema = m_svcAbbr;
|
|
vi->baseTable = getAttribute(domDbView, QStringLiteral("base"));
|
|
vi->comment = getAttribute(domDbView, QStringLiteral("comment"), true);
|
|
vi->filter = getAttribute(domDbView, QStringLiteral("filter"));
|
|
vi->exerciseDependency = string2ExerciseDependency(getAttribute(domDbView, QStringLiteral("exerciseDependency"), true));
|
|
|
|
DEBUG_LOG(m_logger) << "Base table = " << vi->baseTable;
|
|
/*
|
|
QDomElement domConstraint = domDbView.firstChildElement(QStringLiteral("constraint"));
|
|
while (!domConstraint.isNull())
|
|
{
|
|
vi->constraints.append(parseConstraint(domConstraint));
|
|
domConstraint = domConstraint.nextSiblingElement(domConstraint.tagName());
|
|
}
|
|
*/
|
|
m_views.insert(vi->name, vi);
|
|
|
|
domDbView = domDbView.nextSiblingElement(domDbView.tagName());
|
|
}
|
|
|
|
INFO_LOG(m_logger) << "Read " << m_views.size() << " database view(s)";
|
|
}
|
|
|
|
void XmlReader::parseEnumerations(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
QDomElement domEnum = rootElement.firstChildElement(QStringLiteral("enumeration"));
|
|
while (!domEnum.isNull())
|
|
{
|
|
EnumInformation enumeration;
|
|
enumeration.serviceName = getServiceNamespace();
|
|
enumeration.enumName = getAttribute(domEnum, QStringLiteral("name"));
|
|
enumeration.tableName = getAttribute(domEnum, QStringLiteral("table"), true);
|
|
|
|
QDomElement enumVal = domEnum.firstChildElement(QStringLiteral("attribute"));
|
|
while (!enumVal.isNull())
|
|
{
|
|
EnumKeyValuePair evp;
|
|
evp.key = getAttribute(enumVal, QStringLiteral("key"));
|
|
evp.value = getAttributeInt(enumVal, QStringLiteral("value"));
|
|
enumeration.values.append(evp);
|
|
|
|
enumVal = enumVal.nextSiblingElement(enumVal.tagName());
|
|
}
|
|
|
|
m_enumerations.push_back(enumeration);
|
|
|
|
domEnum = domEnum.nextSiblingElement(domEnum.tagName());
|
|
}
|
|
INFO_LOG(m_logger) << "Read " << m_enumerations.size() << " enumeration(s)";
|
|
}
|
|
|
|
void XmlReader::parseCustomDtcFunctions(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
QDomElement domElement = rootElement.firstChildElement(QStringLiteral("customDtcFunction"));
|
|
while (!domElement.isNull())
|
|
{
|
|
|
|
QDomElement domFunc = domElement.firstChildElement(QStringLiteral("function"));
|
|
while (!domFunc.isNull())
|
|
{
|
|
m_customFunctions += parseCustomFunction(domFunc, CustomServiceFunctionInformation::Type::Dtc);
|
|
domFunc = domFunc.nextSiblingElement(domFunc.tagName());
|
|
}
|
|
domElement = domElement.nextSiblingElement(domElement.tagName());
|
|
}
|
|
INFO_LOG(m_logger) << "Read " << m_enumerations.size() << " customDtcFunction(s)";
|
|
}
|
|
|
|
/**
|
|
* @brief Parse idl structure (TopicType Information)
|
|
* (IDL = Interface Definition Language)
|
|
* @param rootElement
|
|
*/
|
|
void XmlReader::parseTopicTypes(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
// idl struct
|
|
QDomElement domIdlStruct = rootElement.firstChildElement(QStringLiteral("topicType"));
|
|
while (!domIdlStruct.isNull())
|
|
{
|
|
TopicTypeInformation isi;
|
|
isi.name = getAttribute(domIdlStruct, QStringLiteral("name"));
|
|
isi.baseValueType = getAttribute(domIdlStruct, QStringLiteral("baseValueType"), true);
|
|
|
|
// preload some external topics to be able to know which external services we're using
|
|
const QVector<QStringRef> sl = isi.baseValueType.splitRef(QStringLiteral("::"));
|
|
if (sl.size() == 2)
|
|
loadExternalTopicType(sl.at(0).toString(), sl.at(1).toString());
|
|
|
|
const QString tmp = getAttribute(domIdlStruct, QStringLiteral("extensibility"), true);
|
|
|
|
if (tmp.compare(QLatin1String("FINAL"), Qt::CaseInsensitive) == 0) isi.extensibility = dds::core::xtypes::ExtensibilityKind::FINAL;
|
|
if (tmp.compare(QLatin1String("MUTABLE"), Qt::CaseInsensitive) == 0) isi.extensibility = dds::core::xtypes::ExtensibilityKind::MUTABLE;
|
|
if (tmp.compare(QLatin1String("EXTENSIBLE"), Qt::CaseInsensitive) == 0) isi.extensibility = dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;
|
|
|
|
isi.comment = getAttribute(domIdlStruct, QStringLiteral("comment"), true);
|
|
isi.isDataObject = getAttributeBool(domIdlStruct, QStringLiteral("isDataObject"), true, false);
|
|
isi.dtsAutogen = getAttributeBool(domIdlStruct, QStringLiteral("autogenDTS"), true, true);
|
|
isi.dtcAutogen = getAttributeBool(domIdlStruct, QStringLiteral("autogenDTC"), true, true);
|
|
isi.recordTopic = getAttributeBool(domIdlStruct, QStringLiteral("recordTopic"), true, false);
|
|
isi.routeToClient = getAttributeBool(domIdlStruct, QStringLiteral("routeToClient"), true, true);
|
|
isi.routeToServer = getAttributeBool(domIdlStruct, QStringLiteral("routeToServer"), true, false);
|
|
isi.routeInReplay = getAttributeBool(domIdlStruct, QStringLiteral("routeInReplay"), true, false);
|
|
isi.autosubscribe = getAttributeBool(domIdlStruct, QStringLiteral("autosubscribe"), true, true);
|
|
|
|
QDomElement domColumn = domIdlStruct.firstChildElement(QStringLiteral("column"));
|
|
while (!domColumn.isNull())
|
|
{
|
|
isi.columns.append(parseIdlStructColumn(domColumn));
|
|
domColumn = domColumn.nextSiblingElement(domColumn.tagName());
|
|
}
|
|
|
|
//INFO_LOG(m_logger) << "# TopicType: " << isi.name;
|
|
m_idlStructsToGenerate.insert(isi.name, isi);
|
|
|
|
domIdlStruct = domIdlStruct.nextSiblingElement(domIdlStruct.tagName());
|
|
}
|
|
|
|
|
|
INFO_LOG(m_logger) << "Read " << m_idlStructsToGenerate.size() << " idl struct(s)";
|
|
}
|
|
|
|
void XmlReader::parseFunctionTopics(const QDomElement &rootElement)
|
|
{
|
|
if (rootElement.isNull())
|
|
return;
|
|
|
|
// idl struct
|
|
QDomElement domFunctionTopic = rootElement.firstChildElement(QStringLiteral("functionTopic"));
|
|
while (!domFunctionTopic.isNull())
|
|
{
|
|
FunctionTopic ft;
|
|
ft.name = getAttribute(domFunctionTopic, QStringLiteral("name"));
|
|
ft.requestTopicType = getAttribute(domFunctionTopic, QStringLiteral("requestTopicType"));
|
|
ft.replyTopicType = getAttribute(domFunctionTopic, QStringLiteral("replyTopicType"));
|
|
ft.requestTopicName = getAttribute(domFunctionTopic, QStringLiteral("requestTopicName"));
|
|
ft.replyTopicName = getAttribute(domFunctionTopic, QStringLiteral("replyTopicName"));
|
|
ft.routeInReplay = getAttributeBool(domFunctionTopic, QStringLiteral("routeInReplay"), true, false);
|
|
|
|
m_functionTopics.append(ft);
|
|
|
|
domFunctionTopic = domFunctionTopic.nextSiblingElement(domFunctionTopic.tagName());
|
|
}
|
|
|
|
for (const FunctionTopic &ft : qAsConst(m_functionTopics))
|
|
{
|
|
const QVector<QStringRef> sl1 = ft.requestTopicType.splitRef(QStringLiteral("::"));
|
|
if (sl1.size() == 2)
|
|
loadExternalTopicType(sl1.at(0).toString(), sl1.at(1).toString());
|
|
const QVector<QStringRef> sl2 = ft.replyTopicType.splitRef(QStringLiteral("::"));
|
|
if (sl2.size() == 2)
|
|
loadExternalTopicType(sl2.at(0).toString(), sl2.at(1).toString());
|
|
}
|
|
}
|
|
|
|
ColumnInformation XmlReader::parseTableColumn(const QDomElement &column, const QString &tableName) const
|
|
{
|
|
ColumnInformation ci;
|
|
|
|
ci.columnName = getAttribute(column, QStringLiteral("name"));
|
|
ci.datatype = getAttribute(column, QStringLiteral("datatype"));
|
|
ci.defaultValue = getAttribute(column, QStringLiteral("default"), true);
|
|
ci.comment = getAttribute(column, QStringLiteral("comment"), true);
|
|
ci.isPrimaryKey = getAttributeBool(column, QStringLiteral("isPrimaryKey"), true, false);
|
|
ci.isForeignKey = getAttributeBool(column, QStringLiteral("isForeignKey"), true, false);
|
|
ci.isOptional = getAttributeBool(column, QStringLiteral("isOptional"), true, false);
|
|
const QDomElement seq = column.firstChildElement(QStringLiteral("sequence"));
|
|
if (!seq.isNull())
|
|
{
|
|
ci.sequenceStart = getAttributeInt(seq, QStringLiteral("start"), true, -1);
|
|
ci.sequenceIncrement = getAttributeInt(seq, QStringLiteral("increment"), true, -1);
|
|
ci.hasSequence = ci.sequenceStart >= 0 && ci.sequenceIncrement > 0;
|
|
}
|
|
|
|
if (ci.columnName.toLower() != ci.columnName)
|
|
WARNING_LOG(m_logger) << "Column " << ci.columnName << " in Table "
|
|
<< tableName << " has has upper-case chars which is not allowed!";
|
|
|
|
return ci;
|
|
}
|
|
|
|
IdlColumnInformation XmlReader::parseIdlStructColumn(const QDomElement &column) const
|
|
{
|
|
IdlColumnInformation ci;
|
|
|
|
ci.name = getAttribute(column, QStringLiteral("name"));
|
|
ci.type = getAttribute(column, QStringLiteral("idlType"));
|
|
ci.comment = getAttribute(column, QStringLiteral("comment"), true);
|
|
ci.isKey = getAttributeBool(column, QStringLiteral("isKey"), true, false);
|
|
ci.isOptional = getAttributeBool(column, QStringLiteral("isOptional"), true, false);
|
|
ci.isTranslatable = getAttributeBool(column, QStringLiteral("isTranslatable"), true, false);
|
|
|
|
return ci;
|
|
}
|
|
|
|
QSharedPointer<ForeignKeyInformation> XmlReader::parseForeignKey(const QDomElement &foreignKey) const
|
|
{
|
|
QSharedPointer<ForeignKeyInformation> fk(new ForeignKeyInformation);
|
|
|
|
fk->name = getAttribute(foreignKey, QStringLiteral("name"));
|
|
// Default-Value of isOnDeleteCascade => true
|
|
const QString deleteAction = getAttribute(foreignKey, QStringLiteral("referential_integrity"), true);
|
|
if (deleteAction == QLatin1String("DeleteNoAction"))
|
|
fk->deleteAction = ForeignKeyInformation::OnDeleteAction::NoAction;
|
|
else if (deleteAction == QLatin1String("DeleteCascade"))
|
|
fk->deleteAction = ForeignKeyInformation::OnDeleteAction::Cascade;
|
|
else if (deleteAction == QLatin1String("DeleteRestrict"))
|
|
fk->deleteAction = ForeignKeyInformation::OnDeleteAction::Restrict;
|
|
else if (deleteAction == QLatin1String("DeleteSetNull"))
|
|
fk->deleteAction = ForeignKeyInformation::OnDeleteAction::SetNull;
|
|
else if (deleteAction == QLatin1String("DeleteSetDefault"))
|
|
fk->deleteAction = ForeignKeyInformation::OnDeleteAction::SetDefault;
|
|
else
|
|
fk->deleteAction = ForeignKeyInformation::OnDeleteAction::Cascade; // default
|
|
|
|
fk->source = parseForeignKeyEndpoint(fk->name, foreignKey.firstChildElement(QStringLiteral("source")));
|
|
fk->destination = parseForeignKeyEndpoint(fk->name, foreignKey.firstChildElement(QStringLiteral("destination")));
|
|
|
|
return fk;
|
|
}
|
|
|
|
ForeignKeyInformation::Endpoint XmlReader::parseForeignKeyEndpoint(const QString &foreignKeyName,
|
|
const QDomElement &endpoint) const
|
|
{
|
|
if (endpoint.isNull())
|
|
throw XmlReaderException(QLatin1String("No endpoint for foreign key ") + foreignKeyName);
|
|
|
|
ForeignKeyInformation::Endpoint fkEndpoint;
|
|
|
|
fkEndpoint.service = getAttribute(endpoint, QStringLiteral("service"), true);
|
|
fkEndpoint.serviceAbbr= getAttribute(endpoint, QStringLiteral("serviceAbbr"), true);
|
|
fkEndpoint.schema = getAttribute(endpoint, QStringLiteral("schema"), true);
|
|
fkEndpoint.tableName = getAttribute(endpoint, QStringLiteral("table"));
|
|
fkEndpoint.columnName = getAttribute(endpoint, QStringLiteral("column"));
|
|
|
|
return fkEndpoint;
|
|
}
|
|
|
|
ConstraintInformation XmlReader::parseConstraint(const QDomElement &constraint) const
|
|
{
|
|
ConstraintInformation ret;
|
|
|
|
ret.name = getAttribute(constraint, QStringLiteral("name"), true);
|
|
const QString type = getAttribute(constraint, QStringLiteral("type")).toLower();
|
|
if (type == QLatin1String("unique"))
|
|
ret.type = ConstraintInformation::Type::unique;
|
|
else if (type == QLatin1String("index"))
|
|
ret.type = ConstraintInformation::Type::index;
|
|
|
|
QDomElement domColumn = constraint.firstChildElement(QStringLiteral("column"));
|
|
if (domColumn.isNull())
|
|
throw XmlReaderException(QLatin1String("No column for constraint") + ret.name);
|
|
while (!domColumn.isNull())
|
|
{
|
|
ret.affectedColumns += getAttribute(domColumn, QStringLiteral("name"));
|
|
domColumn = domColumn.nextSiblingElement(domColumn.tagName());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
CustomServiceFunctionInformation XmlReader::parseCustomFunction(const QDomElement &customFunc,
|
|
CustomServiceFunctionInformation::Type funcType) const
|
|
{
|
|
CustomServiceFunctionInformation ret;
|
|
ret.methodName = getAttribute(customFunc, QStringLiteral("name"));
|
|
ret.returnValue = getAttribute(customFunc, QStringLiteral("returns"), true);
|
|
ret.isConst = getAttributeBool(customFunc, QStringLiteral("isConst"), true, false);
|
|
if (ret.returnValue.isEmpty())
|
|
ret.returnValue = QStringLiteral("bool");
|
|
QMap<int, QPair<QString, QString>> paramHelper;
|
|
QDomElement domParam = customFunc.firstChildElement(QStringLiteral("parameter"));
|
|
while (!domParam.isNull())
|
|
{
|
|
int pos = getAttributeInt(domParam, QStringLiteral("pos"));
|
|
if (paramHelper.contains(pos))
|
|
throw XmlReaderException(QLatin1String("Doubled position entry for custom function ") + ret.methodName);
|
|
QString paramName = getAttribute(domParam, QStringLiteral("name"));
|
|
const QString paramType = getAttribute(domParam, QStringLiteral("type"));
|
|
const QString paramDefault = getAttribute(domParam, QStringLiteral("default"), true);
|
|
if (!paramDefault.isEmpty())
|
|
paramName.append(QLatin1String(" = ") + paramDefault);
|
|
paramHelper[pos] = qMakePair(paramName, paramType);
|
|
domParam = domParam.nextSiblingElement(domParam.tagName());
|
|
|
|
}
|
|
ret.paramNames.reserve(paramHelper.size());
|
|
ret.paramTypes.reserve(paramHelper.size());
|
|
ret.type = funcType;
|
|
QStringList signature;
|
|
for (auto it = paramHelper.constBegin(); it != paramHelper.constEnd(); ++it)
|
|
{
|
|
ret.paramNames += it.value().first;
|
|
ret.paramTypes += it.value().second;
|
|
QString tmp = it.value().second;
|
|
if (!it.value().second.endsWith(QLatin1Char('&')))
|
|
tmp += QLatin1Char(' ');
|
|
tmp += it.value().first;
|
|
signature += tmp;
|
|
}
|
|
ret.signature += signature.join(QStringLiteral(", "));
|
|
return ret;
|
|
}
|
|
|
|
DbNotifcationInformation XmlReader::parseDbNotification(const QDomElement &customFunc) const
|
|
{
|
|
DbNotifcationInformation ret(parseCustomFunction(customFunc, CustomServiceFunctionInformation::Type::DbNotify));
|
|
|
|
const QString attribute(getAttribute(customFunc, QStringLiteral("notificationTypes")).toLower());
|
|
const QStringList nfTypes = attribute.split(QLatin1Char(','));
|
|
static const QMap<QString, DbNotifcationInformation::NotificationType> s_nfTypeMap =
|
|
{
|
|
{ QLatin1String("beforeinsert"), DbNotifcationInformation::NotificationType::BeforeInsert },
|
|
{ QLatin1String("afterinsert"), DbNotifcationInformation::NotificationType::AfterInsert },
|
|
{ QLatin1String("beforeupdate"), DbNotifcationInformation::NotificationType::BeforeUpdate },
|
|
{ QLatin1String("afterupdate"), DbNotifcationInformation::NotificationType::AfterUpdate },
|
|
{ QLatin1String("beforedelete"), DbNotifcationInformation::NotificationType::BeforeDelete },
|
|
{ QLatin1String("afterdelete"), DbNotifcationInformation::NotificationType::AfterDelete }
|
|
};
|
|
for (const QString &nfType : nfTypes)
|
|
{
|
|
const auto it = s_nfTypeMap.find(nfType);
|
|
if (it == s_nfTypeMap.end())
|
|
throw XmlReaderException(QStringLiteral("Can not find notification type %2 in type map for function %1").arg(ret.methodName, nfType));
|
|
ret.notificationType += it.value();
|
|
}
|
|
if (ret.notificationType.isEmpty())
|
|
throw XmlReaderException(QStringLiteral("Notification function '%1' without a valid notification type").arg(ret.methodName));
|
|
if (ret.paramTypes.size() != 1)
|
|
throw XmlReaderException(QStringLiteral("Notification function '%1' must have exactly one parameter").arg(ret.methodName));
|
|
|
|
return ret;
|
|
}
|
|
|
|
TopicTypeInformation XmlReader::loadExternalTopicType(const QString &externalServiceName, const QString &topicTypeName)
|
|
{
|
|
DEBUG_LOG(m_logger) << "externalServiceName: " << externalServiceName << ", topicTypeName: " << topicTypeName;
|
|
|
|
if (!loadExternalService(externalServiceName))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not find service " << externalServiceName
|
|
<< " referenced by external topic " << topicTypeName;
|
|
return TopicTypeInformation();
|
|
}
|
|
auto extXmlReader = m_externalXmlInformations.value(externalServiceName);
|
|
if (!extXmlReader)
|
|
{
|
|
ERROR_LOG(m_logger) << "Could not find service xml file for service '" << externalServiceName << "'";
|
|
return TopicTypeInformation();
|
|
}
|
|
|
|
TopicTypeInformation tti = extXmlReader->getIdlStructInformation().value(topicTypeName);
|
|
if (tti.isValid())
|
|
{
|
|
tti.name = externalServiceName + QLatin1String("::") + tti.name;
|
|
m_externalTopicTypes += tti;
|
|
m_usedServices[externalServiceName] = true;
|
|
return tti;
|
|
}
|
|
WARNING_LOG(m_logger) << "Could not find topic " << topicTypeName
|
|
<< " in external service definition for service "
|
|
<< externalServiceName;
|
|
return TopicTypeInformation();
|
|
}
|
|
|
|
EnumInformation XmlReader::getExternalEnumeration(const QString &externalServiceName, const QString &enumName, bool verbose)
|
|
{
|
|
DEBUG_LOG(m_logger) << "externalServiceName: " << externalServiceName << ", topicTypeName: " << enumName;
|
|
|
|
if (!loadExternalService(externalServiceName))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not find service '" << externalServiceName << "'"
|
|
<< " referenced by external enumeration " << enumName;
|
|
return EnumInformation();
|
|
}
|
|
auto extXmlReader = m_externalXmlInformations.value(externalServiceName);
|
|
if (!extXmlReader)
|
|
{
|
|
ERROR_LOG(m_logger) << "Could not find service xml file for service '" << externalServiceName << "'";
|
|
return EnumInformation();
|
|
}
|
|
|
|
const QVector<EnumInformation> enums = extXmlReader->getEnumerations();
|
|
for (const EnumInformation &ei : enums)
|
|
{
|
|
if (ei.enumName == enumName)
|
|
{
|
|
m_usedServices[externalServiceName] = true;
|
|
return ei;
|
|
}
|
|
}
|
|
if (verbose)
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not find enumeration " << enumName
|
|
<< " in external service definition for '"
|
|
<< externalServiceName << "'";
|
|
}
|
|
return EnumInformation();
|
|
}
|
|
|
|
|
|
bool XmlReader::loadExternalService(const QString &serviceName)
|
|
{
|
|
if (serviceName == getServiceNamespace())
|
|
return false;
|
|
if (m_externalXmlInformations.contains(serviceName))
|
|
return true;
|
|
|
|
QString fileName = xmlFileForService(serviceName);
|
|
if (fileName.isEmpty())
|
|
{
|
|
const QVector<QString> dirs = NGL::directories(NGL::FileType::ConfigFile);
|
|
for (const QString &dirname : dirs)
|
|
{
|
|
QDirIterator dirIt(dirname + QStringLiteral("/xml"), QDir::Files | QDir::NoDotAndDotDot | QDir::Readable);
|
|
while (dirIt.hasNext())
|
|
{
|
|
dirIt.next();
|
|
if (!dirIt.fileName().endsWith(QLatin1String(".xml")))
|
|
continue;
|
|
|
|
fileName = dirIt.filePath();
|
|
const QString svcNamespace = serviceNamespaceFromFile(fileName);
|
|
if (svcNamespace == serviceName)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (fileName.isEmpty())
|
|
return false;
|
|
|
|
DEBUG_LOG(m_logger) << "xml file for " << serviceName << ": " << fileName;
|
|
auto extXmlReader = QSharedPointer<XmlReader>(new XmlReader);
|
|
if (!extXmlReader->readServiceFile(fileName, QString(), this))
|
|
{
|
|
WARNING_LOG(m_logger) << "Error reading service file " << fileName
|
|
<< " for service " << serviceName;
|
|
return false;
|
|
}
|
|
m_externalXmlInformations[serviceName] = extXmlReader;
|
|
if (!m_usedServices.contains(serviceName))
|
|
m_usedServices[serviceName] = false;
|
|
return true;
|
|
}
|
|
|
|
void XmlReader::loadIdlInfofile(const QString &idlServiceInfoFile)
|
|
{
|
|
if (idlServiceInfoFile.isEmpty())
|
|
return;
|
|
QFile f(idlServiceInfoFile);
|
|
if (!f.open(QIODevice::ReadOnly))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not read idl service info file " << idlServiceInfoFile;
|
|
return;
|
|
}
|
|
const QList<QByteArray> files = f.readAll().split('\n');
|
|
for (const QByteArray &filePath : files)
|
|
{
|
|
// comment
|
|
if (filePath.startsWith("--") || filePath.trimmed().isEmpty())
|
|
continue;
|
|
const QString fileName = QString::fromLocal8Bit(filePath.trimmed());
|
|
const QVector<QStringRef> parts = fileName.splitRef(QLatin1Char('/'));
|
|
getServiceNameInfoFromFilePath(parts); // what/ever/ServiceFooBar/sfb_service.xml -> ServiceFooBar <-> sfb
|
|
const auto fn = parts.last().trimmed();
|
|
if (fn.endsWith(QLatin1String(".xml")))
|
|
{
|
|
const auto svcAbbreveation = fn.split(QLatin1Char('.')).at(0).split(QLatin1Char('_')).at(0);
|
|
m_xmlFiles[svcAbbreveation.toString()] = fileName;
|
|
DEBUG_LOG(m_logger) << "xml: " << svcAbbreveation.toString() << " = " << fileName;
|
|
}
|
|
else
|
|
{
|
|
const auto svcAbbreveation = fn.split(QLatin1Char('.')).at(0).toString().toLower();
|
|
if (svcAbbreveation.endsWith(QLatin1String("_enums")))
|
|
continue;
|
|
m_idlFiles[svcAbbreveation] = fileName;
|
|
DEBUG_LOG(m_logger) << "idl: " << svcAbbreveation << " = " << fileName;
|
|
}
|
|
}
|
|
}
|
|
|
|
QString XmlReader::getIdlFileForService(const QMap<QString, QString> &data,
|
|
const QString &serviceName) const
|
|
{
|
|
const QString serviceAbbr = serviceNameAbbreviation(serviceName);
|
|
return data.value(serviceAbbr);
|
|
}
|
|
|
|
|
|
QString XmlReader::serviceNameAbbreviation(const QString &serviceName) const
|
|
{
|
|
return m_fullServiceName2Abbreviation.value(serviceName);
|
|
}
|
|
|
|
void XmlReader::getServiceNameInfoFromFilePath(const QVector<QStringRef> &parts)
|
|
{
|
|
if (parts.size() < 2)
|
|
return;
|
|
|
|
// foo_service.xml -> foo
|
|
const QString abbreviation = parts.last().split(QLatin1Char('.')).first().split(QLatin1Char('_')).first().toString();
|
|
const QString serviceName = parts.at(parts.size() - 2).toString();
|
|
DEBUG_LOG(m_logger) << "serviceName: " << serviceName << " = " << abbreviation;
|
|
m_fullServiceName2Abbreviation[serviceName] = abbreviation;
|
|
}
|
|
|
|
ExerciseDependency XmlReader::string2ExerciseDependency(const QString &str)
|
|
{
|
|
if (str.isEmpty())
|
|
return ExerciseDependency::Undefined;
|
|
const QStringList sd = str.toLower().split(QLatin1Char(','));
|
|
int ret = ExerciseDependency::Undefined;
|
|
for (const QString &s : sd)
|
|
{
|
|
if (s == QLatin1String("global"))
|
|
ret |= ExerciseDependency::Global;
|
|
else if (s == QLatin1String("exercise"))
|
|
ret |= ExerciseDependency::Exercise;
|
|
else if (s == QLatin1String("globalandexercise"))
|
|
ret |= ExerciseDependency::GlobalAndExercise;
|
|
}
|
|
return static_cast<ExerciseDependency>(ret);
|
|
}
|
|
|
|
QString XmlReader::serviceNamespaceFromFile(const QString &fn)
|
|
{
|
|
QFile f(fn);
|
|
if (!f.open(QIODevice::ReadOnly))
|
|
return QString();
|
|
QXmlStreamReader sr(&f);
|
|
while (!sr.atEnd())
|
|
{
|
|
sr.readNext();
|
|
if (sr.isStartElement() && sr.name() == QLatin1String("service"))
|
|
return (sr.attributes().value(QLatin1String("namespace"))).toString();
|
|
}
|
|
return QString();
|
|
}
|
|
|