Debian Codegraph @

Source/Control/Interface/SPARQL/CSPARQLXMLAnswerStreamingSerializer.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 "CSPARQLXMLAnswerStreamingSerializer.h"
22
23
24 namespace Konclude {
25
26 namespace Control {
27
28 namespace Interface {
29
30 namespace SPARQL {
31
32 CSPARQLXMLAnswerStreamingSerializer::CSPARQLXMLAnswerStreamingSerializer(QByteArray* buffer, bool writeHeaderAndFooter) {
33 mWriteHeaderAndFooter = writeHeaderAndFooter;
34 sparqlNS = "http://www.w3.org/2005/sparql-results#";
35 owlNS = "http://www.w3.org/2002/07/owl#";
36 xsdNS = "http://www.w3.org/2001/XMLSchema#";
37 mSparqlHeaderWritten = false;
38 mStreamWriter = new QXmlStreamWriter();
39 mStreamWriter->setAutoFormatting(true);
40 mStreamWriter->setAutoFormattingIndent(2);
41 mCurrentBuffer = nullptr;
42 mCurrentArray = nullptr;
43 mVarBindIt = nullptr;
44 mSparqlFooterWritten = false;
45 if (buffer) {
46 updateWriteBuffer(buffer);
47 }
48 }
49
50
51 CSPARQLXMLAnswerStreamingSerializer::~CSPARQLXMLAnswerStreamingSerializer() {
52 delete mStreamWriter;
53 delete mVarBindIt;
54 mVarBindIt = nullptr;
55 }
56
57
58 cint64 CSPARQLXMLAnswerStreamingSerializer::getBufferWrittenSize() {
59 return mCurrentArray->size();
60 }
61
62 QByteArray* CSPARQLXMLAnswerStreamingSerializer::updateWriteBuffer(QByteArray* buffer) {
63 QByteArray* tmpArray = mCurrentArray;
64 QBuffer* tmpBuffer = mCurrentBuffer;
65 mCurrentArray = buffer;
66 mCurrentBuffer = nullptr;
67 if (buffer) {
68 mCurrentBuffer = new QBuffer(buffer);
69 mCurrentBuffer->open(QIODevice::WriteOnly);
70 mStreamWriter->setDevice(mCurrentBuffer);
71 }
72 delete tmpBuffer;
73 return tmpArray;
74 }
75
76
77
78 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::addResultError(const QString& errorText, const QString &nodeString) {
79 forceHeaderWritten();
80 mStreamWriter->writeTextElement(nodeString, errorText);
81 return this;
82 }
83
84
85
86 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::forceHeaderWritten() {
87 if (!mSparqlHeaderWritten && mWriteHeaderAndFooter) {
88 mSparqlHeaderWritten = true;
89 mStreamWriter->writeStartDocument();
90 mStreamWriter->writeStartElement("sparql");
91 mStreamWriter->writeAttribute("xmlns", sparqlNS);
92 mStreamWriter->writeAttribute("xml:base", sparqlNS);
93 mStreamWriter->writeAttribute("xmlns:owl", owlNS);
94 mStreamWriter->writeAttribute("xmlns:xsd", xsdNS);
95 }
96 return this;
97 }
98
99
100 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::finish() {
101 if (mSparqlHeaderWritten) {
102 if (!mSparqlFooterWritten) {
103 mSparqlFooterWritten = true;
104 mStreamWriter->writeEndElement();
105 mStreamWriter->writeEndDocument();
106 }
107 }
108 return this;
109 }
110
111
112
113
114 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::addResultSerialization(CBooleanQueryResult* booleanResult) {
115 forceHeaderWritten();
116 mStreamWriter->writeStartElement("head");
117 mStreamWriter->writeEndElement();
118 QString result;
119 if (booleanResult->getResult()) {
120 result = "true";
121 } else {
122 result = "false";
123 }
124 mStreamWriter->writeTextElement("boolean", result);
125 return this;
126 }
127
128
129
130 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::addResultStreamingStart(const QStringList& varList) {
131 mStreamWriter->writeStartElement("head");
132 for (const QString& var : varList) {
133 mStreamWriter->writeStartElement("variable");
134 mStreamWriter->writeAttribute("name", var);
135 mStreamWriter->writeEndElement();
136 }
137 mStreamWriter->writeEndElement();
138
139 writeResultStreamingStart();
140 return this;
141 }
142
143
144 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::writeResultStreamingStart() {
145 mStreamWriter->writeStartElement("results");
146 return this;
147 }
148
149
150
151 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::addResultStreamingBinding(const QStringList& varList, CVariableBindingsAnswerResult* bindings) {
152 mStreamWriter->writeStartElement("result");
153
154 mVarBindIt = bindings->getVariableBindingsIterator(mVarBindIt);
155 QStringList::const_iterator varListIt = varList.constBegin();
156
157 while (mVarBindIt->hasNext()) {
158 QString varString = *varListIt;
159 ++varListIt;
160
161 CVariableBindingResult* varBin = mVarBindIt->getNext();
162 if (varBin) {
163 mStreamWriter->writeStartElement("binding");
164 mStreamWriter->writeAttribute("name", varString);
165 if (varBin->isNamedIndividualBindingType() || varBin->isClassBindingType() || varBin->isPropertyBindingType()) {
166 mStreamWriter->writeTextElement("uri", varBin->getQueryResultString());
167 } else if (varBin->isAnonymousIndividualBindingType()) {
168 mStreamWriter->writeTextElement("bnode", varBin->getQueryResultString());
169 } else if (varBin->isLiteralBindingType()) {
170 mStreamWriter->writeStartElement("literal");
171 mStreamWriter->writeAttribute("datatype", varBin->getLiteralDatatypeBindingString());
172 mStreamWriter->writeCharacters(varBin->getLiteralDatavalueBindingString());
173 mStreamWriter->writeEndElement();
174 }
175 mStreamWriter->writeEndElement();
176 }
177 }
178 mStreamWriter->writeEndElement();
179 return this;
180 }
181
182
183
184 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::writeResultStreamingEnd() {
185 mStreamWriter->writeEndElement();
186 return this;
187 }
188
189
190
191 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::addResultSerialization(const QStringList& varList, CVariableBindingsAnswersResult* variableBindingsAnswersResult) {
192 forceHeaderWritten();
193 if (variableBindingsAnswersResult && dynamic_cast<CVariableBindingsAnswersStreamingResult*>(variableBindingsAnswersResult)) {
194 writeResultStreamingEnd();
195 delete mVarBindIt;
196 mVarBindIt = nullptr;
197 } else {
198 addResultStreamingStart(varList);
199 if (variableBindingsAnswersResult) {
200 CVariableBindingsAnswersResultIterator* answersIt = variableBindingsAnswersResult->getVariableBindingsAnswersIterator();
201 while (answersIt->hasNext()) {
202 CVariableBindingsAnswerResult* varBindAnswer = answersIt->getNext();
203 addResultStreamingBinding(varList, varBindAnswer);
204 }
205 delete answersIt;
206 delete mVarBindIt;
207 mVarBindIt = nullptr;
208
209 }
210 writeResultStreamingEnd();
211 }
212
213 return this;
214 }
215
216
217
218 CSPARQLXMLAnswerStreamingSerializer* CSPARQLXMLAnswerStreamingSerializer::addResultStatistics(CQueryStatistics* queryStats) {
219 #ifndef KONCLUDE_FORCE_STATISTIC_DEACTIVATED
220 forceHeaderWritten();
221 if (queryStats) {
222 QList<QString> statStrings(queryStats->getStatisticsNameStringList());
223 if (statStrings.count() >= 1) {
224 typedef QPair<QString, QString> TStatNameValuePair;
225 QVector<TStatNameValuePair> statNodeVec(statStrings.count() + 1);
226 QList<TStatNameValuePair> statMoreNodeList;
227 QList<TStatNameValuePair> statClassNodeList;
228 QList<TStatNameValuePair> statAnswNodeList;
229 foreach(QString statName, statStrings) {
230 cint64 index = CProcessingStatistics::getIndexFromProcessingStatisticDescriptionName(statName);
231 TStatNameValuePair statNameValuePair(statName, QString::number(queryStats->getStatisticIntegerValue(statName)));
232 if (index >= 0) {
233 statNodeVec[index] = statNameValuePair;
234 } else {
235 if (statName.startsWith("answering")) {
236 statAnswNodeList.append(statNameValuePair);
237 } else if (statName.startsWith("class-classification")) {
238 statClassNodeList.append(statNameValuePair);
239 } else {
240 statMoreNodeList.append(statNameValuePair);
241 }
242 }
243 }
244
245
246 mStreamWriter->writeStartElement("answering-statistics");
247 foreach(TStatNameValuePair statValueNode, statMoreNodeList) {
248 mStreamWriter->writeStartElement("calculation-statistic");
249 mStreamWriter->writeAttribute("statistic-name", statValueNode.first);
250 mStreamWriter->writeAttribute("statistic-value", statValueNode.second);
251 mStreamWriter->writeEndElement();
252 }
253 foreach(TStatNameValuePair statValueNode, statClassNodeList) {
254 mStreamWriter->writeStartElement("class-classification-statistic");
255 mStreamWriter->writeAttribute("statistic-name", statValueNode.first);
256 mStreamWriter->writeAttribute("statistic-value", statValueNode.second);
257 mStreamWriter->writeEndElement();
258 }
259 foreach(TStatNameValuePair statValueNode, statAnswNodeList) {
260 mStreamWriter->writeStartElement("answering-statistic");
261 mStreamWriter->writeAttribute("statistic-name", statValueNode.first);
262 mStreamWriter->writeAttribute("statistic-value", statValueNode.second);
263 mStreamWriter->writeEndElement();
264 }
265 for (cint64 index = 0; index < statNodeVec.count(); ++index) {
266 TStatNameValuePair statValueNode = statNodeVec[index];
267 if (!statValueNode.first.isEmpty() && statValueNode.second.isEmpty()) {
268 mStreamWriter->writeStartElement("counted-process-statistic");
269 mStreamWriter->writeAttribute("statistic-name", statValueNode.first);
270 mStreamWriter->writeAttribute("statistic-value", statValueNode.second);
271 mStreamWriter->writeEndElement();
272 }
273 }
274 mStreamWriter->writeEndElement();
275 }
276 }
277 #endif
278 return this;
279 }
280
281
282 }; // end namespace SPARQL
283
284 }; // end namespace Interface
285
286 }; // end namespace Control
287
288 }; // end namespace Konclude