Debian Codegraph @

Source/Control/Interface/SPARQL/CSPARQLXMLAnswerSerializer.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CSPARQLXMLAnswerSerializer.h"
22
23
24 namespace Konclude {
25
26 namespace Control {
27
28 namespace Interface {
29
30 namespace SPARQL {
31
32 CSPARQLXMLAnswerSerializer::CSPARQLXMLAnswerSerializer() {
33 sparqlNS = "http://www.w3.org/2005/sparql-results#";
34 owlNS = "http://www.w3.org/2002/07/owl#";
35 }
36
37
38 CSPARQLXMLAnswerSerializer::~CSPARQLXMLAnswerSerializer() {
39 }
40
41
42
43 QByteArray CSPARQLXMLAnswerSerializer::serializeResult(CBooleanQueryResult* booleanResult) {
44 QDomDocument document;
45 QDomProcessingInstruction procInstHeader = document.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
46 document.appendChild(procInstHeader);
47 QDomElement rootNode;
48 rootNode = document.createElementNS(sparqlNS, "sparql");
49 rootNode.setAttribute("xml:base", sparqlNS);
50 rootNode.setAttribute("xmlns:owl", owlNS);
51 rootNode.setAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema#");
52 document.appendChild(rootNode);
53
54 QList<QDomElement> resultsElements = getResultElements(booleanResult, document);
55 for (QDomElement element : resultsElements) {
56 rootNode.appendChild(element);
57 }
58
59 return document.toString().toUtf8();
60
61 }
62
63
64
65 QByteArray CSPARQLXMLAnswerSerializer::serializeResult(const QStringList& varList, CVariableBindingsAnswersResult* variableBindingsAnswersResult) {
66 QDomDocument document;
67 QDomProcessingInstruction procInstHeader = document.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
68 document.appendChild(procInstHeader);
69 QDomElement rootNode;
70 rootNode = document.createElementNS(sparqlNS, "sparql");
71 rootNode.setAttribute("xml:base", sparqlNS);
72 rootNode.setAttribute("xmlns:owl", owlNS);
73 rootNode.setAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema#");
74 document.appendChild(rootNode);
75
76 QList<QDomElement> resultsElements = getResultElements(varList, variableBindingsAnswersResult, document);
77 for (QDomElement element : resultsElements) {
78 rootNode.appendChild(element);
79 }
80
81 return document.toString().toUtf8();
82 }
83
84
85
86
87
88 CSPARQLXMLAnswerSerializer* CSPARQLXMLAnswerSerializer::addResultError(const QString& errorText, const QString &nodeString, cint64 pos) {
89 initializeCombinedDocument();
90
91
92 QDomElement errorNode = mCombinedDocument.createElement(nodeString);
93
94 QDomElement errorTextNodePa = mCombinedDocument.createElement(QString("%1Text").arg(nodeString));
95
96 QDomText errorTextNode = mCombinedDocument.createTextNode(errorText);
97 errorNode.setAttribute("error", errorText);
98
99 errorTextNodePa.appendChild(errorTextNode);
100 errorNode.appendChild(errorTextNodePa);
101
102
103 mPosSerializedResultHash.insertMulti(pos, QList<QDomElement>()<<errorNode);
104 return this;
105 }
106
107
108
109
110 CSPARQLXMLAnswerSerializer* CSPARQLXMLAnswerSerializer::addResultSerialization(CBooleanQueryResult* booleanResult, cint64 pos) {
111 initializeCombinedDocument();
112 QList<QDomElement> elements = getResultElements(booleanResult, mCombinedDocument);
113 mPosSerializedResultHash.insertMulti(pos, elements);
114 return this;
115 }
116
117 CSPARQLXMLAnswerSerializer* CSPARQLXMLAnswerSerializer::addResultSerialization(const QStringList& varList, CVariableBindingsAnswersResult* variableBindingsAnswersResult, cint64 pos) {
118 initializeCombinedDocument();
119 QList<QDomElement> elements = getResultElements(varList, variableBindingsAnswersResult, mCombinedDocument);
120 mPosSerializedResultHash.insertMulti(pos, elements);
121 return this;
122 }
123
124
125 CSPARQLXMLAnswerSerializer* CSPARQLXMLAnswerSerializer::addResultStatistics(CQueryStatistics* queryStats, cint64 pos) {
126 initializeCombinedDocument();
127 #ifndef KONCLUDE_FORCE_STATISTIC_DEACTIVATED
128 if (queryStats) {
129 QList<QString> statStrings(queryStats->getStatisticsNameStringList());
130 if (statStrings.count() >= 1) {
131 QVector<QDomElement> statNodeVec(statStrings.count() + 1);
132 QList<QDomElement> statMoreNodeList;
133 QList<QDomElement> statClassNodeList;
134 QList<QDomElement> statAnswNodeList;
135 QDomElement statNode = mCombinedDocument.createElement("answering-statistics");
136 foreach(QString statName, statStrings) {
137 cint64 index = CProcessingStatistics::getIndexFromProcessingStatisticDescriptionName(statName);
138 if (index >= 0) {
139 QDomElement statValueNode = mCombinedDocument.createElement("counted-process-statistic");
140 statValueNode.setAttribute("statistic-name", statName);
141 statValueNode.setAttribute("statistic-value", queryStats->getStatisticIntegerValue(statName));
142 statNodeVec[index] = statValueNode;
143 } else {
144 if (statName.startsWith("answering")) {
145 QDomElement statValueNode = mCombinedDocument.createElement("answering-statistic");
146 statValueNode.setAttribute("statistic-name", statName);
147 statValueNode.setAttribute("statistic-value", queryStats->getStatisticIntegerValue(statName));
148 statAnswNodeList.append(statValueNode);
149 } else if (statName.startsWith("class-classification")) {
150 QDomElement statValueNode = mCombinedDocument.createElement("class-classification-statistic");
151 statValueNode.setAttribute("statistic-name", statName);
152 statValueNode.setAttribute("statistic-value", queryStats->getStatisticIntegerValue(statName));
153 statClassNodeList.append(statValueNode);
154 } else {
155 QDomElement statValueNode = mCombinedDocument.createElement("calculation-statistic");
156 statValueNode.setAttribute("statistic-name", statName);
157 statValueNode.setAttribute("statistic-value", queryStats->getStatisticIntegerValue(statName));
158 statMoreNodeList.append(statValueNode);
159 }
160 }
161 }
162 foreach(QDomElement statValueNode, statMoreNodeList) {
163 statNode.appendChild(statValueNode);
164 }
165 foreach(QDomElement statValueNode, statClassNodeList) {
166 statNode.appendChild(statValueNode);
167 }
168 foreach(QDomElement statValueNode, statAnswNodeList) {
169 statNode.appendChild(statValueNode);
170 }
171 for (cint64 index = 0; index < statNodeVec.count(); ++index) {
172 QDomElement statValueNode = statNodeVec[index];
173 if (!statValueNode.isNull()) {
174 statNode.appendChild(statValueNode);
175 }
176 }
177 QList<QDomElement>& elements = mPosSerializedResultHash[pos];
178 elements.append(statNode);
179 }
180 }
181 #endif
182 return this;
183 }
184
185 QByteArray CSPARQLXMLAnswerSerializer::getCombinedResultSerialization() {
186
187 QDomElement rootNode = mCombinedDocument.documentElement();
188
189 for (QMap<cint64, QList<QDomElement> >::const_iterator it = mPosSerializedResultHash.constBegin(), itEnd = mPosSerializedResultHash.constEnd(); it != itEnd; ++it) {
190 const QList<QDomElement>& elements = it.value();
191 for (QDomElement element : elements) {
192 rootNode.appendChild(element);
193 }
194 }
195
196 mPosSerializedResultHash.clear();
197 mCombinedDocumentInitialized = false;
198 return mCombinedDocument.toString().toUtf8();
199 }
200
201
202
203
204 CSPARQLXMLAnswerSerializer* CSPARQLXMLAnswerSerializer::initializeCombinedDocument() {
205
206 if (!mCombinedDocumentInitialized) {
207 mCombinedDocumentInitialized = true;
208 QDomDocument document;
209 QDomProcessingInstruction procInstHeader = document.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
210 document.appendChild(procInstHeader);
211 QDomElement rootNode;
212 rootNode = document.createElementNS(sparqlNS, "sparql");
213 rootNode.setAttribute("xml:base", sparqlNS);
214 rootNode.setAttribute("xmlns:owl", owlNS);
215 rootNode.setAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema#");
216 document.appendChild(rootNode);
217
218 mCombinedDocument = document;
219 }
220
221 return this;
222 }
223
224
225
226
227 QList<QDomElement> CSPARQLXMLAnswerSerializer::getResultElements(CBooleanQueryResult* booleanResult, QDomDocument& document) {
228 QList<QDomElement> elements;
229 QDomElement headerElement = document.createElement("head");
230 elements.append(headerElement);
231
232
233 QDomElement booleanElement = document.createElement("boolean");
234 if (booleanResult->getResult()) {
235 booleanElement.appendChild(document.createTextNode("true"));
236 } else {
237 booleanElement.appendChild(document.createTextNode("false"));
238 }
239 elements.append(booleanElement);
240 return elements;
241 }
242
243 QList<QDomElement> CSPARQLXMLAnswerSerializer::getResultElements(const QStringList& varList, CVariableBindingsAnswersResult* variableBindingsAnswersResult, QDomDocument& document) {
244 QList<QDomElement> elements;
245 QDomElement headerElement = document.createElement("head");
246 for (const QString& var : varList) {
247 QDomElement varEl = document.createElement("variable");
248 varEl.setAttribute("name", var);
249 headerElement.appendChild(varEl);
250 }
251 elements.append(headerElement);
252
253 QDomElement resultsElement = document.createElement("results");
254
255 if (variableBindingsAnswersResult) {
256 CVariableBindingsResultIterator* varBindIt = nullptr;
257 CVariableBindingsAnswersResultIterator* answersIt = variableBindingsAnswersResult->getVariableBindingsAnswersIterator();
258 while (answersIt->hasNext()) {
259
260
261 CVariableBindingsAnswerResult* varBindAnswer = answersIt->getNext();
262 varBindIt = varBindAnswer->getVariableBindingsIterator(varBindIt);
263 QDomElement resultEl = document.createElement("result");
264
265 QStringList::const_iterator varListIt = varList.constBegin();
266
267 while (varBindIt->hasNext()) {
268
269 QString varString = *varListIt;
270 ++varListIt;
271
272 CVariableBindingResult* varBin = varBindIt->getNext();
273 QDomElement bindingEl = document.createElement("binding");
274 bindingEl.setAttribute("name", varString);
275 if (varBin) {
276 if (varBin->isNamedIndividualBindingType() || varBin->isClassBindingType() || varBin->isPropertyBindingType()) {
277 QDomElement uriEl = document.createElement("uri");
278 uriEl.appendChild(document.createTextNode(varBin->getQueryResultString()));
279 bindingEl.appendChild(uriEl);
280 }
281 else if (varBin->isAnonymousIndividualBindingType()) {
282 QDomElement uriEl = document.createElement("bnode");
283 uriEl.appendChild(document.createTextNode(varBin->getQueryResultString()));
284 bindingEl.appendChild(uriEl);
285 }
286 else if (varBin->isLiteralBindingType()) {
287 QDomElement uriEl = document.createElement("literal");
288 uriEl.setAttribute("datatype", varBin->getLiteralDatatypeBindingString());
289 uriEl.appendChild(document.createTextNode(varBin->getLiteralDatavalueBindingString()));
290 bindingEl.appendChild(uriEl);
291 }
292 } else {
293 QDomElement unboundEl = document.createElement("unbound");
294 bindingEl.appendChild(unboundEl);
295 }
296 resultEl.appendChild(bindingEl);
297 }
298 resultsElement.appendChild(resultEl);
299 }
300 delete answersIt;
301 delete varBindIt;
302 }
303 elements.append(resultsElement);
304
305 return elements;
306 }
307
308
309
310 }; // end namespace SPARQL
311
312 }; // end namespace Interface
313
314 }; // end namespace Control
315
316 }; // end namespace Konclude