Debian Codegraph @

Source/Parser/CSPARQLExtendedMappingBuildingParser.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 #ifdef KONCLUDE_REDLAND_INTEGRATION
21
22 #include "CSPARQLExtendedMappingBuildingParser.h"
23
24
25 namespace Konclude {
26
27 namespace Parser {
28
29
30
31 CSPARQLExtendedMappingBuildingParser::CSPARQLExtendedMappingBuildingParser(COntologyBuilder* ontoBuilder, CConcreteOntology* ontology) : CSPARQLSimpleBuildingParser(ontoBuilder, ontology) {
32 }
33
34
35 CSPARQLExtendedMappingBuildingParser::~CSPARQLExtendedMappingBuildingParser() {
36 }
37
38
39 QList<CAxiomExpression*> CSPARQLExtendedMappingBuildingParser::getTripleOWLAxioms(QHash<QString, CRDFHahsedSubjectData>* subjectTripleHash, bool anonymousIndividualsAsVariables) {
40 QList<CSPARQLBuildingParserTripleData*>* tripleDataList = createTermTripleData(subjectTripleHash);
41 bool requiresMapping = analyseTermTripleDataRequiresExtendedMapping(tripleDataList, anonymousIndividualsAsVariables);
42 if (!requiresMapping) {
43 return CSPARQLSimpleBuildingParser::getTripleOWLAxioms(subjectTripleHash, anonymousIndividualsAsVariables);
44 } else {
45 return handlingMappingRequiredTermTripleData(tripleDataList, anonymousIndividualsAsVariables, nullptr);
46 }
47 }
48
49 QList<CAxiomExpression*> CSPARQLExtendedMappingBuildingParser::getTripleOWLAxioms(QList<CRDFStringTriple>* tripleStringList, bool anonymousIndividualsAsVariables, QSet<CExpressionVariable*>* varExpSet) {
50 QList<CSPARQLBuildingParserTripleData*>* tripleDataList = createTermTripleData(tripleStringList);
51 bool requiresMapping = analyseTermTripleDataRequiresExtendedMapping(tripleDataList, anonymousIndividualsAsVariables);
52 if (!requiresMapping) {
53 return CSPARQLSimpleBuildingParser::getTripleOWLAxioms(tripleStringList, anonymousIndividualsAsVariables, varExpSet);
54 } else {
55 return handlingMappingRequiredTermTripleData(tripleDataList, anonymousIndividualsAsVariables, varExpSet);
56 }
57 }
58
59
60
61 librdf_node* CSPARQLExtendedMappingBuildingParser::getRedlandRDFNode(CSPARQLBuildingParserTermData* termData, CRedlandStoredTriplesData* triplesData, QHash<CSPARQLBuildingParserTermData*, librdf_node*>* reuseExpHash, QHash<CBuildExpression*, QString>* termVariableExpressionNewEntityHash, cint64& newEntityNumber, QSet<CExpressionVariable*>* varExpSet) {
62
63
64 librdf_world* world = triplesData->getRedlandWorld();
65
66 librdf_node* node = nullptr;
67
68 if (reuseExpHash->contains(termData)) {
69 node = reuseExpHash->value(termData);
70 node = librdf_new_node_from_node(node);
71 return node;
72 }
73
74
75 CSPARQLBuildingParserTermData::TermType termType = termData->getTermType();
76 const QString& termString = termData->getTermString();
77 if (termType == CSPARQLBuildingParserTermData::RESOURCE_TYPE || termType == CSPARQLBuildingParserTermData::CLASS_TYPE || termType == CSPARQLBuildingParserTermData::PROPERTY_TYPE || termType == CSPARQLBuildingParserTermData::DATA_PROPERTY_TYPE || termType == CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_TYPE) {
78 if (termString.startsWith("_:")) {
79 QByteArray bytes = termString.toUtf8();
80 node = librdf_new_node_from_blank_identifier(world, (const unsigned char*)bytes.constData());
81 } else {
82 QByteArray bytes = termString.toUtf8();
83 raptor_uri* uri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)bytes.constData());
84 node = librdf_new_node_from_uri(world, uri);
85 }
86 } else if (termType == CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE) {
87
88 cint64 sepPos = termString.lastIndexOf("^^");
89 QByteArray datatypeBytes = termString.mid(sepPos+2).toUtf8();
90
91 QByteArray literalBytes;
92 if (termString.startsWith("\"")) {
93 literalBytes = termString.mid(1, sepPos - 1).toUtf8(); // remove quotes
94 } else {
95 literalBytes = termString.mid(0, sepPos).toUtf8();
96 }
97 librdf_uri* datatypeUri = librdf_new_uri(world, (const unsigned char*)datatypeBytes.constData());
98 node = librdf_new_node_from_typed_literal(world, (const unsigned char*)literalBytes.constData(), NULL, datatypeUri);
99
100 } else if (termData->isVariableTerm()) {
101
102 CExpressionVariable* varExp = nullptr;
103 CBuildExpression* varBuildExp = nullptr;
104 QString varString = getVariableName(termString);
105 if (termType == CSPARQLBuildingParserTermData::CLASS_VARIABLE_TYPE) {
106 auto exp = mOntoBuilder->getClassVariable(varString);
107 varBuildExp = exp;
108 varExp = exp;
109 } else if (termType == CSPARQLBuildingParserTermData::OBJECT_PROPERTY_VARIABLE_TYPE) {
110 auto exp = mOntoBuilder->getObjectPropertyVariable(varString);
111 varBuildExp = exp;
112 varExp = exp;
113 } else if (termType == CSPARQLBuildingParserTermData::DATA_PROPERTY_VARIABLE_TYPE) {
114 auto exp = mOntoBuilder->getDataPropertyVariable(varString);
115 varBuildExp = exp;
116 varExp = exp;
117 } else if (termType == CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_VARIABLE_TYPE) {
118 auto exp = mOntoBuilder->getIndividualVariable(varString, false);
119 varBuildExp = exp;
120 varExp = exp;
121 } else if (termType == CSPARQLBuildingParserTermData::ANONYMOUS_INDIVIDUAL_VARIABLE_TYPE) {
122 auto exp = mOntoBuilder->getIndividualVariable(varString, true);
123 varBuildExp = exp;
124 varExp = exp;
125 } else if (termType == CSPARQLBuildingParserTermData::DATA_LITERAL_VARIABLE_TYPE) {
126 auto exp = mOntoBuilder->getDataLiteralVariable(varString);
127 varBuildExp = exp;
128 varExp = exp;
129 }
130
131 if (varExp) {
132 varExpSet->insert(varExp);
133 }
134
135 QString replacedEntityString = termVariableExpressionNewEntityHash->value(varBuildExp);
136 if (replacedEntityString.isEmpty()) {
137 replacedEntityString = QString("http://konclude.com/temporary/variable-encoded-as-fresh-entity/%1").arg(newEntityNumber++);
138 termVariableExpressionNewEntityHash->insert(varBuildExp, replacedEntityString);
139 }
140
141 QByteArray bytes = replacedEntityString.toUtf8();
142 raptor_uri* uri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)bytes.constData());
143 node = librdf_new_node_from_uri(world, uri);
144
145 }
146
147 reuseExpHash->insert(termData, node);
148 return node;
149 }
150
151
152 CRedlandStoredTriplesData* CSPARQLExtendedMappingBuildingParser::getUpdatingTripleData() {
153
154 CRedlandStoredTriplesData* prevTripleData = nullptr;
155 CRedlandStoredTriplesData* tripleData = nullptr;
156
157
158 if (!tripleData) {
159 tripleData = new CRedlandStoredTriplesData();
160 tripleData->initTriplesData(CTRIPLES_DATA_UPDATE_TYPE::TRIPLES_DATA_QUERYING, prevTripleData);
161 }
162
163 librdf_world* world = tripleData->getRedlandWorld();
164 if (!world) {
165 world = librdf_new_world();
166 librdf_world_open(world);
167 tripleData->setRedlandWorldData(world);
168 }
169
170 librdf_storage* indexedStorage = tripleData->getRedlandIndexedStorage();
171 if (!indexedStorage && world) {
172 indexedStorage = librdf_new_storage(world, "hashes", NULL, "hash-type='memory',index-predicates='yes'");
173 tripleData->setRedlandIndexedStorageData(indexedStorage);
174 }
175
176 librdf_model* indexedModel = tripleData->getRedlandIndexedModel();
177 if (!indexedModel && indexedStorage) {
178 indexedModel = librdf_new_model(world, indexedStorage, NULL);
179 tripleData->setRedlandIndexedModelData(indexedModel);
180 }
181
182 if (!indexedModel) {
183 delete tripleData;
184 tripleData = nullptr;
185 }
186
187 return tripleData;
188
189 }
190
191
192 QList<CSPARQLBuildingParserTripleData*>* CSPARQLExtendedMappingBuildingParser::createTermTripleData(QHash<QString, CRDFHahsedSubjectData>* subjectTripleHash) {
193 QHash<QString, CSPARQLBuildingParserTermData*> termStringDataHash;
194 QList<CSPARQLBuildingParserTripleData*>* tripleDataList = new QList<CSPARQLBuildingParserTripleData *>();
195 for (QHash<QString, CRDFHahsedSubjectData>::const_iterator it = subjectTripleHash->constBegin(), itEnd = subjectTripleHash->constEnd(); it != itEnd; ++it) {
196 const QString& subjectString = it.key();
197 const CRDFHahsedSubjectData& subjectData = it.value();
198
199 CSPARQLBuildingParserTermData* term1 = getTermData(subjectString, &termStringDataHash);
200 CSPARQLBuildingParserTermData* term2 = getTermData(subjectData.string[0], &termStringDataHash);
201 CSPARQLBuildingParserTermData* term3 = getTermData(subjectData.string[1], &termStringDataHash);
202 CSPARQLBuildingParserTripleData* triple = new CSPARQLBuildingParserTripleData(term1, term2, term3);
203 tripleDataList->append(triple);
204
205 }
206 return tripleDataList;
207 }
208
209
210 QList<CSPARQLBuildingParserTripleData*>* CSPARQLExtendedMappingBuildingParser::createTermTripleData(QList<CRDFStringTriple>* tripleStringList) {
211 QHash<QString, CSPARQLBuildingParserTermData*> termStringDataHash;
212 QList<CSPARQLBuildingParserTripleData*>* tripleDataList = new QList<CSPARQLBuildingParserTripleData *>();
213 for (CRDFStringTriple& tripleStringData : *tripleStringList) {
214 CSPARQLBuildingParserTermData* term1 = getTermData(tripleStringData.string[0], &termStringDataHash);
215 CSPARQLBuildingParserTermData* term2 = getTermData(tripleStringData.string[1], &termStringDataHash);
216 CSPARQLBuildingParserTermData* term3 = getTermData(tripleStringData.string[2], &termStringDataHash);
217 CSPARQLBuildingParserTripleData* triple = new CSPARQLBuildingParserTripleData(term1, term2, term3);
218 tripleDataList->append(triple);
219 }
220 return tripleDataList;
221 }
222
223 CSPARQLBuildingParserTermData* CSPARQLExtendedMappingBuildingParser::getTermData(const QString& termString, QHash<QString, CSPARQLBuildingParserTermData*>* termStringDataHash) {
224 CSPARQLBuildingParserTermData*& termData = (*termStringDataHash)[termString];
225 if (!termData) {
226 termData = new CSPARQLBuildingParserTermData(termString);
227 }
228 return termData;
229 }
230
231 bool CSPARQLExtendedMappingBuildingParser::analyseTermTripleDataRequiresExtendedMapping(QList<CSPARQLBuildingParserTripleData*>* tripleList, bool anonymousIndividualsAsVariables) {
232 bool updated = true;
233 bool mappingRequired = false;
234
235 for (CSPARQLBuildingParserTripleData* tripleData : *tripleList) {
236 if (!tripleData->areTermsCompletelyTyped()) {
237 for (cint64 i = 0; i < 3; ++i) {
238 CSPARQLBuildingParserTermData* term = tripleData->getTermData(i);
239 if (term->getTermType() == CSPARQLBuildingParserTermData::UNKNON_TYPE) {
240 const QString& termString = term->getTermString();
241 if (termString.startsWith("?") || termString.startsWith("$")) {
242 term->setTermType(CSPARQLBuildingParserTermData::VARIABLE_TYPE);
243 } else if (termString.startsWith("_:")) {
244 term->setTermType(CSPARQLBuildingParserTermData::BLANK_NODE_TYPE);
245 } else if (termString.startsWith("\"")) {
246 term->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE);
247 } else {
248 term->setTermType(CSPARQLBuildingParserTermData::RESOURCE_TYPE);
249 }
250 }
251 }
252 }
253
254 }
255
256
257 QSet<QString> predClassConSet;
258 predClassConSet.insert(PREFIX_RDFS_SUBCLASS_OF);
259 predClassConSet.insert(PREFIX_OWL_DISJOINT_WITH);
260 predClassConSet.insert(PREFIX_OWL_DISJOINT_UNION_OF);
261
262
263 QSet<QString> mapReqPredClassConSet;
264 mapReqPredClassConSet.insert(PREFIX_OWL_INTERSECTION_OF);
265 mapReqPredClassConSet.insert(PREFIX_OWL_UNION_OF);
266 mapReqPredClassConSet.insert(PREFIX_OWL_COMPLEMENT_OF);
267 mapReqPredClassConSet.insert(PREFIX_OWL_SOME_VALUES_FROM);
268 mapReqPredClassConSet.insert(PREFIX_OWL_ALL_VALUES_FROM);
269 mapReqPredClassConSet.insert(PREFIX_OWL_ALL_DISJOINT_CLASSES);
270
271
272 QSet<QString> mapReqPredClassSingConSet;
273 mapReqPredClassSingConSet.insert(PREFIX_OWL_MIN_CARDINALITY);
274 mapReqPredClassSingConSet.insert(PREFIX_OWL_MAX_CARDINALITY);
275 mapReqPredClassSingConSet.insert(PREFIX_OWL_CARDINALITY);
276 mapReqPredClassSingConSet.insert(PREFIX_OWL_MIN_QUALIFIED_CARDINALITY);
277 mapReqPredClassSingConSet.insert(PREFIX_OWL_MAX_QUALIFIED_CARDINALITY);
278 mapReqPredClassSingConSet.insert(PREFIX_OWL_QUALIFIED_CARDINALITY);
279 mapReqPredClassSingConSet.insert(PREFIX_OWL_ON_DATA_RANGE);
280
281
282 CBUILDHASH<CStringRefStringHasher, CObjectPropertyExpression*>* objPropEntityBuildHash = mOntology->getBuildData()->getObjectPropertyEntityBuildHash();
283 CBUILDHASH<CStringRefStringHasher, CDataPropertyExpression*>* dataPropEntityBuildHash = mOntology->getBuildData()->getDataPropertyEntityBuildHash();
284
285
286 while (updated) {
287 updated = false;
288 for (CSPARQLBuildingParserTripleData* tripleData : *tripleList) {
289 if (!tripleData->areTermsCompletelyTyped()) {
290 CSPARQLBuildingParserTermData* term1 = tripleData->getTermData(0);
291 CSPARQLBuildingParserTermData* term2 = tripleData->getTermData(1);
292 CSPARQLBuildingParserTermData* term3 = tripleData->getTermData(2);
293
294 if (term2->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) {
295 const QString& term2String = term2->getTermString();
296 const QString& term3String = term3->getTermString();
297
298 if (objPropEntityBuildHash->contains(term2String)) {
299 makeIndividualTerm(term1, anonymousIndividualsAsVariables);
300 makeIndividualTerm(term3, anonymousIndividualsAsVariables);
301 } else if (dataPropEntityBuildHash->contains(term2String)) {
302 makeIndividualTerm(term1, anonymousIndividualsAsVariables);
303 makeDataLiteralTerm(term3);
304 }
305
306 if (predClassConSet.contains(term2String)) {
307 updated |= makeClassTerm(term1);
308 updated |= makeClassTerm(term3);
309 } else if (mapReqPredClassConSet.contains(term2String)) {
310 updated |= makeClassTerm(term1);
311 updated |= makeClassTerm(term3);
312 mappingRequired = true;
313 } else if (mapReqPredClassSingConSet.contains(term2String)) {
314 updated |= makeClassTerm(term1);
315 mappingRequired = true;
316 }
317 if (term2String == PREFIX_RDFS_SUBPROPERTY_OF) {
318 bool dataProp = term1->isDataPropertyTerm() || term3->isDataPropertyTerm();
319 bool objectProp = term1->isObjectPropertyTerm() || term3->isObjectPropertyTerm();
320 if (dataProp && !objectProp) {
321 updated |= makeDataPropertyTerm(term1);
322 updated |= makeDataPropertyTerm(term3);
323 } else if (!dataProp && objectProp) {
324 updated |= makeObjectPropertyTerm(term1);
325 updated |= makeObjectPropertyTerm(term3);
326 } else {
327 updated |= makePropertyTerm(term1);
328 updated |= makePropertyTerm(term3);
329 }
330 }
331 if (term2String == PREFIX_RDF_TYPE) {
332
333 if (term3->isClassTerm() && !term1->isCompletelyTyped()) {
334 makeIndividualTerm(term1, anonymousIndividualsAsVariables);
335 }
336
337 if (term3String == PREFIX_OWL_OBJECT_PROPERTY) {
338 updated |= makeObjectPropertyTerm(term1);
339 } else if (term3String == PREFIX_OWL_DATATYPE_PROPERTY) {
340 updated |= makeDataPropertyTerm(term1);
341 } else if (term3String == PREFIX_OWL_CLASS) {
342 updated |= makeClassTerm(term1);
343 } else if (term3String == PREFIX_OWL_RESTRICTION) {
344 updated |= makeClassTerm(term1);
345 mappingRequired = true;
346 } else if (term3String == PREFIX_OWL_NAMED_INDIVIDUAL) {
347 updated |= makeIndividualTerm(term1, anonymousIndividualsAsVariables);
348 } else if (term3String == PREFIX_RDFS_DATATYPE) {
349 updated |= makeDataLiteralTerm(term1);
350 }
351
352 }
353
354 if (term2String == PREFIX_RDF_FIRST || term2String == PREFIX_RDF_REST) {
355 if (term3->getTermString() != PREFIX_RDF_NIL) {
356 if (term1->isCompletelyTyped() && !term3->isCompletelyTyped()) {
357 updated |= makeTermTypedBasedOnTerm(term3, term1, anonymousIndividualsAsVariables);
358 }
359 if (!term1->isCompletelyTyped() && term3->isCompletelyTyped()) {
360 updated |= makeTermTypedBasedOnTerm(term1, term3, anonymousIndividualsAsVariables);
361 }
362 }
363 }
364 else if (term2String == PREFIX_OWL_ONE_OF) {
365 updated |= makeClassTerm(term1);
366 updated |= makeIndividualTerm(term3, anonymousIndividualsAsVariables);
367 mappingRequired = true;
368 }
369 else if (term2String == PREFIX_OWL_HAS_VALUE) {
370 mappingRequired = true;
371 updated |= makeClassTerm(term1);
372 }
373 else if (term2String == PREFIX_OWL_ON_PROPERTY) {
374 mappingRequired = true;
375 updated |= makeClassTerm(term1);
376 updated |= makePropertyTerm(term3);
377 }
378 else if (term2String == PREFIX_OWL_INVERSE_OF) {
379 mappingRequired = true;
380 updated |= makePropertyTerm(term1);
381 updated |= makePropertyTerm(term3);
382 if (term1->isCompletelyTyped() && !term3->isCompletelyTyped()) {
383 updated |= makeTermTypedBasedOnTerm(term3, term1, anonymousIndividualsAsVariables);
384 }
385 if (!term1->isCompletelyTyped() && term3->isCompletelyTyped()) {
386 updated |= makeTermTypedBasedOnTerm(term1, term3, anonymousIndividualsAsVariables);
387 }
388 }
389
390
391 }
392
393 }
394 }
395 }
396
397 return mappingRequired;
398 }
399
400
401 bool CSPARQLExtendedMappingBuildingParser::makeTermTypedBasedOnTerm(CSPARQLBuildingParserTermData* termData, CSPARQLBuildingParserTermData* baseData, bool anonymousIndividualsAsVariables) {
402 if (baseData->isClassTerm()) {
403 return makeClassTerm(termData);
404 } else if (baseData->isObjectPropertyTerm()) {
405 return makeObjectPropertyTerm(termData);
406 } else if (baseData->isDataPropertyTerm()) {
407 return makeDataPropertyTerm(termData);
408 } else if (baseData->isIndividualTerm()) {
409 return makeIndividualTerm(termData, anonymousIndividualsAsVariables);
410 } else if (baseData->isLiteralTerm()) {
411 return makeDataLiteralTerm(termData);
412 }
413 return false;
414 }
415
416
417 bool CSPARQLExtendedMappingBuildingParser::makeIndividualTerm(CSPARQLBuildingParserTermData* termData, bool anonymousIndividualsAsVariables) {
418 if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) {
419 termData->setTermType(CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_VARIABLE_TYPE);
420 return true;
421 }
422 if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) {
423 termData->setTermType(CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_TYPE);
424 return true;
425 }
426 if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) {
427 if (anonymousIndividualsAsVariables) {
428 termData->setTermType(CSPARQLBuildingParserTermData::ANONYMOUS_INDIVIDUAL_VARIABLE_TYPE);
429 } else {
430 termData->setTermType(CSPARQLBuildingParserTermData::ANONYMOUS_INDIVIDUAL_TYPE);
431 }
432 return true;
433 }
434 return false;
435 }
436
437 bool CSPARQLExtendedMappingBuildingParser::makeClassTerm(CSPARQLBuildingParserTermData* termData) {
438 if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) {
439 termData->setTermType(CSPARQLBuildingParserTermData::CLASS_VARIABLE_TYPE);
440 return true;
441 }
442 if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) {
443 termData->setTermType(CSPARQLBuildingParserTermData::CLASS_TYPE);
444 return true;
445 }
446 if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) {
447 termData->setTermType(CSPARQLBuildingParserTermData::CLASS_TYPE);
448 return true;
449 }
450 return false;
451 }
452
453
454 bool CSPARQLExtendedMappingBuildingParser::makePropertyTerm(CSPARQLBuildingParserTermData* termData) {
455 if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) {
456 termData->setTermType(CSPARQLBuildingParserTermData::PROPERTY_VARIABLE_TYPE);
457 return true;
458 }
459 if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) {
460 termData->setTermType(CSPARQLBuildingParserTermData::PROPERTY_TYPE);
461 return true;
462 }
463 if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) {
464 termData->setTermType(CSPARQLBuildingParserTermData::PROPERTY_TYPE);
465 return true;
466 }
467 return false;
468 }
469
470
471 bool CSPARQLExtendedMappingBuildingParser::makeObjectPropertyTerm(CSPARQLBuildingParserTermData* termData) {
472 if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_VARIABLE_TYPE) {
473 termData->setTermType(CSPARQLBuildingParserTermData::OBJECT_PROPERTY_VARIABLE_TYPE);
474 return true;
475 }
476 if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_TYPE) {
477 termData->setTermType(CSPARQLBuildingParserTermData::OBJECT_PROPERTY_TYPE);
478 return true;
479 }
480 if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) {
481 termData->setTermType(CSPARQLBuildingParserTermData::OBJECT_PROPERTY_TYPE);
482 return true;
483 }
484 return false;
485 }
486
487
488 bool CSPARQLExtendedMappingBuildingParser::makeDataPropertyTerm(CSPARQLBuildingParserTermData* termData) {
489 if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_VARIABLE_TYPE) {
490 termData->setTermType(CSPARQLBuildingParserTermData::DATA_PROPERTY_VARIABLE_TYPE);
491 return true;
492 }
493 if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_TYPE) {
494 termData->setTermType(CSPARQLBuildingParserTermData::DATA_PROPERTY_TYPE);
495 return true;
496 }
497 if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) {
498 termData->setTermType(CSPARQLBuildingParserTermData::DATA_PROPERTY_TYPE);
499 return true;
500 }
501 return false;
502 }
503
504
505 bool CSPARQLExtendedMappingBuildingParser::makeDataLiteralTerm(CSPARQLBuildingParserTermData* termData) {
506 if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) {
507 termData->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_VARIABLE_TYPE);
508 return true;
509 }
510 if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) {
511 termData->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE);
512 return true;
513 }
514 if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) {
515 termData->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE);
516 return true;
517 }
518 return false;
519 }
520
521 QList<CAxiomExpression *> CSPARQLExtendedMappingBuildingParser::handlingMappingRequiredTermTripleData(QList<CSPARQLBuildingParserTripleData *>* tripleDataList, bool anonymousIndividualsAsVariables, QSet<CExpressionVariable *>* varExpSet) {
522 QList<CAxiomExpression*> axList;
523 CRedlandStoredTriplesData* triplesData = getUpdatingTripleData();
524 librdf_world* world = triplesData->getRedlandWorld();
525 librdf_model* model = triplesData->getRedlandIndexedModel();
526
527 CConcreteOntologyRedlandTriplesDataQueryingExpressionMapper* expressionMapper = new CConcreteOntologyRedlandTriplesDataQueryingExpressionMapper(mOntoBuilder);
528 QHash<CSPARQLBuildingParserTermData*, librdf_node*> reuseExpHash;
529 QHash<CBuildExpression*, QString> termVariableExpressionNewEntityHash;
530 cint64 newEntityNumber = 0;
531
532 CXLinker<librdf_statement*>* statementLinker = nullptr;
533 CXLinker<librdf_statement*>* lastStatementLinker = nullptr;
534
535 for (CSPARQLBuildingParserTripleData* tripleData : *tripleDataList) {
536
537 librdf_node* subjectNode = getRedlandRDFNode(tripleData->getTermData(0), triplesData, &reuseExpHash, &termVariableExpressionNewEntityHash, newEntityNumber, varExpSet);
538 librdf_node* predicateNode = getRedlandRDFNode(tripleData->getTermData(1), triplesData, &reuseExpHash, &termVariableExpressionNewEntityHash, newEntityNumber, varExpSet);
539 librdf_node* objectNode = getRedlandRDFNode(tripleData->getTermData(2), triplesData, &reuseExpHash, &termVariableExpressionNewEntityHash, newEntityNumber, varExpSet);
540 librdf_statement* statement = librdf_new_statement_from_nodes(world, subjectNode, predicateNode, objectNode);
541
542 librdf_statement* newStatement = librdf_new_statement_from_statement(statement);
543 librdf_model_add_statement(model, newStatement);
544
545 CXLinker<librdf_statement*>* newStatementLinker = new CXLinker<librdf_statement*>();
546 newStatementLinker->initLinker(statement, nullptr);
547 if (statementLinker) {
548 lastStatementLinker->setNext(newStatementLinker);
549 lastStatementLinker = newStatementLinker;
550 } else {
551 statementLinker = newStatementLinker;
552 lastStatementLinker = newStatementLinker;
553 }
554
555 }
556 triplesData->setRedlandStatementLinker(statementLinker);
557
558 QHash<QString, CBuildExpression*> freshEntityUseVariableExpressionHash;
559 for (QHash<CBuildExpression*, QString>::const_iterator it = termVariableExpressionNewEntityHash.constBegin(), itEnd = termVariableExpressionNewEntityHash.constEnd(); it != itEnd; ++it) {
560 freshEntityUseVariableExpressionHash.insert(it.value(), it.key());
561 }
562 expressionMapper->useEntitiesVariableExpressionMapping(freshEntityUseVariableExpressionHash, triplesData);
563 COntologyTriplesData ontTripData;
564 ontTripData.addTriplesData(triplesData);
565 expressionMapper->mapTriples(mOntology, &ontTripData);
566 axList = expressionMapper->takeQueryingCollectedAxiomExpressions();
567
568 return axList;
569 }
570
571 }; // end namespace Parser
572
573 }; // end namespace Konclude
574
575 #endif // KONCLUDE_REDLAND_INTEGRATION