Debian Codegraph @

Source/Reasoner/Generator/CConcreteOntologyRedlandTriplesDataExpressionMapper.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 "CConcreteOntologyRedlandTriplesDataExpressionMapper.h"
23
24
25 namespace Konclude {
26
27 namespace Reasoner {
28
29 namespace Generator {
30
31
32 int CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData::nextId = 0;
33
34
35 CConcreteOntologyRedlandTriplesDataExpressionMapper::CConcreteOntologyRedlandTriplesDataExpressionMapper(COntologyBuilder* ontologyBuilder) : CConcreteOntologyTriplesExpressionMapper(ontologyBuilder) {
36
37 mConfSuccessorRetrieval = true;
38 }
39
40 CConcreteOntologyRedlandTriplesDataExpressionMapper::~CConcreteOntologyRedlandTriplesDataExpressionMapper() {
41 }
42
43
44 bool CConcreteOntologyRedlandTriplesDataExpressionMapper::mapTriples(CConcreteOntology* updateConcreteOntology, COntologyTriplesData* ontologyTripleData) {
45
46 bool newTriplesMapped = false;
47 CTriplesData* tripleData = ontologyTripleData->getLatestTriplesData(true);
48 if (tripleData) {
49 CRedlandStoredTriplesData* redlandTriplesData = dynamic_cast<CRedlandStoredTriplesData*>(tripleData);
50
51 librdf_model* model = redlandTriplesData->getRedlandIndexedModel();
52 librdf_statement *partial_statement = librdf_new_statement(redlandTriplesData->getRedlandWorld());
53
54 librdf_stream* stream = librdf_model_find_statements(model, partial_statement);
55 if (!stream) {
56 return false;
57 } else {
58 newTriplesMapped = true;
59
60 //unsigned char* modelString = librdf_model_to_string(redlandTriplesData->getRedlandIndexedModel(), nullptr, "turtle", nullptr, nullptr);
61 //QFile file("temp.ttl");
62 //file.open(QIODevice::WriteOnly);
63 //file.write((const char*)modelString);
64
65
66 initTripleDataProcessing(redlandTriplesData);
67
68 cint64 count = 0;
69 getOWLClassInstanceNodesStream()->forEach([&](librdf_node* node) {
70 count++;
71 });
72
73
74 loadExistingEntities(updateConcreteOntology->getBuildData(), redlandTriplesData);
75 buildDeclarations();
76
77 buildObjectPropertyExpressions();
78 buildDataRangeExpressions();
79 buildClassExpressions();
80
81 buildClassBasedAxioms();
82 buildObjectPropertyBasedAxioms();
83 buildDataPropertyBasedAxioms();
84 buildDatatypeBasedAxioms();
85
86 buildSeparateNodeBasedAxioms();
87
88 buildComplexABoxAxioms();
89
90 if (mConfExtractSimpleABoxAssertions) {
91 buildSimpleABoxAxioms();
92 }
93
94 // do clean up
95 //clearTripleDataProcessing();
96
97 }
98 }
99
100 return newTriplesMapped;
101 }
102
103
104
105 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::handleParsedOntologyAxiomExpression(CAxiomExpression* axiomExpression) {
106 mOntologyBuilder->tellOntologyAxiom(axiomExpression);
107 return this;
108 }
109
110
111
112 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildSimpleABoxAxioms() {
113
114 QList<CAxiomExpression*> axiomExpressionList;
115
116 for (CRedlandNodeProcessingData* nextProcessingData : mClassNodeHandlingList) {
117 if (nextProcessingData->mExpression) {
118 if (librdf_node_is_resource(nextProcessingData->mRedlandNode)) {
119 QList<CRedlandNodeProcessingData*>* processingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, nextProcessingData->mRedlandNode, mPartialFilteringStatementForOWLAllRDFTypePredecessors)), 0), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* {
120 return createNamedIndividualProcessingData(node);
121 });
122 if (processingDataList && !processingDataList->isEmpty()) {
123 for (CRedlandNodeProcessingData* processingData : *processingDataList) {
124 CAxiomExpression* axiomExpression = mOntologyBuilder->getClassAssertion(processingData->mExpression, nextProcessingData->mExpression);
125 if (axiomExpression) {
126 axiomExpressionList.append(axiomExpression);
127 }
128 }
129 }
130 if (processingDataList) {
131 delete processingDataList;
132 }
133 }
134 }
135 }
136
137
138 for (CRedlandNodeProcessingData* nextProcessingData : mObjectPropertyNodeHandlingList) {
139 if (nextProcessingData->mExpression) {
140 collectBetweenIndividualsBasedAxiomExpression(nextProcessingData, [&](const QList<CBuildExpression*>& expressionList)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyAssertion(expressionList); }, mPartialFilteringStatementForOWLPropertyAssertions, axiomExpressionList);
141 }
142 }
143
144 collectBetweenIndividualsBasedAxiomExpression([&](const QList<CBuildExpression*>& expressionList)->CAxiomExpression* { return mOntologyBuilder->getDifferentIndividuals(expressionList); }, mPartialFilteringStatementForOWLDifferentIndividuals, axiomExpressionList);
145 collectBetweenIndividualsBasedAxiomExpression([&](const QList<CBuildExpression*>& expressionList)->CAxiomExpression* { return mOntologyBuilder->getSameIndividual(expressionList); }, mPartialFilteringStatementForOWLSameIndividuals, axiomExpressionList);
146
147
148 for (CRedlandNodeProcessingData* nextProcessingData : mDataPropertyNodeHandlingList) {
149 if (nextProcessingData->mExpression) {
150
151 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nextProcessingData->mRedlandNode, nullptr, mPartialFilteringStatementForOWLPropertyAssertions))->forEach([&](librdf_statement* statement) {
152 librdf_node* subject = librdf_statement_get_subject(statement);
153 librdf_node* object = librdf_statement_get_object(statement);
154
155 if (librdf_node_is_literal(object)) {
156 QList<CRedlandNodeProcessingData*>* processingDataList = nullptr;
157 // TODO: individuals may be anonymous individuals
158 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
159 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(object, mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); }, processingDataList);
160 if (processingDataList) {
161 processingDataList->append(nextProcessingData);
162 QList<CBuildExpression*> expressionList;
163 collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
164 CAxiomExpression* axiomExpression = mOntologyBuilder->getDataPropertyAssertion(expressionList);
165 if (axiomExpression) {
166 axiomExpressionList.append(axiomExpression);
167 }
168 delete processingDataList;
169 }
170 }
171 }));
172
173 }
174 }
175
176 for (CAxiomExpression* axiomExpression : axiomExpressionList) {
177 handleParsedOntologyAxiomExpression(axiomExpression);
178 }
179
180 return this;
181 }
182
183
184
185
186 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBetweenIndividualsBasedAxiomExpression(CRedlandNodeProcessingData* nextProcessingData, function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunc, librdf_statement* filteringStatement, QList<CAxiomExpression*>& axiomList) {
187 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nextProcessingData->mRedlandNode, nullptr, filteringStatement))->forEach([&](librdf_statement* statement) {
188 librdf_node* subject = librdf_statement_get_subject(statement);
189 librdf_node* object = librdf_statement_get_object(statement);
190
191 QList<CRedlandNodeProcessingData*>* processingDataList = nullptr;
192 // TODO: individuals may be anonymous individuals
193 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
194 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(object, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
195 if (processingDataList) {
196 processingDataList->append(nextProcessingData);
197 QList<CBuildExpression*> expressionList;
198 collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
199 CAxiomExpression* axiomExpression = buildFunc(expressionList);
200 if (axiomExpression) {
201 axiomList.append(axiomExpression);
202 }
203 delete processingDataList;
204 }
205 }));
206
207 return this;
208 }
209
210
211
212 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBetweenIndividualsBasedAxiomExpression(function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunc, librdf_statement* filteringStatement, QList<CAxiomExpression*>& axiomList) {
213 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, nullptr, filteringStatement))->forEach([&](librdf_statement* statement) {
214 librdf_node* subject = librdf_statement_get_subject(statement);
215 librdf_node* object = librdf_statement_get_object(statement);
216
217 QList<CRedlandNodeProcessingData*>* processingDataList = nullptr;
218 // TODO: individuals may be anonymous individuals
219 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
220 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(object, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
221 if (processingDataList) {
222 QList<CBuildExpression*> expressionList;
223 collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
224 CAxiomExpression* axiomExpression = buildFunc(expressionList);
225 if (axiomExpression) {
226 axiomList.append(axiomExpression);
227 }
228 delete processingDataList;
229 }
230 }));
231
232 return this;
233 }
234
235
236
237
238
239
240
241 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildComplexABoxAxioms() {
242
243 QList<CAxiomExpression*> axiomExpressionList;
244
245 for (CRedlandNodeProcessingData* nextProcessingData : mClassNodeHandlingList) {
246 if (nextProcessingData->mExpression) {
247 if (librdf_node_is_blank(nextProcessingData->mRedlandNode)) {
248 QList<CRedlandNodeProcessingData*>* processingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, nextProcessingData->mRedlandNode, mPartialFilteringStatementForOWLAllRDFTypePredecessors)), 0), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* {
249 return createNamedIndividualProcessingData(node);
250 });
251 if (processingDataList && !processingDataList->isEmpty()) {
252 for (CRedlandNodeProcessingData* processingData : *processingDataList) {
253 QList<CBuildExpression*> expressionList;
254 expressionList.append(nextProcessingData->mExpression);
255 expressionList.append(processingData->mExpression);
256 CAxiomExpression* axiomExpression = mOntologyBuilder->getClassAssertion(expressionList);
257 if (axiomExpression) {
258 axiomExpressionList.append(axiomExpression);
259 }
260 delete processingDataList;
261 }
262 }
263
264 }
265 }
266 }
267 // complex data range assertions
268 for (CRedlandNodeProcessingData* nextProcessingData : mDataPropertyNodeHandlingList) {
269 if (nextProcessingData->mExpression) {
270
271 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nextProcessingData->mRedlandNode, nullptr, mPartialFilteringStatementForOWLPropertyAssertions))->forEach([&](librdf_statement* statement) {
272 librdf_node* subject = librdf_statement_get_subject(statement);
273 librdf_node* object = librdf_statement_get_object(statement);
274
275 if (!librdf_node_is_literal(object)) {
276 QList<CRedlandNodeProcessingData*>* processingDataList = nullptr;
277 // TODO: individuals may be anonymous individuals
278 processingDataList = getNodeProcessingDataListFromNodeWithNewHandling(subject, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingDataList);
279 processingDataList = getNodeProcessingDataListFromNode(object, mDatatypeNodeIdentifierDataHash, processingDataList);
280 if (processingDataList) {
281 processingDataList->append(nextProcessingData);
282 QList<CBuildExpression*> expressionList;
283 collectBuildExpressionsFromProcessingDataList(*processingDataList, expressionList);
284 CAxiomExpression* axiomExpression = mOntologyBuilder->getDataPropertyAssertion(expressionList);
285 if (axiomExpression) {
286 axiomExpressionList.append(axiomExpression);
287 }
288 delete processingDataList;
289 }
290 }
291 }));
292
293 }
294 }
295
296
297 for (CAxiomExpression* axiomExpression : axiomExpressionList) {
298 handleParsedOntologyAxiomExpression(axiomExpression);
299 }
300
301 return this;
302 }
303
304
305
306
307
308
309 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::loadExistingEntities(COntologyBuildData* buildData, CRedlandStoredTriplesData* redlandTriplesData) {
310 CBUILDHASH<CStringRefStringHasher, CClassExpression*>* classExpHash = buildData->getClassEntityBuildHash();
311 for (CBUILDHASH<CStringRefStringHasher, CClassExpression*>::const_iterator it = classExpHash->constBegin(), itEnd = classExpHash->constEnd(); it != itEnd; ++it) {
312 CClassExpression* classExp = it.value();
313 loadExistingEntity(classExp, classExp->getName(), redlandTriplesData->getRedlandWorld(), mClassNodeIdentifierDataHash, mClassNodeHandlingList);
314 }
315 CBUILDHASH<CStringRefStringHasher, CObjectPropertyExpression*>* objPropExpHash = buildData->getObjectPropertyEntityBuildHash();
316 for (CBUILDHASH<CStringRefStringHasher, CObjectPropertyExpression*>::const_iterator it = objPropExpHash->constBegin(), itEnd = objPropExpHash->constEnd(); it != itEnd; ++it) {
317 CObjectPropertyExpression* objPropExp = it.value();
318 loadExistingEntity(objPropExp, objPropExp->getName(), redlandTriplesData->getRedlandWorld(), mObjectPropertyNodeIdentifierDataHash, mObjectPropertyNodeHandlingList);
319 }
320 CBUILDHASH<CStringRefStringHasher, CDataPropertyExpression*>* dataPropExpHash = buildData->getDataPropertyEntityBuildHash();
321 for (CBUILDHASH<CStringRefStringHasher, CDataPropertyExpression*>::const_iterator it = dataPropExpHash->constBegin(), itEnd = dataPropExpHash->constEnd(); it != itEnd; ++it) {
322 CDataPropertyExpression* dataPropExp = it.value();
323 loadExistingEntity(dataPropExp, dataPropExp->getName(), redlandTriplesData->getRedlandWorld(), mDataPropertyNodeIdentifierDataHash, mDataPropertyNodeHandlingList);
324 }
325 return this;
326 }
327
328
329
330
331
332
333
334 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::loadExistingEntity(CBuildExpression* expression, const QString& entityUri, librdf_world* world, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>& nodeHandlingList) {
335 QByteArray uriData = entityUri.toUtf8();
336 librdf_uri* uri = librdf_new_uri(world, (const unsigned char*)uriData.constData());
337 librdf_node* classNode = librdf_new_node_from_uri(world, uri);
338
339 CRedlandNodeProcessingData*& processingData = nodeIdentifierDataHash[CRedlandNodeHasher(classNode)];
340 if (!processingData) {
341 processingData = new CRedlandNodeProcessingData(classNode, expression);
342 nodeHandlingList.append(processingData);
343 processingData->mExpression = expression;
344 }
345 return this;
346 }
347
348
349
350
351 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDeclarations() {
352
353
354 releaseRedlandNodeStreamWrapper(getOWLClassInstanceNodesStream()->forEach([&](librdf_node* node) {
355 handleDeclaration(node, [&](const QString &uri)->CBuildExpression* {
356 return mOntologyBuilder->getClass(uri);
357 }, mClassNodeIdentifierDataHash, mClassNodeHandlingList);
358 }));
359
360 releaseRedlandNodeStreamWrapper(getOWLRestrictionInstanceNodesStream()->forEach([&](librdf_node* node) {
361 handleClassExpressionRestriction(node);
362 }));
363
364 releaseRedlandNodeStreamWrapper(getOWLObjectPropertyInstanceNodesStream()->forEach([&](librdf_node* node) {
365 handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getObjectProberty(uri); }, mObjectPropertyNodeIdentifierDataHash, mObjectPropertyNodeHandlingList);
366 }));
367
368 releaseRedlandNodeStreamWrapper(getOWLDatatypePropertyInstanceNodesStream()->forEach([&](librdf_node* node) {
369 handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getDataProberty(uri); }, mDataPropertyNodeIdentifierDataHash, mDataPropertyNodeHandlingList);
370 }));
371
372 releaseRedlandNodeStreamWrapper(getRDFSDatatypeInstanceNodesStream()->forEach([&](librdf_node* node) {
373 handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getDatatype(uri); }, mDatatypeNodeIdentifierDataHash, mDatatypeNodeHandlingList);
374 }));
375
376 if (mConfExtractSimpleABoxAssertions) {
377 releaseRedlandNodeStreamWrapper(getOWLNamedIndividualInstanceNodesStream()->forEach([&](librdf_node* node) {
378 handleDeclaration(node, [&](const QString &uri)->CBuildExpression* { return mOntologyBuilder->getNamedIndividual(uri); }, mNamedIndividualNodeIdentifierDataHash, mNamedIndividualNodeHandlingList);
379 }));
380 }
381 return this;
382 }
383
384
385
386
387 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildSeparateNodeBasedAxioms() {
388 QList<CAxiomExpression*> axiomExpressionList;
389 releaseRedlandNodeStreamWrapper(getOWLAllDisjointClassesInstanceNodesStream()->forEach([&](librdf_node* node) {
390 bool processed = false;
391 if (!processed) {
392 buildAxiomExpressionForMemberRDFNodeList(node, mPartialFilteringStatementForOWLMembers, mClassNodeIdentifierDataHash, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* {
393 CAxiomExpression* axiomExp = mOntologyBuilder->getDisjointClasses(expressions);
394 processed |= axiomExp != nullptr;
395 return axiomExp;
396 }, axiomExpressionList);
397 }
398 }));
399
400 releaseRedlandNodeStreamWrapper(getOWLAllDisjointPropertiesInstanceNodesStream()->forEach([&](librdf_node* node) {
401 bool processed = false;
402 if (!processed) {
403 buildAxiomExpressionForObjectORDataPropertyMemberRDFNodeList(node, mPartialFilteringStatementForOWLMembers, [&](const QList<CBuildExpression*>& expressions, bool hasDataProperties, bool hasObjectProperties)->CAxiomExpression* {
404 CAxiomExpression* axiomExp = nullptr;
405 if (!hasDataProperties && hasObjectProperties) {
406 axiomExp = mOntologyBuilder->getDisjointObjectProperties(expressions);
407 } else if (hasDataProperties && !hasObjectProperties) {
408 axiomExp = mOntologyBuilder->getDisjointDataProperties(expressions);
409 }
410 processed |= axiomExp != nullptr;
411 return axiomExp;
412 }, axiomExpressionList);
413 }
414 }));
415
416 releaseRedlandNodeStreamWrapper(getOWLAllDifferentInstanceNodesStream()->forEach([&](librdf_node* node) {
417 bool processed = false;
418 if (!processed) {
419 buildAxiomExpressionForMemberRDFNodeListWithNewHandling(node, mPartialFilteringStatementForOWLMembers, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* {
420 if (expressions.size() > 0) {
421 CAxiomExpression* axiomExp = mOntologyBuilder->getDifferentIndividuals(expressions);
422 processed |= axiomExp != nullptr;
423 return axiomExp;
424 }
425 return nullptr;
426 }, axiomExpressionList);
427 }
428 if (!processed) {
429 buildAxiomExpressionForMemberRDFNodeListWithNewHandling(node, mPartialFilteringStatementForOWLDistinctMembers, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* {
430 if (expressions.size() > 0) {
431 CAxiomExpression* axiomExp = mOntologyBuilder->getDifferentIndividuals(expressions);
432 processed |= axiomExp != nullptr;
433 return axiomExp;
434 }
435 return nullptr;
436 }, axiomExpressionList);
437 }
438 }));
439
440 releaseRedlandNodeStreamWrapper(getOWLAllNegativePropertyAssertionInstanceNodesStream()->forEach([&](librdf_node* node) {
441 bool processed = false;
442 if (!processed) {
443 QList<CRedlandNodeProcessingData*>* sourcendividualProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLSourceIndividualSuccessors)), 2), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
444 if (sourcendividualProcessingDataList) {
445
446 if (!processed) {
447 QList<CRedlandNodeProcessingData*>* targetValueLiteralProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLTargetValueSuccessors)), 2), mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); });
448 if (targetValueLiteralProcessingDataList) {
449
450 QList<CRedlandNodeProcessingData*>* propertyProcessingDataList = getNodeProcessingDataListFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLAssertionPropertySuccessors)), 2), mObjectPropertyNodeIdentifierDataHash);
451 if (propertyProcessingDataList) {
452 QList<CBuildExpression*> expressionList;
453 collectBuildExpressionsFromProcessingDataList(*sourcendividualProcessingDataList, expressionList);
454 collectBuildExpressionsFromProcessingDataList(*targetValueLiteralProcessingDataList, expressionList);
455 collectBuildExpressionsFromProcessingDataList(*propertyProcessingDataList, expressionList);
456 CAxiomExpression* axiomExpression = mOntologyBuilder->getNegativeObjectPropertyAssertion(expressionList);
457 if (axiomExpression) {
458 processed = true;
459 axiomExpressionList.append(axiomExpression);
460 }
461 delete propertyProcessingDataList;
462 }
463
464 delete targetValueLiteralProcessingDataList;
465 }
466 }
467
468
469 if (!processed) {
470 QList<CRedlandNodeProcessingData*>* targetIndividualProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLTargetIndividualSuccessors)), 2), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
471 if (targetIndividualProcessingDataList) {
472 QList<CRedlandNodeProcessingData*>* propertyProcessingDataList = getNodeProcessingDataListFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, mPartialFilteringStatementForOWLAssertionPropertySuccessors)), 2), mDataPropertyNodeIdentifierDataHash);
473 if (propertyProcessingDataList) {
474 QList<CBuildExpression*> expressionList;
475 collectBuildExpressionsFromProcessingDataList(*sourcendividualProcessingDataList, expressionList);
476 collectBuildExpressionsFromProcessingDataList(*targetIndividualProcessingDataList, expressionList);
477 collectBuildExpressionsFromProcessingDataList(*propertyProcessingDataList, expressionList);
478 CAxiomExpression* axiomExpression = mOntologyBuilder->getNegativeDataPropertyAssertion(expressionList);
479 if (axiomExpression) {
480 processed = true;
481 axiomExpressionList.append(axiomExpression);
482 }
483 delete propertyProcessingDataList;
484 }
485
486 delete targetIndividualProcessingDataList;
487 }
488 }
489 delete sourcendividualProcessingDataList;
490 }
491 }
492
493 }));
494 for (CAxiomExpression* axiomExpression : axiomExpressionList) {
495 handleParsedOntologyAxiomExpression(axiomExpression);
496 }
497 return this;
498 }
499
500
501
502 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromProcessingDataList(QList<CRedlandNodeProcessingData*>& processingDataList, QList<CBuildExpression*>& expressionList) {
503 for (CRedlandNodeProcessingData* processingData : processingDataList) {
504 if (processingData->mExpression) {
505 expressionList.append(processingData->mExpression);
506 }
507 }
508 return this;
509 }
510
511
512
513 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionForMemberRDFNodeList(librdf_node* node, librdf_statement* partialFilteringStatementForOWLMembers, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunction, QList<CAxiomExpression*>& axiomExpressions) {
514 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, partialFilteringStatementForOWLMembers))->forEach([&](librdf_statement* statement) {
515 librdf_node* object = librdf_statement_get_object(statement);
516
517 QList<CBuildExpression*> expressionList;
518 buildAxiomExpressionFromRDFNodeList(object, nodeIdentifierDataHash, expressionList, buildFunction, axiomExpressions);
519
520 }));
521 return this;
522 }
523
524
525
526
527 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionForMemberRDFNodeListWithNewHandling(librdf_node* node, librdf_statement* partialFilteringStatementForOWLMembers, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunction, QList<CAxiomExpression*>& axiomExpressions) {
528 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, partialFilteringStatementForOWLMembers))->forEach([&](librdf_statement* statement) {
529 librdf_node* object = librdf_statement_get_object(statement);
530
531 QList<CBuildExpression*> expressionList;
532 buildAxiomExpressionFromRDFNodeListWithNewHandling(object, nodeIdentifierDataHash, newHandlingFunc, expressionList, buildFunction, axiomExpressions);
533
534 }));
535 return this;
536 }
537
538 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionForObjectORDataPropertyMemberRDFNodeList(librdf_node* node, librdf_statement* partialFilteringStatementForOWLMembers, function<CAxiomExpression*(const QList<CBuildExpression*>&, bool hasDataProperties, bool hasObjectProperties)> buildFunction, QList<CAxiomExpression*>& axiomExpressions) {
539 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, nullptr, nullptr, partialFilteringStatementForOWLMembers))->forEach([&](librdf_statement* statement) {
540 librdf_node* object = librdf_statement_get_object(statement);
541
542 bool dataPropertyNodeUsed = false;
543 bool objectPropertyNodeUsed = false;
544
545 QList<CBuildExpression*> expressionList;
546 QList<librdf_node*>* nodeList = nullptr;
547 nodeList = getOWLListElementNodesList(object, nodeList);
548 if (nodeList) {
549 for (librdf_node* listElementNode : *nodeList) {
550 CRedlandNodeHasher hasher(listElementNode);
551 CRedlandNodeProcessingData* processingData = mObjectPropertyNodeIdentifierDataHash.value(hasher);
552 if (!processingData) {
553 processingData = mDataPropertyNodeIdentifierDataHash.value(hasher);
554 if (processingData) {
555 dataPropertyNodeUsed = true;
556 }
557 } else {
558 objectPropertyNodeUsed = true;
559 }
560
561 if (processingData && processingData->mExpression) {
562 expressionList.append(processingData->mExpression);
563 }
564 }
565
566 CAxiomExpression* axiomExp = buildFunction(expressionList, dataPropertyNodeUsed, objectPropertyNodeUsed);
567 if (axiomExp) {
568 axiomExpressions.append(axiomExp);
569 }
570
571 delete nodeList;
572 }
573
574 }));
575 return this;
576 }
577
578
579
580
581
582
583
584 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDatatypeBasedAxioms() {
585 if (mConfSuccessorRetrieval) {
586 buildAxioms(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectDatatypeBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
587 } else {
588 buildAxioms(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectDatatypeBasedAxiomExpressions(processingData, axiomExpressions); });
589 }
590 return this;
591 }
592
593
594
595 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildClassBasedAxioms() {
596 if (mConfSuccessorRetrieval) {
597 buildAxioms(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectClassBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
598 } else {
599 buildAxioms(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectClassBasedAxiomExpressions(processingData, axiomExpressions); });
600 }
601 return this;
602 }
603
604
605
606 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildObjectPropertyBasedAxioms() {
607 if (mConfSuccessorRetrieval) {
608 buildAxioms(&mObjectPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectObjectPropertyBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
609 QList<CAxiomExpression*> axiomExpressions;
610 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval(axiomExpressions);
611 for (CAxiomExpression* axiomExpression : axiomExpressions) {
612 handleParsedOntologyAxiomExpression(axiomExpression);
613 }
614 } else {
615 buildAxioms(&mObjectPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectObjectPropertyBasedAxiomExpressions(processingData, axiomExpressions); });
616 }
617 return this;
618 }
619
620 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDataPropertyBasedAxioms() {
621 if (mConfSuccessorRetrieval) {
622 buildAxioms(&mDataPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectDataPropertyBasedAxiomExpressionsBySuccessorRetrieval(processingData, axiomExpressions); });
623 QList<CAxiomExpression*> axiomExpressions;
624 collectDataPropertyTypesAxiomExpressionsBySuccessorRetrieval(axiomExpressions);
625 for (CAxiomExpression* axiomExpression : axiomExpressions) {
626 handleParsedOntologyAxiomExpression(axiomExpression);
627 }
628
629 } else {
630 buildAxioms(&mDataPropertyNodeHandlingList, [&](CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) { collectDataPropertyBasedAxiomExpressions(processingData, axiomExpressions); });
631 }
632 return this;
633 }
634
635
636 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxioms(QList<CRedlandNodeProcessingData*>* nodeHandlingList, function<void(CRedlandNodeProcessingData*, QList<CAxiomExpression*>&)> dependenciesCollectionFunction) {
637
638 QList<CAxiomExpression*> axiomExpressionList;
639
640 for (CRedlandNodeProcessingData* nextProcessingData : *nodeHandlingList) {
641 if (nextProcessingData->mExpression) {
642 dependenciesCollectionFunction(nextProcessingData, axiomExpressionList);
643 }
644 }
645
646 for (CAxiomExpression* axiomExpression : axiomExpressionList) {
647 handleParsedOntologyAxiomExpression(axiomExpression);
648 }
649 return this;
650 }
651
652
653
654
655
656 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
657 if (processingData->mExpression) {
658
659 // TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
660 // create/use forEachAsLong/forEachLimited
661 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
662 librdf_node* predicate = librdf_statement_get_predicate(statement);
663 librdf_node* object = librdf_statement_get_object(statement);
664 cint64 index = mClassBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
665 if (index >= 0) {
666
667 QList<CBuildExpression*> expressionList;
668 expressionList.append(processingData->mExpression);
669
670 switch (index) {
671 case mOWLClassAxiomSubClassOfPredicateIndex:
672 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubClassOf(expressions); }, axiomExpressions);
673 break;
674 case mOWLClassAxiomEquvialentClassPredicateIndex:
675 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentClasses(expressions); }, axiomExpressions);
676 break;
677 case mOWLClassAxiomDisjointWithPredicateIndex:
678 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointClasses(expressions); }, axiomExpressions);
679 break;
680 case mOWLClassAxiomDisjointUnionOfPredicateIndex:
681 buildAxiomExpressionFromRDFNodeList(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointUnion(expressions); }, axiomExpressions);
682 break;
683 default:
684 break;
685 }
686
687 }
688 }));
689
690 }
691 return this;
692 }
693
694
695
696
697 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
698
699 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSSubClassOfSuccessors))->forEach([&](librdf_statement* statement) {
700 librdf_node* object = librdf_statement_get_object(statement);
701 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubClassOf(expressions); }, axiomExpressions);
702 }));
703
704 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLEquivalentClassesSuccessors))->forEach([&](librdf_statement* statement) {
705 librdf_node* object = librdf_statement_get_object(statement);
706 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentClasses(expressions); }, axiomExpressions);
707 }));
708
709 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLDisjointClassesSuccessors))->forEach([&](librdf_statement* statement) {
710 librdf_node* object = librdf_statement_get_object(statement);
711 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointClasses(expressions); }, axiomExpressions);
712 }));
713
714 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLDisjointUnionSuccessors))->forEach([&](librdf_statement* statement) {
715 librdf_node* object = librdf_statement_get_object(statement);
716 buildAxiomExpressionFromRDFNodeList(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointUnion(expressions); }, axiomExpressions);
717 }));
718
719 return this;
720 }
721
722
723
724
725
726 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDatatypeBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
727 if (processingData->mExpression) {
728
729 // TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
730 // create/use forEachAsLong/forEachLimited
731 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
732 librdf_node* predicate = librdf_statement_get_predicate(statement);
733 librdf_node* object = librdf_statement_get_object(statement);
734 cint64 index = mDatatypeBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
735 if (index >= 0) {
736
737 QList<CBuildExpression*> expressionList;
738 expressionList.append(processingData->mExpression);
739
740 switch (index) {
741 case mOWLClassAxiomEquvialentClassPredicateIndex:
742 // TODO: build datatype definition axiom (may not yet available)
743 break;
744 default:
745 break;
746 }
747
748 }
749 }));
750
751 }
752 return this;
753 }
754
755
756 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDatatypeBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
757 // TODO: build datatype definition axiom (may not yet available)
758 return this;
759 }
760
761
762
763 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
764 if (processingData->mExpression) {
765
766 // TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
767 // create/use forEachAsLong/forEachLimited
768 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
769 librdf_node* predicate = librdf_statement_get_predicate(statement);
770 librdf_node* object = librdf_statement_get_object(statement);
771 cint64 predicateIndex = mPropertyBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
772 if (predicateIndex >= 0) {
773
774 QList<CBuildExpression*> expressionList;
775 expressionList.append(processingData->mExpression);
776
777 switch (predicateIndex) {
778 case mOWLPredicateBasedAxiomSubPropertyOfPredicateIndex:
779 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubObjectPropertyOf(expressions); }, axiomExpressions);
780 break;
781 case mOWLPredicateBasedAxiomPropertyChainAxiomPredicateIndex:
782 buildAxiomExpressionFromRDFNodeList(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* {
783 QList<CBuildExpression*> resortedExpressionList(expressions);
784 if (resortedExpressionList.size() > 0) {
785 CBuildExpression* superProperty = resortedExpressionList.takeFirst();
786 resortedExpressionList.append(superProperty);
787 }
788 return mOntologyBuilder->getSubObjectPropertyOf(resortedExpressionList);
789 }, axiomExpressions);
790 break;
791 case mOWLPredicateBasedAxiomEquivalentPropertyPredicateIndex:
792 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentObjectProperties(expressions); }, axiomExpressions);
793 break;
794 case mOWLPredicateBasedAxiomPropertyDisjointWithPredicateIndex:
795 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointObjectProperties(expressions); }, axiomExpressions);
796 break;
797 case mOWLPredicateBasedAxiomDomainPredicateIndex:
798 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyDomainExpression(expressions); }, axiomExpressions);
799 break;
800 case mOWLPredicateBasedAxiomRangePredicateIndex:
801 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyRangeExpression(expressions); }, axiomExpressions);
802 break;
803 case mOWLPredicateBasedAxiomInverseOfPredicateIndex:
804 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getInverseObjectProperties(expressions); }, axiomExpressions);
805 break;
806 case mRDFPredicateBasedAxiomTypeOfPredicateIndex:
807 cint64 objectIndex = mPropertyBasedAxiomObjectIndexHash.value(CRedlandNodeHasher(object), -1);
808 if (objectIndex >= 0) {
809 switch (objectIndex) {
810 case mOWLPredicateBasedAxiomTypeFunctionalPropertyObjectIndex:
811 axiomExpressions.append(mOntologyBuilder->getFunctionalObjectProperty(processingData->mExpression));
812 break;
813 case mOWLPredicateBasedAxiomTypeInverseFunctionalPropertyObjectIndex:
814 axiomExpressions.append(mOntologyBuilder->getInverseFunctionalObjectProperty(processingData->mExpression));
815 break;
816 case mOWLPredicateBasedAxiomTypeReflexivePropertyObjectIndex:
817 axiomExpressions.append(mOntologyBuilder->getReflexiveObjectProperty(processingData->mExpression));
818 break;
819 case mOWLPredicateBasedAxiomTypeIrreflexivePropertyObjectIndex:
820 axiomExpressions.append(mOntologyBuilder->getIrreflexiveObjectProperty(processingData->mExpression));
821 break;
822 case mOWLPredicateBasedAxiomTypeSymmetricPropertyObjectIndex:
823 axiomExpressions.append(mOntologyBuilder->getSymmetricObjectProperty(processingData->mExpression));
824 break;
825 case mOWLPredicateBasedAxiomTypeAsymmetricPropertyObjectIndex:
826 axiomExpressions.append(mOntologyBuilder->getAsymmetricObjectProperty(processingData->mExpression));
827 break;
828 case mOWLPredicateBasedAxiomTypeTransitivePropertyObjectIndex:
829 axiomExpressions.append(mOntologyBuilder->getTransetiveObjectProperty(processingData->mExpression));
830 break;
831 default:
832 break;
833 }
834 }
835 break;
836 }
837
838 }
839 }));
840
841 }
842 return this;
843 }
844
845
846
847
848
849 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataPropertyTypesAxiomExpressionsBySuccessorRetrieval(QList<CAxiomExpression*>& axiomExpressions) {
850 releaseRedlandNodeStreamWrapper(getOWLFunctionalPropertyInstanceNodesStream()->forEach([&](librdf_node* node) {
851 QList<CRedlandNodeProcessingData*>* dataProcessingDataList = getNodeProcessingDataListFromNode(node, mDataPropertyNodeIdentifierDataHash);
852 if (dataProcessingDataList) {
853 for (CRedlandNodeProcessingData* processingData : *dataProcessingDataList) {
854 axiomExpressions.append(mOntologyBuilder->getFunctionalDataProperty(QList<CBuildExpression*>() << processingData->mExpression));
855 }
856 delete dataProcessingDataList;
857 }
858 }));
859 return this;
860 }
861
862
863 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval(QList<CAxiomExpression*>& axiomExpressions) {
864
865 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLFunctionalPropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getFunctionalObjectProperty(expressions); }, axiomExpressions);
866 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLInverseFunctionalPropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getInverseFunctionalObjectProperty(expressions); }, axiomExpressions);
867 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLReflexivePropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getReflexiveObjectProperty(expressions); }, axiomExpressions);
868 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLIrreflexivePropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getIrreflexiveObjectProperty(expressions); }, axiomExpressions);
869 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLSymmetricPropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSymmetricObjectProperty(expressions); }, axiomExpressions);
870 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLAsymmetricPropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getAsymmetricObjectProperty(expressions); }, axiomExpressions);
871 collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval([&]()->CRedlandNodeStream* { return getOWLTransetivePropertyInstanceNodesStream(); }, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getTransetiveObjectProperty(expressions); }, axiomExpressions);
872
873 return this;
874 }
875
876
877 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyTypesAxiomExpressionsBySuccessorRetrieval(function<CRedlandNodeStream*()> nodeStreamFunc, function<CAxiomExpression*(const QList<CBuildExpression*>& expressions)> buildFunc, QList<CAxiomExpression*>& axiomExpressions) {
878 releaseRedlandNodeStreamWrapper(nodeStreamFunc()->forEach([&](librdf_node* node) {
879 QList<CRedlandNodeProcessingData*>* objectProcessingDataList = getNodeProcessingDataListFromNode(node, mObjectPropertyNodeIdentifierDataHash);
880 if (objectProcessingDataList) {
881 for (CRedlandNodeProcessingData* processingData : *objectProcessingDataList) {
882 axiomExpressions.append(buildFunc(QList<CBuildExpression*>() << processingData->mExpression));
883 }
884 delete objectProcessingDataList;
885 }
886 }));
887 return this;
888 }
889
890
891
892
893
894
895 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectObjectPropertyBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
896 if (processingData->mExpression) {
897
898 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSSubPropertySuccessors))->forEach([&](librdf_statement* statement) {
899 librdf_node* object = librdf_statement_get_object(statement);
900 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubObjectPropertyOf(expressions); }, axiomExpressions);
901 }));
902
903 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyChainAxiomSuccessors))->forEach([&](librdf_statement* statement) {
904 librdf_node* object = librdf_statement_get_object(statement);
905 buildAxiomExpressionFromRDFNodeList(object, mObjectPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* {
906 QList<CBuildExpression*> resortedExpressionList(expressions);
907 if (!resortedExpressionList.isEmpty()) {
908 CBuildExpression* superProperty = resortedExpressionList.takeFirst();
909 resortedExpressionList.append(superProperty);
910 }
911 return mOntologyBuilder->getSubObjectPropertyOf(resortedExpressionList);
912 }, axiomExpressions);
913 }));
914
915
916 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLEquivalentPropertySuccessors))->forEach([&](librdf_statement* statement) {
917 librdf_node* object = librdf_statement_get_object(statement);
918 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentObjectProperties(expressions); }, axiomExpressions);
919 }));
920
921
922 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyDisjointWithSuccessors))->forEach([&](librdf_statement* statement) {
923 librdf_node* object = librdf_statement_get_object(statement);
924 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointObjectProperties(expressions); }, axiomExpressions);
925 }));
926
927
928 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSDomainSuccessors))->forEach([&](librdf_statement* statement) {
929 librdf_node* object = librdf_statement_get_object(statement);
930 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyDomainExpression(expressions); }, axiomExpressions);
931 }));
932
933
934 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSRangeSuccessors))->forEach([&](librdf_statement* statement) {
935 librdf_node* object = librdf_statement_get_object(statement);
936 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getObjectPropertyRangeExpression(expressions); }, axiomExpressions);
937 }));
938
939
940 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLInverseOfSuccessors))->forEach([&](librdf_statement* statement) {
941 librdf_node* object = librdf_statement_get_object(statement);
942 buildAxiomExpressionFromNode(object, mObjectPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getInverseObjectProperties(expressions); }, axiomExpressions);
943 }));
944 }
945 return this;
946 }
947
948
949
950
951 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataPropertyBasedAxiomExpressions(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
952 if (processingData->mExpression) {
953
954 // TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
955 // create/use forEachAsLong/forEachLimited
956 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms))->forEach([&](librdf_statement* statement) {
957 librdf_node* predicate = librdf_statement_get_predicate(statement);
958 librdf_node* object = librdf_statement_get_object(statement);
959 cint64 predicateIndex = mPropertyBasedAxiomPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
960 if (predicateIndex >= 0) {
961
962 QList<CBuildExpression*> expressionList;
963 expressionList.append(processingData->mExpression);
964
965 switch (predicateIndex) {
966 case mOWLPredicateBasedAxiomSubPropertyOfPredicateIndex:
967 buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubDataPropertyOf(expressions); }, axiomExpressions);
968 break;
969 case mOWLPredicateBasedAxiomEquivalentPropertyPredicateIndex:
970 buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentDataProperties(expressions); }, axiomExpressions);
971 break;
972 case mOWLPredicateBasedAxiomPropertyDisjointWithPredicateIndex:
973 buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointDataProperties(expressions); }, axiomExpressions);
974 break;
975 case mOWLPredicateBasedAxiomDomainPredicateIndex:
976 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDataPropertyDomainExpression(expressions); }, axiomExpressions);
977 break;
978 case mOWLPredicateBasedAxiomRangePredicateIndex:
979 buildAxiomExpressionFromNode(object, mDatatypeNodeIdentifierDataHash, expressionList, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDataPropertyRangeExpression(expressions); }, axiomExpressions);
980 break;
981 case mRDFPredicateBasedAxiomTypeOfPredicateIndex:
982 cint64 objectIndex = mPropertyBasedAxiomObjectIndexHash.value(CRedlandNodeHasher(object), -1);
983 if (objectIndex >= 0) {
984 switch (objectIndex) {
985 case mOWLPredicateBasedAxiomTypeFunctionalPropertyObjectIndex:
986 axiomExpressions.append(mOntologyBuilder->getFunctionalDataProperty(processingData->mExpression));
987 break;
988 }
989 }
990 break;
991 }
992
993 }
994 }));
995
996 }
997 return this;
998 }
999
1000
1001
1002
1003
1004
1005 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataPropertyBasedAxiomExpressionsBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, QList<CAxiomExpression*>& axiomExpressions) {
1006 if (processingData->mExpression) {
1007
1008 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSSubPropertySuccessors))->forEach([&](librdf_statement* statement) {
1009 librdf_node* object = librdf_statement_get_object(statement);
1010 buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getSubDataPropertyOf(expressions); }, axiomExpressions);
1011 }));
1012
1013
1014 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLEquivalentPropertySuccessors))->forEach([&](librdf_statement* statement) {
1015 librdf_node* object = librdf_statement_get_object(statement);
1016 buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getEquivalentDataProperties(expressions); }, axiomExpressions);
1017 }));
1018
1019
1020 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyDisjointWithSuccessors))->forEach([&](librdf_statement* statement) {
1021 librdf_node* object = librdf_statement_get_object(statement);
1022 buildAxiomExpressionFromNode(object, mDataPropertyNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDisjointDataProperties(expressions); }, axiomExpressions);
1023 }));
1024
1025
1026 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSDomainSuccessors))->forEach([&](librdf_statement* statement) {
1027 librdf_node* object = librdf_statement_get_object(statement);
1028 buildAxiomExpressionFromNode(object, mClassNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* { return mOntologyBuilder->getDataPropertyDomainExpression(expressions); }, axiomExpressions);
1029 }));
1030
1031
1032 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForRDFSRangeSuccessors))->forEach([&](librdf_statement* statement) {
1033 librdf_node* object = librdf_statement_get_object(statement);
1034 buildAxiomExpressionFromNode(object, mDatatypeNodeIdentifierDataHash, QList<CBuildExpression*>() << processingData->mExpression, [&](const QList<CBuildExpression*>& expressions)->CAxiomExpression* {
1035 return mOntologyBuilder->getDataPropertyRangeExpression(expressions);
1036 }, axiomExpressions);
1037 }));
1038
1039
1040 }
1041 return this;
1042 }
1043
1044
1045
1046
1047
1048
1049
1050 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionFromNode(librdf_node* node, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CBuildExpression*>& expressionList, function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunction, QList<CAxiomExpression*>& axiomExpressions) {
1051 cint64 prevSize = expressionList.size();
1052 collectBuildExpressionsFromNode(node, nodeIdentifierDataHash, expressionList);
1053 CAxiomExpression* axiomExpression = buildFunction(expressionList);
1054 if (axiomExpression) {
1055 axiomExpressions.append(axiomExpression);
1056 }
1057 while (expressionList.size() > prevSize) {
1058 expressionList.removeLast();
1059 }
1060 return this;
1061 }
1062
1063
1064
1065 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionFromRDFNodeList(librdf_node* listNode, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CBuildExpression*>& expressionList, function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunction, QList<CAxiomExpression*>& axiomExpressions) {
1066 cint64 prevSize = expressionList.size();
1067 collectBuildExpressionsFromRDFNodeList(listNode, nodeIdentifierDataHash, expressionList);
1068 CAxiomExpression* axiomExpression = buildFunction(expressionList);
1069 if (axiomExpression) {
1070 axiomExpressions.append(axiomExpression);
1071 }
1072 while (expressionList.size() > prevSize) {
1073 expressionList.removeLast();
1074 }
1075 return this;
1076 }
1077
1078
1079
1080
1081
1082 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildAxiomExpressionFromRDFNodeListWithNewHandling(librdf_node* listNode, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CBuildExpression*>& expressionList, function<CAxiomExpression*(const QList<CBuildExpression*>&)> buildFunction, QList<CAxiomExpression*>& axiomExpressions) {
1083 cint64 prevSize = expressionList.size();
1084 collectBuildExpressionsFromRDFNodeListWithNewHandling(listNode, nodeIdentifierDataHash, newHandlingFunc, expressionList);
1085 CAxiomExpression* axiomExpression = buildFunction(expressionList);
1086 if (axiomExpression) {
1087 axiomExpressions.append(axiomExpression);
1088 }
1089 while (expressionList.size() > prevSize) {
1090 expressionList.removeLast();
1091 }
1092 return this;
1093 }
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildObjectPropertyExpressions() {
1106 for (CRedlandNodeProcessingData* nextProcessingData : mObjectPropertyNodeHandlingList) {
1107
1108 nextProcessingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(getOWLObjectInverseOfPredecessorNodesStream(nextProcessingData->mRedlandNode), mObjectPropertyNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* {
1109 CRedlandNodeProcessingData* processingData = nullptr;
1110 CBuildExpression* expression = nullptr;
1111 if (librdf_node_is_blank(node)) {
1112 expression = mOntologyBuilder->getInverseObjectPropertyOf(nextProcessingData->mExpression);
1113 processingData = new CRedlandNodeProcessingData(node, expression);
1114 }
1115 return processingData;
1116 });
1117
1118 if (nextProcessingData->mDependendRedlandNodeProcessingDataList) {
1119 delete nextProcessingData->mDependendRedlandNodeProcessingDataList;
1120 nextProcessingData->mDependendRedlandNodeProcessingDataList = nullptr;
1121 }
1122
1123 }
1124 return this;
1125 }
1126
1127
1128
1129 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildDataRangeExpressions() {
1130 if (mConfSuccessorRetrieval) {
1131 buildExpressions(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectDataRangeExpressionDependenciesBySuccessorRetrieval(processingData); });
1132 } else {
1133 buildExpressions(&mDatatypeNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectDataRangeExpressionDependencies(processingData); });
1134 }
1135 return this;
1136 }
1137
1138 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildClassExpressions() {
1139 if (mConfSuccessorRetrieval) {
1140 buildExpressions(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectClassExpressionDependenciesBySuccessorRetrieval(processingData); });
1141 } else {
1142 buildExpressions(&mClassNodeHandlingList, [&](CRedlandNodeProcessingData* processingData) { collectClassExpressionDependencies(processingData); });
1143 }
1144 return this;
1145 }
1146
1147 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::buildExpressions(QList<CRedlandNodeProcessingData*>* nodeHandlingList, function<void(CRedlandNodeProcessingData*)> dependenciesCollectionFunction) {
1148
1149 QStack<CRedlandNodeProcessingData*> processingStack;
1150 QList<CBuildExpression*> dependentBuildExpressionList;
1151
1152 for (CRedlandNodeProcessingData* nextProcessingData : *nodeHandlingList) {
1153 if (!nextProcessingData->mStacked && !nextProcessingData->mExpression) {
1154 nextProcessingData->mStacked = true;
1155
1156 processingStack.push(nextProcessingData);
1157 while (!processingStack.isEmpty()) {
1158 CRedlandNodeProcessingData* processingData = processingStack.top();
1159
1160 bool buildingPossible = false;
1161 if (!processingData->mExpression && !processingData->mProcessed) {
1162 dependenciesCollectionFunction(processingData);
1163
1164 bool stackedProcessing = false;
1165 if (processingData->mDependendRedlandNodeProcessingDataList) {
1166 for (CRedlandNodeProcessingData* dependentProcessingData : *processingData->mDependendRedlandNodeProcessingDataList) {
1167 if (!dependentProcessingData->mExpression && !dependentProcessingData->mStacked) {
1168 processingStack.push(dependentProcessingData);
1169 dependentProcessingData->mStacked = true;
1170 stackedProcessing = true;
1171 }
1172 }
1173 if (!stackedProcessing) {
1174 buildingPossible = true;
1175 }
1176 } else {
1177 // probably an error, not clear how to build expression
1178 //TODO: print warning/error message
1179 buildingPossible = true;
1180 }
1181
1182 processingData->mProcessed = true;
1183 } else {
1184 buildingPossible = true;
1185 }
1186
1187
1188 if (buildingPossible) {
1189 processingStack.pop();
1190 if (processingData->mExpressionBuildFunc) {
1191 dependentBuildExpressionList.clear();
1192 if (processingData->mDependendRedlandNodeProcessingDataList) {
1193 for (CRedlandNodeProcessingData* dependentProcessingData : *processingData->mDependendRedlandNodeProcessingDataList) {
1194 if (dependentProcessingData->mExpression) {
1195 dependentBuildExpressionList.append(dependentProcessingData->mExpression);
1196 }
1197 }
1198 //delete processingData->mDependendRedlandNodeProcessingDataList;
1199 }
1200 //processingData->mDependendRedlandNodeProcessingDataList = nullptr;
1201 processingData->mExpression = processingData->mExpressionBuildFunc(dependentBuildExpressionList);
1202 processingData->mBuilt = true;
1203 processingData->mDependendRedlandNodeProcessingDataList = nullptr;
1204 }
1205 }
1206 }
1207 }
1208 }
1209 return this;
1210 }
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataRangeExpressionDependencies(CRedlandNodeProcessingData* processingData) {
1225 if (!processingData->mExpression) {
1226
1227 librdf_node* dataRangePredicateObjectArray[mOWLDataRangePredicateMaxIndex];
1228 for (cint64 i = 0; i < mOWLDataRangePredicateMaxIndex; ++i) {
1229 dataRangePredicateObjectArray[i] = nullptr;
1230 }
1231
1232
1233 // TODO: if there are too many successor triples, then use the other method, which directly filters by the corresponding predicates
1234 // create/use forEachAsLong/forEachLimited
1235 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLDataRanges))->forEach([&](librdf_statement* statement) {
1236 librdf_node* predicate = librdf_statement_get_predicate(statement);
1237 librdf_node* object = librdf_statement_get_object(statement);
1238 cint64 index = mDataRangePredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
1239 if (index >= 0 && !dataRangePredicateObjectArray[index]) {
1240 dataRangePredicateObjectArray[index] = librdf_new_node_from_node(object);
1241 }
1242 }));
1243
1244
1245
1246 // data intersection of
1247 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLIntersectionOfPredicateIndex]) {
1248 librdf_node* listNode = dataRangePredicateObjectArray[mOWLIntersectionOfPredicateIndex];
1249 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1250 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataIntersectionOf(expressions); };
1251 }
1252
1253 // data union of
1254 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLUnionOfPredicateIndex]) {
1255 librdf_node* listNode = dataRangePredicateObjectArray[mOWLUnionOfPredicateIndex];
1256 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1257 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataUnionOf(expressions); };
1258 }
1259
1260
1261 // data complement of
1262 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLDatatypeComplementOfPredicateIndex]) {
1263 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(dataRangePredicateObjectArray[mOWLDatatypeComplementOfPredicateIndex], mDatatypeNodeIdentifierDataHash);
1264 if (processingData->mDependendRedlandNodeProcessingDataList) {
1265 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataComplementOf(expressions); };
1266 }
1267 }
1268
1269
1270 // data one of
1271 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLOneOfPredicateIndex]) {
1272 librdf_node* listNode = dataRangePredicateObjectArray[mOWLOneOfPredicateIndex];
1273 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); });
1274 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataOneOf(expressions); };
1275 }
1276
1277
1278 // datatype restriction
1279 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && dataRangePredicateObjectArray[mOWLOnDatatypePredicateIndex] && dataRangePredicateObjectArray[mOWLWithRestrictionPredicateIndex]) {
1280 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(dataRangePredicateObjectArray[mOWLOnDatatypePredicateIndex], mDatatypeNodeIdentifierDataHash);
1281 if (processingData->mDependendRedlandNodeProcessingDataList) {
1282 QList<librdf_node*>* facetNodeList = getOWLListElementNodesList(dataRangePredicateObjectArray[mOWLWithRestrictionPredicateIndex]);
1283
1284 if (facetNodeList) {
1285 for (librdf_node* facetNode : *facetNodeList) {
1286 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(facetNode, nullptr, nullptr, mPartialFilteringStatementForOWLFacets))->forEach([&](librdf_statement* statement) {
1287 librdf_node* objectNode = librdf_statement_get_object(statement);
1288 librdf_node* predicateNode = librdf_statement_get_predicate(statement);
1289 if (librdf_node_is_literal(objectNode) && librdf_node_is_resource(predicateNode)) {
1290 CDataLiteralExpression* datLitExp = (CDataLiteralExpression*)createLiteralValueProcessingData(objectNode)->mExpression;
1291 const char* facetUri = (const char*)librdf_uri_as_string(librdf_node_get_uri(predicateNode));
1292 CDataFacetExpression* dataFacetExp = mOntologyBuilder->getDataFacet(QString::fromUtf8(facetUri));
1293 CDataFacetRestrictionExpression* dataFacetRestExp = mOntologyBuilder->getDataFacetRestriction(datLitExp, dataFacetExp);
1294 CRedlandNodeProcessingData* tmpProcessignData = new CRedlandNodeProcessingData(facetNode, dataFacetRestExp);
1295 processingData->mDependendRedlandNodeProcessingDataList->append(tmpProcessignData);
1296 mDataFacetRestrictionHandlingContainerList.append(tmpProcessignData);
1297 }
1298 }));
1299
1300 }
1301 delete facetNodeList;
1302 }
1303
1304 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDatatypeRestriction(expressions); };
1305 }
1306 }
1307
1308
1309 for (cint64 i = 0; i < mOWLDataRangePredicateMaxIndex; ++i) {
1310 if (dataRangePredicateObjectArray[i]) {
1311 librdf_free_node(dataRangePredicateObjectArray[i]);
1312 }
1313 }
1314
1315 }
1316 return this;
1317 }
1318
1319
1320
1321
1322
1323 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataRangeExpressionDependenciesBySuccessorRetrieval(CRedlandNodeProcessingData* processingData) {
1324 if (!processingData->mExpression) {
1325
1326 // data intersection of
1327 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1328 releaseRedlandNodeStreamWrapper(getOWLIntersectionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
1329 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1330 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataIntersectionOf(expressions); };
1331 }));
1332 }
1333
1334 // data union of
1335 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1336 releaseRedlandNodeStreamWrapper(getOWLUnionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
1337 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1338 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataUnionOf(expressions); };
1339 }));
1340 }
1341
1342
1343 // data complement of
1344 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1345 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLDatatypeComplementOfSuccessorNodesStream(processingData->mRedlandNode), mDatatypeNodeIdentifierDataHash);
1346 if (processingData->mDependendRedlandNodeProcessingDataList) {
1347 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataComplementOf(expressions); };
1348 }
1349 }
1350
1351
1352 // data one of
1353 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1354 releaseRedlandNodeStreamWrapper(getOWLOneOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
1355 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); });
1356 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataOneOf(expressions); };
1357 }));
1358 }
1359
1360 // datatype restriction
1361 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1362 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnDatatypeSuccessorNodesStream(processingData->mRedlandNode), mDatatypeNodeIdentifierDataHash);
1363 if (processingData->mDependendRedlandNodeProcessingDataList) {
1364 QList<librdf_node*>* facetNodeList = nullptr;
1365 releaseRedlandNodeStreamWrapper(getOWLWithRestrictionSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1366 facetNodeList = getOWLListElementNodesList(node, facetNodeList);
1367 }));
1368
1369 if (facetNodeList) {
1370 for (librdf_node* facetNode : *facetNodeList) {
1371 for (QHash<const char*, librdf_node*>::const_iterator it = mFacetUriNodeHash.constBegin(), itEnd = mFacetUriNodeHash.constEnd(); it != itEnd; ++it) {
1372 const char* facetUri = it.key();
1373 librdf_node* facetUriNode = it.value();
1374 collectDataFacetExpressionBySuccessorRetrieval(processingData, facetNode, facetUriNode, facetUri);
1375 }
1376 }
1377 delete facetNodeList;
1378 }
1379
1380 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDatatypeRestriction(expressions); };
1381 }
1382 }
1383
1384 }
1385 return this;
1386 }
1387
1388
1389
1390 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectDataFacetExpressionBySuccessorRetrieval(CRedlandNodeProcessingData* processingData, librdf_node* node, librdf_node* facetNode, const char* facetUri) {
1391 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(node, facetNode, nullptr, mPartialFilteringStatementForOWLFacetSuccessors))->forEach([&](librdf_statement* statement) {
1392 librdf_node* objectNode = librdf_statement_get_object(statement);
1393 if (librdf_node_is_literal(objectNode)) {
1394 CDataLiteralExpression* datLitExp = (CDataLiteralExpression*)createLiteralValueProcessingData(objectNode)->mExpression;
1395 CDataFacetExpression* dataFacetExp = mOntologyBuilder->getDataFacet(QString::fromUtf8(facetUri));
1396 CDataFacetRestrictionExpression* dataFacetRestExp = mOntologyBuilder->getDataFacetRestriction(datLitExp, dataFacetExp);
1397 CRedlandNodeProcessingData* tmpProcessignData = new CRedlandNodeProcessingData(node, dataFacetRestExp);
1398 processingData->mDependendRedlandNodeProcessingDataList->append(tmpProcessignData);
1399 mDataFacetRestrictionHandlingContainerList.append(tmpProcessignData);
1400 }
1401 }));
1402
1403 return this;
1404 }
1405
1406
1407
1408
1409
1410
1411
1412 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassExpressionDependencies(CRedlandNodeProcessingData* processingData) {
1413 if (!processingData->mExpression) {
1414
1415 librdf_node* classPredicateObjectArray[mOWLPredicateMaxIndex];
1416 for (cint64 i = 0; i < mOWLPredicateMaxIndex; ++i) {
1417 classPredicateObjectArray[i] = nullptr;
1418 }
1419
1420
1421
1422 // TODO: if there are too many successor triples that do not match, then use the other method, which directly filters by the corresponding predicates
1423 // create/use forEachAsLong/forEachLimited
1424 releaseRedlandTripleStreamWrapper(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(processingData->mRedlandNode, nullptr, nullptr, mPartialFilteringStatementForOWLClasses))->forEach([&](librdf_statement* statement) {
1425 librdf_node* predicate = librdf_statement_get_predicate(statement);
1426 librdf_node* object = librdf_statement_get_object(statement);
1427 cint64 index = mClassPredicateIndexHash.value(CRedlandNodeHasher(predicate), -1);
1428 if (index >= 0 && !classPredicateObjectArray[index]) {
1429 classPredicateObjectArray[index] = librdf_new_node_from_node(object);
1430 }
1431 }));
1432
1433
1434 // object intersection of
1435 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLIntersectionOfPredicateIndex]) {
1436 librdf_node* listNode = classPredicateObjectArray[mOWLIntersectionOfPredicateIndex];
1437 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1438 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectIntersectionOf(expressions); };
1439 }
1440
1441 // object union of
1442 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLUnionOfPredicateIndex]) {
1443 librdf_node* listNode = classPredicateObjectArray[mOWLUnionOfPredicateIndex];
1444 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1445 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectUnionOf(expressions); };
1446 }
1447
1448 // object complement of
1449 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLComplementOfPredicateIndex]) {
1450 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLComplementOfPredicateIndex], mClassNodeIdentifierDataHash);
1451 if (processingData->mDependendRedlandNodeProcessingDataList) {
1452 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectComplementOf(expressions); };
1453 }
1454 }
1455
1456 // object one of
1457 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLOneOfPredicateIndex]) {
1458 librdf_node* listNode = classPredicateObjectArray[mOWLOneOfPredicateIndex];
1459 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
1460 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectOneOf(expressions); };
1461 }
1462
1463
1464
1465
1466
1467 // restrictions
1468 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList && classPredicateObjectArray[mOWLOnPropertyPredicateIndex]) {
1469
1470 QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>* nodeDataHash = nullptr;
1471 bool dataPropertyNodeUsed = false;
1472 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromObjectORDataPropertyNode(classPredicateObjectArray[mOWLOnPropertyPredicateIndex], &dataPropertyNodeUsed, &nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1473
1474
1475 if (processingData->mDependendRedlandNodeProcessingDataList) {
1476 // object/data some value from
1477 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLSomeValuesFromPredicateIndex]) {
1478 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLSomeValuesFromPredicateIndex], *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1479 if (dataPropertyNodeUsed) {
1480 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataSomeValuesFrom(expressions); };
1481 } else {
1482 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectSomeValuesFrom(expressions); };
1483 }
1484 }
1485
1486 // object/data some value from
1487 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLAllValuesFromPredicateIndex]) {
1488 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLAllValuesFromPredicateIndex], *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1489 if (dataPropertyNodeUsed) {
1490 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataAllValuesFrom(expressions); };
1491 } else {
1492 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectAllValuesFrom(expressions); };
1493 }
1494 }
1495
1496 // object/data has value
1497 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLHasValuePredicateIndex]) {
1498 if (!dataPropertyNodeUsed) {
1499 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeWithNewHandling(classPredicateObjectArray[mOWLHasValuePredicateIndex], mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
1500 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasValue(expressions); };
1501 } else {
1502 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeWithNewHandling(classPredicateObjectArray[mOWLHasValuePredicateIndex], mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
1503 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataHasValue(expressions); };
1504 }
1505 }
1506
1507 // object has self
1508 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLHasSelfPredicateIndex]) {
1509 if (!dataPropertyNodeUsed) {
1510 if (checkHasBooleanTrueLiteralValue(classPredicateObjectArray[mOWLHasSelfPredicateIndex])) {
1511 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasSelf(expressions); };
1512 }
1513 }
1514 }
1515
1516
1517
1518 // qualified cardinality restrictions
1519 if (!processingData->mExpressionBuildFunc && (classPredicateObjectArray[mOWLOnClassPredicateIndex] || classPredicateObjectArray[mOWLOnDataRangePredicateIndex])) {
1520
1521 cint64 prevDepSize = processingData->mDependendRedlandNodeProcessingDataList->size();
1522 if (!dataPropertyNodeUsed) {
1523 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLOnClassPredicateIndex], mClassNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1524 } else {
1525 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNode(classPredicateObjectArray[mOWLOnDataRangePredicateIndex], mDatatypeNodeIdentifierDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1526 }
1527 if (processingData->mDependendRedlandNodeProcessingDataList->size() > prevDepSize) {
1528
1529 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMinQualifiedCardinalityPredicateIndex]) {
1530 cint64 minCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMinQualifiedCardinalityPredicateIndex]);
1531 if (minCardinality >= 0) {
1532 if (!dataPropertyNodeUsed) {
1533 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
1534 } else {
1535 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
1536 }
1537 }
1538 }
1539
1540 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMaxQualifiedCardinalityPredicateIndex]) {
1541 cint64 maxCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMaxQualifiedCardinalityPredicateIndex]);
1542 if (maxCardinality >= 0) {
1543 if (!dataPropertyNodeUsed) {
1544 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
1545 } else {
1546 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
1547 }
1548 }
1549 }
1550
1551 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLQualifiedCardinalityPredicateIndex]) {
1552 cint64 cardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLQualifiedCardinalityPredicateIndex]);
1553 if (cardinality >= 0) {
1554 if (!dataPropertyNodeUsed) {
1555 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
1556 } else {
1557 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
1558 }
1559 }
1560 }
1561 }
1562 if (!processingData->mExpressionBuildFunc) {
1563 while (processingData->mDependendRedlandNodeProcessingDataList->size() > prevDepSize) {
1564 processingData->mDependendRedlandNodeProcessingDataList->removeLast();
1565 }
1566 }
1567 }
1568
1569 // unqualified cardinality restrictions
1570 if (!processingData->mExpressionBuildFunc && !dataPropertyNodeUsed) {
1571 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMinCardinalityPredicateIndex]) {
1572 cint64 minCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMinCardinalityPredicateIndex]);
1573 if (minCardinality >= 0) {
1574 if (!dataPropertyNodeUsed) {
1575 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
1576 } else {
1577 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
1578 }
1579 }
1580 }
1581
1582 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLMaxCardinalityPredicateIndex]) {
1583 cint64 maxCardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLMaxCardinalityPredicateIndex]);
1584 if (maxCardinality >= 0) {
1585 if (!dataPropertyNodeUsed) {
1586 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
1587 } else {
1588 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
1589 }
1590 }
1591 }
1592
1593 if (!processingData->mExpressionBuildFunc && classPredicateObjectArray[mOWLCardinalityPredicateIndex]) {
1594 cint64 cardinality = getNonNegativeNumberFromLiteralValue(classPredicateObjectArray[mOWLCardinalityPredicateIndex]);
1595 if (cardinality >= 0) {
1596 if (!dataPropertyNodeUsed) {
1597 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
1598 } else {
1599 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
1600 }
1601 }
1602 }
1603 }
1604
1605 }
1606 if (!processingData->mExpressionBuildFunc) {
1607 delete processingData->mDependendRedlandNodeProcessingDataList;
1608 processingData->mDependendRedlandNodeProcessingDataList = nullptr;
1609 }
1610
1611 }
1612
1613
1614
1615 }
1616 return this;
1617 }
1618
1619
1620
1621
1622
1623
1624
1625
1626 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassExpressionDependenciesBySuccessorRetrieval(CRedlandNodeProcessingData* processingData) {
1627 if (!processingData->mExpression) {
1628
1629 // object intersection of
1630 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1631 releaseRedlandNodeStreamWrapper(getOWLIntersectionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
1632 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
1633 if (processingData->mDependendRedlandNodeProcessingDataList->isEmpty()) {
1634 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
1635 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
1636 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
1637
1638 }
1639 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectIntersectionOf(expressions); };
1640 }));
1641 }
1642
1643 // object union of
1644 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1645 releaseRedlandNodeStreamWrapper(getOWLUnionOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
1646 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataList(listNode, mClassNodeIdentifierDataHash);
1647 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectUnionOf(expressions); };
1648 }));
1649 }
1650
1651 // object complement of
1652 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1653 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLComplementOfSuccessorNodesStream(processingData->mRedlandNode), mClassNodeIdentifierDataHash);
1654 if (processingData->mDependendRedlandNodeProcessingDataList) {
1655 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectComplementOf(expressions); };
1656 }
1657 }
1658
1659 // object one of
1660 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1661 releaseRedlandNodeStreamWrapper(getOWLOneOfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* listNode) {
1662 processingData->mDependendRedlandNodeProcessingDataList = getRDFListElementNodesAsProcessingDataListWithNewHandling(listNode, mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); });
1663 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectOneOf(expressions); };
1664 }));
1665 }
1666
1667
1668
1669
1670 // restriction
1671 if (!processingData->mExpressionBuildFunc && !processingData->mDependendRedlandNodeProcessingDataList) {
1672 QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>* nodeDataHash = nullptr;
1673 bool dataPropertyNodeUsed = false;
1674 bool onPropertyPresent = collectClassExpressionOnPropertyDependenciesReturnPresence(processingData, &dataPropertyNodeUsed, &nodeDataHash);
1675
1676 if (onPropertyPresent && processingData->mDependendRedlandNodeProcessingDataList) {
1677 cint64 onPropertyDepDataCount = processingData->mDependendRedlandNodeProcessingDataList->size();
1678
1679 // object/data some value from
1680 if (!processingData->mExpressionBuildFunc) {
1681 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLSomeValuesFromSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1682 if (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
1683 if (dataPropertyNodeUsed) {
1684 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataSomeValuesFrom(expressions); };
1685 } else {
1686 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectSomeValuesFrom(expressions); };
1687 }
1688 }
1689 }
1690
1691 // object/data add value from
1692 if (!processingData->mExpressionBuildFunc) {
1693 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLAllValuesFromSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1694 if (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
1695 if (dataPropertyNodeUsed) {
1696 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataAllValuesFrom(expressions); };
1697 } else {
1698 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectAllValuesFrom(expressions); };
1699 }
1700 }
1701 }
1702
1703 // object/data has value
1704 if (!processingData->mExpressionBuildFunc) {
1705 if (dataPropertyNodeUsed) {
1706 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(getOWLHasValueSuccessorNodesStream(processingData->mRedlandNode), mDataLiteralNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createLiteralValueProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
1707 } else {
1708 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStreamWithNewHandling(getOWLHasValueSuccessorNodesStream(processingData->mRedlandNode), mNamedIndividualNodeIdentifierDataHash, [&](librdf_node* node)->CRedlandNodeProcessingData* { return createNamedIndividualProcessingData(node); }, processingData->mDependendRedlandNodeProcessingDataList);
1709 }
1710 if (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
1711 if (dataPropertyNodeUsed) {
1712 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataHasValue(expressions); };
1713 } else {
1714 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasValue(expressions); };
1715 }
1716 }
1717 }
1718
1719
1720 // object has self
1721 if (!processingData->mExpressionBuildFunc && !dataPropertyNodeUsed) {
1722 releaseRedlandNodeStreamWrapper(getOWLHasSelfSuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1723 if (!processingData->mExpressionBuildFunc && checkHasBooleanTrueLiteralValue(node)) {
1724 processingData->mExpressionBuildFunc = [&](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectHasSelf(expressions); };
1725 }
1726 }));
1727 }
1728
1729
1730 // cardinalities
1731 if (!processingData->mExpressionBuildFunc) {
1732 if (!dataPropertyNodeUsed) {
1733 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnClassSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1734 } else {
1735 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnDataRangeSuccessorNodesStream(processingData->mRedlandNode), *nodeDataHash, processingData->mDependendRedlandNodeProcessingDataList);
1736 }
1737 cint64 onClassOrDataRangeDepDataCount = processingData->mDependendRedlandNodeProcessingDataList->size();
1738
1739 if (!processingData->mExpressionBuildFunc && onClassOrDataRangeDepDataCount > onPropertyDepDataCount) {
1740 // qualified cardinality restrictions
1741
1742 if (!processingData->mExpressionBuildFunc) {
1743 cint64 minCardinality = -1;
1744 releaseRedlandNodeStreamWrapper(getOWLMinQualifiedCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1745 minCardinality = getNonNegativeNumberFromLiteralValue(node);
1746 }));
1747
1748 if (minCardinality >= 0) {
1749 if (!dataPropertyNodeUsed) {
1750 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
1751 } else {
1752 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
1753 }
1754 }
1755 }
1756
1757
1758 if (!processingData->mExpressionBuildFunc) {
1759 cint64 maxCardinality = -1;
1760 releaseRedlandNodeStreamWrapper(getOWLMaxQualifiedCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1761 maxCardinality = getNonNegativeNumberFromLiteralValue(node);
1762 }));
1763
1764 if (maxCardinality >= 0) {
1765 if (!dataPropertyNodeUsed) {
1766 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
1767 } else {
1768 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
1769 }
1770 }
1771 }
1772
1773 if (!processingData->mExpressionBuildFunc) {
1774 cint64 cardinality = -1;
1775 releaseRedlandNodeStreamWrapper(getOWLQualifiedCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1776 cardinality = getNonNegativeNumberFromLiteralValue(node);
1777 }));
1778
1779 if (!dataPropertyNodeUsed) {
1780 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
1781 } else {
1782 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
1783 }
1784 }
1785
1786
1787 if (!processingData->mExpressionBuildFunc) {
1788 while (processingData->mDependendRedlandNodeProcessingDataList->size() > onPropertyDepDataCount) {
1789 processingData->mDependendRedlandNodeProcessingDataList->removeLast();
1790 }
1791 }
1792
1793 }
1794
1795
1796
1797 if (!processingData->mExpressionBuildFunc) {
1798 // unqualified cardinality restriction
1799
1800 if (!processingData->mExpressionBuildFunc) {
1801 cint64 minCardinality = -1;
1802 releaseRedlandNodeStreamWrapper(getOWLMinCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1803 minCardinality = getNonNegativeNumberFromLiteralValue(node);
1804 }));
1805
1806 if (minCardinality >= 0) {
1807 if (!dataPropertyNodeUsed) {
1808 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMinCardinality(expressions, minCardinality); };
1809 } else {
1810 processingData->mExpressionBuildFunc = [minCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMinCardinality(expressions, minCardinality); };
1811 }
1812 }
1813 }
1814
1815 if (!processingData->mExpressionBuildFunc) {
1816 cint64 maxCardinality = -1;
1817 releaseRedlandNodeStreamWrapper(getOWLMaxCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1818 maxCardinality = getNonNegativeNumberFromLiteralValue(node);
1819 }));
1820
1821 if (maxCardinality >= 0) {
1822 if (!dataPropertyNodeUsed) {
1823 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectMaxCardinality(expressions, maxCardinality); };
1824 } else {
1825 processingData->mExpressionBuildFunc = [maxCardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataMaxCardinality(expressions, maxCardinality); };
1826 }
1827 }
1828 }
1829
1830
1831 if (!processingData->mExpressionBuildFunc) {
1832 cint64 cardinality = -1;
1833 releaseRedlandNodeStreamWrapper(getOWLCardinalitySuccessorNodesStream(processingData->mRedlandNode)->forEach([&](librdf_node* node) {
1834 cardinality = getNonNegativeNumberFromLiteralValue(node);
1835 }));
1836
1837 if (cardinality >= 0) {
1838 if (!dataPropertyNodeUsed) {
1839 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getObjectExactlyCardinality(expressions, cardinality); };
1840 } else {
1841 processingData->mExpressionBuildFunc = [cardinality, this](const QList<CBuildExpression*>& expressions)->CBuildExpression* { return mOntologyBuilder->getDataExactCardinality(expressions, cardinality); };
1842 }
1843 }
1844 }
1845
1846 }
1847
1848
1849 } // end cardinality
1850
1851
1852 if (!processingData->mExpressionBuildFunc) {
1853 delete processingData->mDependendRedlandNodeProcessingDataList;
1854 processingData->mDependendRedlandNodeProcessingDataList = nullptr;
1855 }
1856 }
1857
1858 } // end restriction
1859
1860
1861 }
1862 return this;
1863 }
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874 bool CConcreteOntologyRedlandTriplesDataExpressionMapper::checkHasBooleanTrueLiteralValue(librdf_node* node) {
1875 if (librdf_node_is_literal(node)) {
1876 const char* lexicalDataValueString = (const char*)librdf_node_get_literal_value(node);
1877 QString literalValueString = QString::fromUtf8(lexicalDataValueString);
1878 literalValueString = literalValueString.toUpper();
1879 if (literalValueString.compare("TRUE") != 0) {
1880 return false;
1881 }
1882
1883 const char* lexicalDataValueLanguageString = librdf_node_get_literal_value_language(node);
1884 if (lexicalDataValueLanguageString) {
1885 return false;
1886 }
1887
1888 librdf_uri* datatypeUri = librdf_node_get_literal_value_datatype_uri(node);
1889 if (datatypeUri) {
1890 if (librdf_uri_equals(mBooleanDatatypeUri, datatypeUri) == 0) {
1891 return false;
1892 }
1893 } else {
1894 return false;
1895 }
1896 return true;
1897 }
1898 return false;
1899 }
1900
1901
1902
1903
1904 cint64 CConcreteOntologyRedlandTriplesDataExpressionMapper::getNonNegativeNumberFromLiteralValue(librdf_node* node) {
1905 cint64 nonNegativeNumber = -1;
1906 if (librdf_node_is_literal(node)) {
1907 const char* lexicalDataValueString = (const char*)librdf_node_get_literal_value(node);
1908 QString literalValueString = QString::fromUtf8(lexicalDataValueString);
1909 bool parsingSuccess = false;
1910 nonNegativeNumber = literalValueString.toLongLong(&parsingSuccess);
1911 if (!parsingSuccess) {
1912 nonNegativeNumber = -1;
1913 }
1914 }
1915 return nonNegativeNumber;
1916 }
1917
1918
1919
1920 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromObjectORDataPropertyNode(librdf_node* node, bool* dataPropertyFlag, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>** nodeDataHash, QList<CRedlandNodeProcessingData*>* extendingList) {
1921 QList<CRedlandNodeProcessingData*>* nodesProcessingData = extendingList;
1922 bool dataPropertyNodeUsed = false;
1923 CRedlandNodeHasher hasher(node);
1924 CRedlandNodeProcessingData* processingData = mObjectPropertyNodeIdentifierDataHash.value(hasher);
1925 if (!processingData) {
1926 processingData = mDataPropertyNodeIdentifierDataHash.value(hasher);
1927 if (processingData) {
1928 dataPropertyNodeUsed = true;
1929 }
1930 }
1931 if (processingData) {
1932 if (!nodesProcessingData) {
1933 nodesProcessingData = new QList<CRedlandNodeProcessingData *>();
1934 }
1935 nodesProcessingData->append(processingData);
1936 }
1937
1938 if (dataPropertyFlag) {
1939 *dataPropertyFlag = false;
1940 if (dataPropertyNodeUsed) {
1941 *dataPropertyFlag = true;
1942 }
1943 }
1944
1945 if (nodeDataHash) {
1946 *nodeDataHash = &mClassNodeIdentifierDataHash;
1947 if (dataPropertyNodeUsed) {
1948 *nodeDataHash = &mDatatypeNodeIdentifierDataHash;
1949 }
1950 }
1951 return nodesProcessingData;
1952 }
1953
1954
1955 bool CConcreteOntologyRedlandTriplesDataExpressionMapper::collectClassExpressionOnPropertyDependenciesReturnPresence(CRedlandNodeProcessingData* processingData, bool* dataPropertyFlag, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>** nodeDataHash) {
1956 bool onPropertyPresent = false;
1957 bool dataPropertyNodeUsed = false;
1958 processingData->mDependendRedlandNodeProcessingDataList = getNodeProcessingDataListFromNodeStream(getOWLOnPropertySuccessorNodesStream(processingData->mRedlandNode), [&](librdf_node* node)->CRedlandNodeProcessingData* {
1959 CRedlandNodeHasher hasher(node);
1960 CRedlandNodeProcessingData* processingData = mObjectPropertyNodeIdentifierDataHash.value(hasher);
1961 if (!processingData) {
1962 processingData = mDataPropertyNodeIdentifierDataHash.value(hasher);
1963 if (processingData) {
1964 dataPropertyNodeUsed = true;
1965 }
1966 }
1967 if (processingData) {
1968 onPropertyPresent = true;
1969 }
1970 return processingData;
1971 }, processingData->mDependendRedlandNodeProcessingDataList);
1972
1973
1974 if (dataPropertyFlag) {
1975 *dataPropertyFlag = dataPropertyNodeUsed;
1976 }
1977
1978 if (nodeDataHash) {
1979 *nodeDataHash = &mClassNodeIdentifierDataHash;
1980 if (dataPropertyNodeUsed) {
1981 *nodeDataHash = &mDatatypeNodeIdentifierDataHash;
1982 }
1983 }
1984 return onPropertyPresent;
1985 }
1986
1987
1988
1989 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData* CConcreteOntologyRedlandTriplesDataExpressionMapper::createNamedIndividualProcessingData(librdf_node* node) {
1990 CRedlandNodeProcessingData* processingData = nullptr;
1991 CBuildExpression* expression = nullptr;
1992 if (!librdf_node_is_blank(node)) {
1993 librdf_uri* uri = librdf_node_get_uri(node);
1994 const char* uriString = (const char*)librdf_uri_as_string(uri);
1995 expression = mOntologyBuilder->getNamedIndividual(QString::fromUtf8(uriString));
1996 processingData = new CRedlandNodeProcessingData(node, expression);
1997 }
1998 return processingData;
1999 }
2000
2001
2002
2003
2004 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData* CConcreteOntologyRedlandTriplesDataExpressionMapper::createLiteralValueProcessingData(librdf_node* node) {
2005 CRedlandNodeProcessingData* processingData = nullptr;
2006 if (librdf_node_is_literal(node)) {
2007 const char* lexicalDataValueString = (const char*)librdf_node_get_literal_value(node);
2008 QString literalValueString = QString::fromUtf8(lexicalDataValueString);
2009 const char* lexicalDataValueLanguageString = librdf_node_get_literal_value_language(node);
2010 if (lexicalDataValueLanguageString) {
2011 literalValueString += QString("@%1").arg(QString::fromUtf8(lexicalDataValueLanguageString));
2012 }
2013
2014 librdf_uri* datatypeUri = librdf_node_get_literal_value_datatype_uri(node);
2015 const char* datatypeUriString = nullptr;
2016 if (datatypeUri) {
2017 datatypeUriString = (const char*)librdf_uri_as_string(datatypeUri);
2018 }
2019 if (!datatypeUriString) {
2020 datatypeUriString = PREFIX_XML_PLAINLITERAL_DATATYPE;
2021 }
2022 CDataLexicalValueExpression* dataLexValueExp = mOntologyBuilder->getDataLexicalValue(literalValueString);
2023 CDatatypeExpression* datatypeExp = mOntologyBuilder->getDatatype(QString::fromUtf8(datatypeUriString));
2024 CDataLiteralExpression* dataLitExp = mOntologyBuilder->getDataLiteral(dataLexValueExp, datatypeExp);
2025 processingData = new CRedlandNodeProcessingData(node, dataLitExp);
2026 }
2027 return processingData;
2028 }
2029
2030
2031
2032
2033
2034
2035 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNode(librdf_node* node, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CBuildExpression*>& existingList) {
2036 CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
2037 if (processingData && processingData->mExpression) {
2038 existingList.append(processingData->mExpression);
2039 }
2040 return this;
2041 }
2042
2043
2044 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNodeStream(CRedlandNodeStream* nodeStream, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CBuildExpression*>& existingList) {
2045 nodeStream->forEach([&](librdf_node* node) {
2046 collectBuildExpressionsFromNode(node, nodeIdentifierDataHash, existingList);
2047 });
2048 releaseRedlandNodeStreamWrapper(nodeStream);
2049 return this;
2050 }
2051
2052
2053 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromRDFNodeList(librdf_node* listNode, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CBuildExpression*>& existingList) {
2054 QList<librdf_node*> listNodes;
2055 listNodes.append(librdf_new_node_from_node(listNode));
2056 while (!listNodes.isEmpty()) {
2057 librdf_node* nextListNode = listNodes.takeFirst();
2058 if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
2059
2060 collectBuildExpressionsFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2), nodeIdentifierDataHash, existingList);
2061
2062 releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
2063 listNodes.append(librdf_new_node_from_node(node));
2064 }));
2065 }
2066 librdf_free_node(nextListNode);
2067 }
2068 return this;
2069 }
2070
2071
2072
2073
2074
2075
2076
2077 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNodeWithNewHandling(librdf_node* node, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CBuildExpression*>& existingList) {
2078 CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
2079 if (!processingData) {
2080 librdf_node* nodeCopy = librdf_new_node_from_node(node);
2081 processingData = newHandlingFunc(nodeCopy);
2082 if (processingData) {
2083 nodeIdentifierDataHash[CRedlandNodeHasher(nodeCopy)] = processingData;
2084 } else {
2085 librdf_free_node(nodeCopy);
2086 }
2087 }
2088 if (processingData && processingData->mExpression) {
2089 existingList.append(processingData->mExpression);
2090 }
2091 return this;
2092 }
2093
2094
2095 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromNodeStreamWithNewHandling(CRedlandNodeStream* nodeStream, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CBuildExpression*>& existingList) {
2096 nodeStream->forEach([&](librdf_node* node) {
2097 collectBuildExpressionsFromNodeWithNewHandling(node, nodeIdentifierDataHash, newHandlingFunc, existingList);
2098 });
2099 releaseRedlandNodeStreamWrapper(nodeStream);
2100 return this;
2101 }
2102
2103
2104 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::collectBuildExpressionsFromRDFNodeListWithNewHandling(librdf_node* listNode, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CBuildExpression*>& existingList) {
2105 QList<librdf_node*> listNodes;
2106 listNodes.append(librdf_new_node_from_node(listNode));
2107 while (!listNodes.isEmpty()) {
2108 librdf_node* nextListNode = listNodes.takeFirst();
2109 if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
2110
2111 collectBuildExpressionsFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2), nodeIdentifierDataHash, newHandlingFunc, existingList);
2112
2113 releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
2114 listNodes.append(librdf_new_node_from_node(node));
2115 }));
2116 }
2117 librdf_free_node(nextListNode);
2118 }
2119 return this;
2120 }
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNode(librdf_node* node, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>* existingList) {
2135 QList<CRedlandNodeProcessingData*>* nodesProcessingData = existingList;
2136 CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
2137 if (processingData) {
2138 if (!nodesProcessingData) {
2139 nodesProcessingData = new QList<CRedlandNodeProcessingData*>();
2140 }
2141 nodesProcessingData->append(processingData);
2142 }
2143 return nodesProcessingData;
2144 }
2145
2146
2147
2148 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNodeStream(CRedlandNodeStream* nodeStream, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>* existingList) {
2149 QList<CRedlandNodeProcessingData*>* nodesProcessingData = existingList;
2150 nodeStream->forEach([&](librdf_node* node) {
2151 nodesProcessingData = getNodeProcessingDataListFromNode(node, nodeIdentifierDataHash, nodesProcessingData);
2152 });
2153 releaseRedlandNodeStreamWrapper(nodeStream);
2154 return nodesProcessingData;
2155 }
2156
2157 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getRDFListElementNodesAsProcessingDataList(librdf_node* listNode, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>* existingList) {
2158 QList<CRedlandNodeProcessingData*>* elementNodesProcessingData = existingList;
2159 QList<librdf_node*> listNodes;
2160 listNodes.append(librdf_new_node_from_node(listNode));
2161 while (!listNodes.isEmpty()) {
2162 librdf_node* nextListNode = listNodes.takeFirst();
2163 if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
2164
2165 elementNodesProcessingData = getNodeProcessingDataListFromNodeStream(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2), nodeIdentifierDataHash, elementNodesProcessingData);
2166
2167 releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
2168 listNodes.append(librdf_new_node_from_node(node));
2169 }));
2170
2171 }
2172 librdf_free_node(nextListNode);
2173 }
2174 return elementNodesProcessingData;
2175 }
2176
2177
2178
2179
2180
2181
2182
2183 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNode(librdf_node* node, function<CRedlandNodeProcessingData*(librdf_node*)> resolvingFunc, QList<CRedlandNodeProcessingData*>* existingList) {
2184 QList<CRedlandNodeProcessingData*>* nodesProcessingData = existingList;
2185 CRedlandNodeProcessingData* processingData = resolvingFunc(node);
2186 if (processingData) {
2187 if (!nodesProcessingData) {
2188 nodesProcessingData = new QList<CRedlandNodeProcessingData*>();
2189 }
2190 nodesProcessingData->append(processingData);
2191 }
2192 return nodesProcessingData;
2193 }
2194
2195 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNodeStream(CRedlandNodeStream* nodeStream, function<CRedlandNodeProcessingData*(librdf_node*)> resolvingFunc, QList<CRedlandNodeProcessingData*>* existingList) {
2196 QList<CRedlandNodeProcessingData*>* nodesProcessingData = existingList;
2197 nodeStream->forEach([&](librdf_node* node) {
2198 nodesProcessingData = getNodeProcessingDataListFromNode(node, resolvingFunc, nodesProcessingData);
2199 });
2200 releaseRedlandNodeStreamWrapper(nodeStream);
2201 return nodesProcessingData;
2202 }
2203
2204
2205
2206
2207 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNodeWithNewHandling(librdf_node* node, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CRedlandNodeProcessingData*>* existingList) {
2208 QList<CRedlandNodeProcessingData*>* nodesProcessingData = existingList;
2209 CRedlandNodeProcessingData* processingData = nodeIdentifierDataHash.value(CRedlandNodeHasher(node));
2210 if (!processingData) {
2211 librdf_node* nodeCopy = librdf_new_node_from_node(node);
2212 processingData = newHandlingFunc(nodeCopy);
2213 if (processingData) {
2214 nodeIdentifierDataHash[CRedlandNodeHasher(nodeCopy)] = processingData;
2215 } else {
2216 librdf_free_node(nodeCopy);
2217 }
2218 }
2219 if (processingData) {
2220 if (!nodesProcessingData) {
2221 nodesProcessingData = new QList<CRedlandNodeProcessingData*>();
2222 }
2223 nodesProcessingData->append(processingData);
2224 }
2225 return nodesProcessingData;
2226 }
2227
2228 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getNodeProcessingDataListFromNodeStreamWithNewHandling(CRedlandNodeStream* nodeStream, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CRedlandNodeProcessingData*>* existingList) {
2229 QList<CRedlandNodeProcessingData*>* nodesProcessingData = existingList;
2230 nodeStream->forEach([&](librdf_node* node) {
2231 nodesProcessingData = getNodeProcessingDataListFromNodeWithNewHandling(node, nodeIdentifierDataHash, newHandlingFunc, nodesProcessingData);
2232 });
2233 releaseRedlandNodeStreamWrapper(nodeStream);
2234 return nodesProcessingData;
2235 }
2236
2237 QList<CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeProcessingData*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getRDFListElementNodesAsProcessingDataListWithNewHandling(librdf_node* listNode, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, function<CRedlandNodeProcessingData*(librdf_node* node)> newHandlingFunc, QList<CRedlandNodeProcessingData*>* existingList) {
2238 QList<CRedlandNodeProcessingData*>* elementNodesProcessingData = existingList;
2239 QList<librdf_node*> listNodes;
2240 listNodes.append(librdf_new_node_from_node(listNode));
2241 while (!listNodes.isEmpty()) {
2242 librdf_node* nextListNode = listNodes.takeFirst();
2243 if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
2244
2245 elementNodesProcessingData = getNodeProcessingDataListFromNodeStreamWithNewHandling(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2), nodeIdentifierDataHash, newHandlingFunc, elementNodesProcessingData);
2246
2247 releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
2248 listNodes.append(librdf_new_node_from_node(node));
2249 }));
2250
2251 }
2252 librdf_free_node(nextListNode);
2253 }
2254 return elementNodesProcessingData;
2255 }
2256
2257
2258
2259
2260
2261
2262 QList<librdf_node*>* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLListElementNodesList(librdf_node* listNode, QList<librdf_node*>* extendingList) {
2263 QList<librdf_node*>* elementNodes = extendingList;
2264 QList<librdf_node*> listNodes;
2265 listNodes.append(librdf_new_node_from_node(listNode));
2266 while (!listNodes.isEmpty()) {
2267 librdf_node* nextListNode = listNodes.takeFirst();
2268 if (!librdf_node_equals(nextListNode, mRDFNilNode)) {
2269
2270 releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFFirstSuccessors)), 2)->forEach([&](librdf_node* node) {
2271 if (!elementNodes) {
2272 elementNodes = new QList<librdf_node*>();
2273 }
2274 elementNodes->append(librdf_new_node_from_node(node));
2275 }));
2276
2277
2278 releaseRedlandNodeStreamWrapper(createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nextListNode, nullptr, nullptr, mPartialFilteringStatementForRDFRestSuccessors)), 2)->forEach([&](librdf_node* node) {
2279 listNodes.append(librdf_new_node_from_node(node));
2280 }));
2281
2282 }
2283 librdf_free_node(nextListNode);
2284 }
2285 return elementNodes;
2286 }
2287
2288
2289
2290
2291
2292 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::handleDeclaration(librdf_node* node, function<CBuildExpression*(const QString &uri)> buildEntityFunc, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>& nodeHandlingList) {
2293 bool anonym = true;
2294 CBuildExpression* expression = nullptr;
2295 librdf_node* nodeCopy = librdf_new_node_from_node(node);
2296 if (!librdf_node_is_blank(nodeCopy)) {
2297 anonym = false;
2298 librdf_uri* uri = librdf_node_get_uri(nodeCopy);
2299 const char* uriString = (const char*)librdf_uri_as_string(uri);
2300 expression = buildEntityFunc(QString::fromUtf8(uriString));
2301 CAxiomExpression* declExpression = mOntologyBuilder->getDeclaration(expression);
2302 handleParsedOntologyAxiomExpression(declExpression);
2303 } else {
2304 expression = expression;
2305 }
2306 CRedlandNodeProcessingData*& processingData = nodeIdentifierDataHash[CRedlandNodeHasher(nodeCopy)];
2307 if (!processingData) {
2308 processingData = new CRedlandNodeProcessingData(nodeCopy, expression);
2309 nodeHandlingList.append(processingData);
2310 } else {
2311 librdf_free_node(nodeCopy);
2312 }
2313 return this;
2314 }
2315
2316
2317
2318
2319
2320 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::addBaseNodeExpression(const char* uri, CBuildExpression* expr, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>& nodeHandlingList, CRedlandStoredTriplesData* redlandTriplesData) {
2321 librdf_node* node = librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)uri);
2322 addBaseNodeExpression(node, expr, nodeIdentifierDataHash, nodeHandlingList);
2323 librdf_free_node(node);
2324 return this;
2325 }
2326
2327
2328
2329 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::addBaseNodeExpression(librdf_node* node, CBuildExpression* expression, QHash<CRedlandNodeHasher, CRedlandNodeProcessingData*>& nodeIdentifierDataHash, QList<CRedlandNodeProcessingData*>& nodeHandlingList) {
2330 librdf_node* nodeCopy = librdf_new_node_from_node(node);
2331 CRedlandNodeProcessingData*& processingData = nodeIdentifierDataHash[CRedlandNodeHasher(nodeCopy)];
2332 if (!processingData) {
2333 processingData = new CRedlandNodeProcessingData(nodeCopy, expression);
2334 nodeHandlingList.append(processingData);
2335 }
2336 return this;
2337 }
2338
2339
2340
2341
2342
2343 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::handleClassExpressionRestriction(librdf_node* node) {
2344 bool anonym = true;
2345 CBuildExpression* expression = nullptr;
2346 librdf_node* nodeCopy = librdf_new_node_from_node(node);
2347 CRedlandNodeProcessingData*& processingData = mClassNodeIdentifierDataHash[CRedlandNodeHasher(nodeCopy)];
2348 if (!processingData) {
2349 processingData = new CRedlandNodeProcessingData(nodeCopy, expression);
2350 mClassNodeHandlingList.append(processingData);
2351 } else {
2352 librdf_free_node(nodeCopy);
2353 }
2354 return this;
2355 }
2356
2357
2358 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandTripleStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getPartialStatementFilteredTripleStream(librdf_statement* partialFilteringStatement) {
2359 librdf_stream* stream = librdf_model_find_statements(mRedlandTriplesData->getRedlandIndexedModel(), partialFilteringStatement);
2360 return createRedlandTripleStreamWrapper()->init(stream);
2361 }
2362
2363
2364
2365 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::initTripleDataProcessing(CRedlandStoredTriplesData* redlandTriplesData) {
2366 mRedlandTriplesData = redlandTriplesData;
2367
2368 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_CLASS, mPartialFilteringStatementForAllRDFTypeOfOwlClass);
2369 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_RESTRICTION, mPartialFilteringStatementForAllRDFTypeOfOwlRestriction);
2370 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_OBJECT_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfOwlObjectProperty);
2371 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_DATATYPE_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfOwlDataProperty);
2372 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_RDFS_DATATYPE, mPartialFilteringStatementForAllRDFTypeOfRDFSDatatype);
2373 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_NAMED_INDIVIDUAL, mPartialFilteringStatementForAllRDFTypeOfOwlNamedIndividual);
2374
2375 initPartialFilteringStatement(nullptr, PREFIX_OWL_INVERSE_OF, nullptr, mPartialFilteringStatementForOWLObjectInverseOfPredecessors);
2376 initPartialFilteringStatement(nullptr, PREFIX_OWL_INTERSECTION_OF, nullptr, mPartialFilteringStatementForOWLIntersectionOfSuccessors);
2377 initPartialFilteringStatement(nullptr, PREFIX_OWL_UNION_OF, nullptr, mPartialFilteringStatementForOWLUnionOfSuccessors);
2378 initPartialFilteringStatement(nullptr, PREFIX_RDF_FIRST, nullptr, mPartialFilteringStatementForRDFFirstSuccessors);
2379 initPartialFilteringStatement(nullptr, PREFIX_RDF_REST, nullptr, mPartialFilteringStatementForRDFRestSuccessors);
2380 initPartialFilteringStatement(nullptr, PREFIX_OWL_COMPLEMENT_OF, nullptr, mPartialFilteringStatementForOWLComplementOfSuccessors);
2381 initPartialFilteringStatement(nullptr, PREFIX_OWL_ONE_OF, nullptr, mPartialFilteringStatementForOWLOneOfSuccessors);
2382 initPartialFilteringStatement(nullptr, PREFIX_OWL_DATATYPE_COMPLEMENT_OF, nullptr, mPartialFilteringStatementForOWLDatatypeComplementOfSuccessors);
2383 initPartialFilteringStatement(nullptr, PREFIX_OWL_ON_DATATYPE, nullptr, mPartialFilteringStatementForOWLOnDatatypeSuccessors);
2384 initPartialFilteringStatement(nullptr, PREFIX_OWL_WITH_RESTRICTION, nullptr, mPartialFilteringStatementForOWLWithRestrictionSuccessors);
2385 initPartialFilteringStatement(nullptr, PREFIX_OWL_ON_PROPERTY, nullptr, mPartialFilteringStatementForOWLOnPropertySuccessors);
2386 initPartialFilteringStatement(nullptr, PREFIX_OWL_SOME_VALUES_FROM, nullptr, mPartialFilteringStatementForOWLSomeValuesFromSuccessors);
2387
2388
2389 initPartialFilteringStatement(nullptr, PREFIX_OWL_ALL_VALUES_FROM, nullptr, mPartialFilteringStatementForOWLAllValuesFromSuccessors);
2390 initPartialFilteringStatement(nullptr, PREFIX_OWL_HAS_VALUE, nullptr, mPartialFilteringStatementForOWLHasValueSuccessors);
2391 initPartialFilteringStatement(nullptr, PREFIX_OWL_HAS_SELF, nullptr, mPartialFilteringStatementForOWLHasSelfSuccessors);
2392 initPartialFilteringStatement(nullptr, PREFIX_OWL_MIN_CARDINALITY, nullptr, mPartialFilteringStatementForOWLMinCardinalitySuccessors);
2393 initPartialFilteringStatement(nullptr, PREFIX_OWL_MAX_CARDINALITY, nullptr, mPartialFilteringStatementForOWLMaxCardinalitySuccessors);
2394 initPartialFilteringStatement(nullptr, PREFIX_OWL_CARDINALITY, nullptr, mPartialFilteringStatementForOWLCardinalitySuccessors);
2395 initPartialFilteringStatement(nullptr, PREFIX_OWL_MIN_QUALIFIED_CARDINALITY, nullptr, mPartialFilteringStatementForOWLMinQualifiedCardinalitySuccessors);
2396 initPartialFilteringStatement(nullptr, PREFIX_OWL_MAX_QUALIFIED_CARDINALITY, nullptr, mPartialFilteringStatementForOWLMaxQualifiedCardinalitySuccessors);
2397 initPartialFilteringStatement(nullptr, PREFIX_OWL_QUALIFIED_CARDINALITY, nullptr, mPartialFilteringStatementForOWLQualifiedCardinalitySuccessors);
2398 initPartialFilteringStatement(nullptr, PREFIX_OWL_ON_DATA_RANGE, nullptr, mPartialFilteringStatementForOWLOnDataRangeSuccessors);
2399 initPartialFilteringStatement(nullptr, PREFIX_OWL_ON_CLASS, nullptr, mPartialFilteringStatementForOWLOnClassSuccessors);
2400
2401
2402
2403
2404 initPartialFilteringStatement(nullptr, PREFIX_RDFS_SUBPROPERTY_OF, nullptr, mPartialFilteringStatementForRDFSSubPropertySuccessors);
2405 initPartialFilteringStatement(nullptr, PREFIX_OWL_PROPERTY_CHAIN_AXIOM, nullptr, mPartialFilteringStatementForOWLPropertyChainAxiomSuccessors);
2406 initPartialFilteringStatement(nullptr, PREFIX_OWL_EQUIVALENT_PROPERTY, nullptr, mPartialFilteringStatementForOWLEquivalentPropertySuccessors);
2407 initPartialFilteringStatement(nullptr, PREFIX_OWL_PROPERTY_DISJOINT_WITH, nullptr, mPartialFilteringStatementForOWLPropertyDisjointWithSuccessors);
2408 initPartialFilteringStatement(nullptr, PREFIX_RDFS_RANGE, nullptr, mPartialFilteringStatementForRDFSRangeSuccessors);
2409 initPartialFilteringStatement(nullptr, PREFIX_RDFS_DOMAIN, nullptr, mPartialFilteringStatementForRDFSDomainSuccessors);
2410 initPartialFilteringStatement(nullptr, PREFIX_OWL_INVERSE_OF, nullptr, mPartialFilteringStatementForOWLInverseOfSuccessors);
2411
2412
2413 initPartialFilteringStatement(nullptr, PREFIX_RDFS_SUBCLASS_OF, nullptr, mPartialFilteringStatementForRDFSSubClassOfSuccessors);
2414 initPartialFilteringStatement(nullptr, PREFIX_OWL_EQUIVALENT_CLASS, nullptr, mPartialFilteringStatementForOWLEquivalentClassesSuccessors);
2415 initPartialFilteringStatement(nullptr, PREFIX_OWL_DISJOINT_WITH, nullptr, mPartialFilteringStatementForOWLDisjointClassesSuccessors);
2416 initPartialFilteringStatement(nullptr, PREFIX_OWL_DISJOINT_UNION_OF, nullptr, mPartialFilteringStatementForOWLDisjointUnionSuccessors);
2417
2418
2419
2420
2421
2422 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_ALL_DISJOINT_CLASSES, mPartialFilteringStatementForAllRDFTypeOfAllDisjointClasses);
2423 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_ALL_DISJOINT_PROPERTIES, mPartialFilteringStatementForAllRDFTypeOfAllDisjointProperties);
2424 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_ALL_DIFFERENT, mPartialFilteringStatementForAllRDFTypeOfAllDifferent);
2425 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_ALL_NEGATIVE_PROPERTY_ASSERTION, mPartialFilteringStatementForAllRDFTypeOfNegativePropertyAssertion);
2426
2427
2428
2429 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_FUNCTIONAL_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfFunctionalProperty);
2430 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_INVERSE_FUNCTIONAL_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfInverseFunctionalProperty);
2431 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_REFLEXIVE_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfReflexiveProperty);
2432 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_IRREFLEXIVE_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfIrreflexiveProperty);
2433 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_SYMMETRIC_PROPERTY, mPartialFilteringStatementForAllRDFTypeOSymmetricProperty);
2434 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_ASYMMETRIC_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfAsymmetricProperty);
2435 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, PREFIX_OWL_TRANSITIVE_PROPERTY, mPartialFilteringStatementForAllRDFTypeOfTransetiveProperty);
2436
2437
2438 initPartialFilteringStatement(nullptr, PREFIX_OWL_MEMBERS, nullptr, mPartialFilteringStatementForOWLMembers);
2439 initPartialFilteringStatement(nullptr, PREFIX_OWL_DISTINCT_MEMBERS, nullptr, mPartialFilteringStatementForOWLDistinctMembers);
2440
2441 initPartialFilteringStatement(nullptr, PREFIX_OWL_SOURCE_INDIVIDUAL, nullptr, mPartialFilteringStatementForOWLSourceIndividualSuccessors);
2442 initPartialFilteringStatement(nullptr, PREFIX_OWL_ASSERTION_PROPERTY, nullptr, mPartialFilteringStatementForOWLTargetIndividualSuccessors);
2443 initPartialFilteringStatement(nullptr, PREFIX_OWL_TARGET_INDIVIDUAL, nullptr, mPartialFilteringStatementForOWLTargetValueSuccessors);
2444 initPartialFilteringStatement(nullptr, PREFIX_OWL_TARGET_VALUE, nullptr, mPartialFilteringStatementForOWLAssertionPropertySuccessors);
2445
2446
2447 initPartialFilteringStatement(nullptr, PREFIX_RDF_TYPE, nullptr, mPartialFilteringStatementForOWLAllRDFTypePredecessors);
2448 initPartialFilteringStatement(nullptr, PREFIX_OWL_DIFFERENT_FROM, nullptr, mPartialFilteringStatementForOWLDifferentIndividuals);
2449 initPartialFilteringStatement(nullptr, PREFIX_OWL_SAME_AS, nullptr, mPartialFilteringStatementForOWLSameIndividuals);
2450
2451
2452 initPartialFilteringStatement(nullptr, nullptr, nullptr, mPartialFilteringStatementForOWLPropertyAssertions);
2453 initPartialFilteringStatement(nullptr, nullptr, nullptr, mPartialFilteringStatementForOWLDataRanges);
2454 initPartialFilteringStatement(nullptr, nullptr, nullptr, mPartialFilteringStatementForOWLClasses);
2455 initPartialFilteringStatement(nullptr, nullptr, nullptr, mPartialFilteringStatementForOWLFacets);
2456 initPartialFilteringStatement(nullptr, nullptr, nullptr, mPartialFilteringStatementForOWLAxioms);
2457 initPartialFilteringStatement(nullptr, nullptr, nullptr, mPartialFilteringStatementForOWLFacetSuccessors);
2458
2459
2460
2461
2462
2463
2464
2465 initPredicateIndexMapping(PREFIX_OWL_INTERSECTION_OF, mOWLIntersectionOfPredicateIndex, &mDataRangePredicateIndexUriNodeHash, &mDataRangePredicateIndexHash);
2466 initPredicateIndexMapping(PREFIX_OWL_UNION_OF, mOWLUnionOfPredicateIndex, &mDataRangePredicateIndexUriNodeHash, &mDataRangePredicateIndexHash);
2467 initPredicateIndexMapping(PREFIX_OWL_DATATYPE_COMPLEMENT_OF, mOWLDatatypeComplementOfPredicateIndex, &mDataRangePredicateIndexUriNodeHash, &mDataRangePredicateIndexHash);
2468 initPredicateIndexMapping(PREFIX_OWL_ONE_OF, mOWLOneOfPredicateIndex, &mDataRangePredicateIndexUriNodeHash, &mDataRangePredicateIndexHash);
2469 initPredicateIndexMapping(PREFIX_OWL_ON_DATATYPE, mOWLOnDatatypePredicateIndex, &mDataRangePredicateIndexUriNodeHash, &mDataRangePredicateIndexHash);
2470 initPredicateIndexMapping(PREFIX_OWL_WITH_RESTRICTION, mOWLWithRestrictionPredicateIndex, &mDataRangePredicateIndexUriNodeHash, &mDataRangePredicateIndexHash);
2471
2472
2473 initPredicateIndexMapping(PREFIX_OWL_INTERSECTION_OF, mOWLIntersectionOfPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2474 initPredicateIndexMapping(PREFIX_OWL_UNION_OF, mOWLUnionOfPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2475 initPredicateIndexMapping(PREFIX_OWL_ONE_OF, mOWLOneOfPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2476 initPredicateIndexMapping(PREFIX_OWL_COMPLEMENT_OF, mOWLComplementOfPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2477 initPredicateIndexMapping(PREFIX_OWL_ON_PROPERTY, mOWLOnPropertyPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2478 initPredicateIndexMapping(PREFIX_OWL_SOME_VALUES_FROM, mOWLSomeValuesFromPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2479 initPredicateIndexMapping(PREFIX_OWL_ALL_VALUES_FROM, mOWLAllValuesFromPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2480 initPredicateIndexMapping(PREFIX_OWL_HAS_VALUE, mOWLHasValuePredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2481 initPredicateIndexMapping(PREFIX_OWL_HAS_SELF, mOWLHasSelfPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2482 initPredicateIndexMapping(PREFIX_OWL_ON_CLASS, mOWLOnClassPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2483 initPredicateIndexMapping(PREFIX_OWL_MIN_QUALIFIED_CARDINALITY, mOWLMinQualifiedCardinalityPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2484 initPredicateIndexMapping(PREFIX_OWL_MAX_QUALIFIED_CARDINALITY, mOWLMaxQualifiedCardinalityPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2485 initPredicateIndexMapping(PREFIX_OWL_QUALIFIED_CARDINALITY, mOWLQualifiedCardinalityPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2486 initPredicateIndexMapping(PREFIX_OWL_MIN_CARDINALITY, mOWLMinCardinalityPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2487 initPredicateIndexMapping(PREFIX_OWL_MAX_CARDINALITY, mOWLMaxCardinalityPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2488 initPredicateIndexMapping(PREFIX_OWL_CARDINALITY, mOWLCardinalityPredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2489 initPredicateIndexMapping(PREFIX_OWL_ON_DATA_RANGE, mOWLOnDataRangePredicateIndex, &mClassPredicateIndexUriNodeHash, &mClassPredicateIndexHash);
2490
2491
2492
2493
2494 initPredicateIndexMapping(PREFIX_RDFS_SUBCLASS_OF, mOWLClassAxiomSubClassOfPredicateIndex, &mClassBasedAxiomPredicateIndexUriNodeHash, &mClassBasedAxiomPredicateIndexHash);
2495 initPredicateIndexMapping(PREFIX_OWL_EQUIVALENT_CLASS, mOWLClassAxiomEquvialentClassPredicateIndex, &mClassBasedAxiomPredicateIndexUriNodeHash, &mClassBasedAxiomPredicateIndexHash);
2496 initPredicateIndexMapping(PREFIX_OWL_DISJOINT_WITH, mOWLClassAxiomDisjointWithPredicateIndex, &mClassBasedAxiomPredicateIndexUriNodeHash, &mClassBasedAxiomPredicateIndexHash);
2497 initPredicateIndexMapping(PREFIX_OWL_DISJOINT_UNION_OF, mOWLClassAxiomDisjointUnionOfPredicateIndex, &mClassBasedAxiomPredicateIndexUriNodeHash, &mClassBasedAxiomPredicateIndexHash);
2498
2499 initPredicateIndexMapping(PREFIX_RDFS_SUBPROPERTY_OF, mOWLPredicateBasedAxiomSubPropertyOfPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2500 initPredicateIndexMapping(PREFIX_OWL_PROPERTY_CHAIN_AXIOM, mOWLPredicateBasedAxiomPropertyChainAxiomPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2501 initPredicateIndexMapping(PREFIX_OWL_EQUIVALENT_PROPERTY, mOWLPredicateBasedAxiomEquivalentPropertyPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2502 initPredicateIndexMapping(PREFIX_OWL_PROPERTY_DISJOINT_WITH, mOWLPredicateBasedAxiomPropertyDisjointWithPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2503 initPredicateIndexMapping(PREFIX_RDFS_DOMAIN, mOWLPredicateBasedAxiomDomainPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2504 initPredicateIndexMapping(PREFIX_RDFS_RANGE, mOWLPredicateBasedAxiomRangePredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2505 initPredicateIndexMapping(PREFIX_OWL_INVERSE_OF, mOWLPredicateBasedAxiomInverseOfPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2506 initPredicateIndexMapping(PREFIX_RDF_TYPE, mRDFPredicateBasedAxiomTypeOfPredicateIndex, &mPropertyBasedAxiomPredicateIndexUriNodeHash, &mPropertyBasedAxiomPredicateIndexHash);
2507
2508
2509 initPredicateIndexMapping(PREFIX_OWL_FUNCTIONAL_PROPERTY, mOWLPredicateBasedAxiomTypeFunctionalPropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2510 initPredicateIndexMapping(PREFIX_OWL_INVERSE_FUNCTIONAL_PROPERTY, mOWLPredicateBasedAxiomTypeInverseFunctionalPropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2511 initPredicateIndexMapping(PREFIX_OWL_REFLEXIVE_PROPERTY, mOWLPredicateBasedAxiomTypeReflexivePropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2512 initPredicateIndexMapping(PREFIX_OWL_IRREFLEXIVE_PROPERTY, mOWLPredicateBasedAxiomTypeIrreflexivePropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2513 initPredicateIndexMapping(PREFIX_OWL_SYMMETRIC_PROPERTY, mOWLPredicateBasedAxiomTypeSymmetricPropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2514 initPredicateIndexMapping(PREFIX_OWL_ASYMMETRIC_PROPERTY, mOWLPredicateBasedAxiomTypeAsymmetricPropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2515 initPredicateIndexMapping(PREFIX_OWL_TRANSITIVE_PROPERTY, mOWLPredicateBasedAxiomTypeTransitivePropertyObjectIndex, &mPropertyBasedAxiomObjectIndexUriNodeHash, &mPropertyBasedAxiomObjectIndexHash);
2516
2517
2518 mFacetUriNodeHash.insert(PREFIX_MIN_INCLUSIVE_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_MIN_INCLUSIVE_FACET));
2519 mFacetUriNodeHash.insert(PREFIX_MIN_EXCLUSIVE_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_MIN_EXCLUSIVE_FACET));
2520 mFacetUriNodeHash.insert(PREFIX_MAX_INCLUSIVE_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_MAX_INCLUSIVE_FACET));
2521 mFacetUriNodeHash.insert(PREFIX_MAX_EXCLUSIVE_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_MAX_EXCLUSIVE_FACET));
2522 mFacetUriNodeHash.insert(PREFIX_MAX_LENGTH_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_MAX_LENGTH_FACET));
2523 mFacetUriNodeHash.insert(PREFIX_MIN_LENGTH_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_MIN_LENGTH_FACET));
2524 mFacetUriNodeHash.insert(PREFIX_LENGTH_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_LENGTH_FACET));
2525 mFacetUriNodeHash.insert(PREFIX_PATTERN_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_PATTERN_FACET));
2526 mFacetUriNodeHash.insert(PREFIX_LANGUAGE_RANGE_FACET, librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_LANGUAGE_RANGE_FACET));
2527
2528 mRDFNilNode = librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_RDF_NIL);
2529
2530
2531 mBooleanDatatypeUri = librdf_new_uri(redlandTriplesData->getRedlandWorld(), (const unsigned char*)PREFIX_XML_BOOLEAN_DATATYPE);
2532
2533
2534 initDatatypeMapping(redlandTriplesData, PREFIX_OWL_TOP_DATATYPE);
2535 initDatatypeMapping(redlandTriplesData, PREFIX_OWL_BOTTOM_DATATYPE);
2536 initDatatypeMapping(redlandTriplesData, PREFIX_OWL_REAL_DATATYPE);
2537 initDatatypeMapping(redlandTriplesData, PREFIX_OWL_RATIONAL_DATATYPE);
2538 initDatatypeMapping(redlandTriplesData, PREFIX_XML_INTEGER_DATATYPE);
2539 initDatatypeMapping(redlandTriplesData, PREFIX_XML_DECIMAL_DATATYPE);
2540 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NONNEGATIVEINTEGER_DATATYPE);
2541 initDatatypeMapping(redlandTriplesData, PREFIX_XML_POSITIVEINTEGER_DATATYPE);
2542 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NONPOSITIVEINTEGER_DATATYPE);
2543 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NEGATIVEINTEGER_DATATYPE);
2544 initDatatypeMapping(redlandTriplesData, PREFIX_XML_LONG_DATATYPE);
2545 initDatatypeMapping(redlandTriplesData, PREFIX_XML_INT_DATATYPE);
2546 initDatatypeMapping(redlandTriplesData, PREFIX_XML_SHORT_DATATYPE);
2547 initDatatypeMapping(redlandTriplesData, PREFIX_XML_BYTE_DATATYPE);
2548 initDatatypeMapping(redlandTriplesData, PREFIX_XML_UNSIGNEDLONG_DATATYPE);
2549 initDatatypeMapping(redlandTriplesData, PREFIX_XML_UNSIGNEDINT_DATATYPE);
2550 initDatatypeMapping(redlandTriplesData, PREFIX_XML_UNSIGNEDSHORT_DATATYPE);
2551 initDatatypeMapping(redlandTriplesData, PREFIX_XML_UNSIGNEDBYTE_DATATYPE);
2552 initDatatypeMapping(redlandTriplesData, PREFIX_XML_PLAINLITERAL_DATATYPE);
2553 initDatatypeMapping(redlandTriplesData, PREFIX_XML_STRING_DATATYPE);
2554 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NORMALIZEDSTRING_DATATYPE);
2555 initDatatypeMapping(redlandTriplesData, PREFIX_XML_TOKEN_DATATYPE);
2556 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NAME_DATATYPE);
2557 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NCNAME_DATATYPE);
2558 initDatatypeMapping(redlandTriplesData, PREFIX_XML_NMTOKEN_DATATYPE);
2559 initDatatypeMapping(redlandTriplesData, PREFIX_XML_LANGUAGE_DATATYPE);
2560 initDatatypeMapping(redlandTriplesData, PREFIX_XML_BOOLEAN_DATATYPE);
2561 initDatatypeMapping(redlandTriplesData, PREFIX_XML_DOUBLE_DATATYPE);
2562 initDatatypeMapping(redlandTriplesData, PREFIX_XML_FLOAT_DATATYPE);
2563 initDatatypeMapping(redlandTriplesData, PREFIX_XML_IRI_DATATYPE);
2564 initDatatypeMapping(redlandTriplesData, PREFIX_XML_BINARYHEX_DATATYPE);
2565 initDatatypeMapping(redlandTriplesData, PREFIX_XML_BINARYBASE64_DATATYPE);
2566 initDatatypeMapping(redlandTriplesData, PREFIX_XML_XML_DATATYPE);
2567 initDatatypeMapping(redlandTriplesData, PREFIX_XML_DATETIME_DATATYPE);
2568 initDatatypeMapping(redlandTriplesData, PREFIX_XML_DATETIMESTAMP_DATATYPE);
2569
2570
2571
2572 addBaseNodeExpression(PREFIX_OWL_THING, mOntologyBuilder->getTopClass(), mClassNodeIdentifierDataHash, mClassNodeHandlingList, redlandTriplesData);
2573 addBaseNodeExpression(PREFIX_OWL_NOTHING, mOntologyBuilder->getBottomClass(), mClassNodeIdentifierDataHash, mClassNodeHandlingList, redlandTriplesData);
2574 addBaseNodeExpression(PREFIX_OWL_TOPOBJECTPROPERTY, mOntologyBuilder->getTopObjectProberty(), mObjectPropertyNodeIdentifierDataHash, mObjectPropertyNodeHandlingList, redlandTriplesData);
2575 addBaseNodeExpression(PREFIX_OWL_BOTTOMOBJECTPROPERTY, mOntologyBuilder->getBottomObjectProberty(), mObjectPropertyNodeIdentifierDataHash, mObjectPropertyNodeHandlingList, redlandTriplesData);
2576 addBaseNodeExpression(PREFIX_OWL_TOPDATAPROPERTY, mOntologyBuilder->getTopObjectProberty(), mDataPropertyNodeIdentifierDataHash, mDataPropertyNodeHandlingList, redlandTriplesData);
2577 addBaseNodeExpression(PREFIX_OWL_BOTTOMDATAPROPERTY, mOntologyBuilder->getTopObjectProberty(), mDataPropertyNodeIdentifierDataHash, mDataPropertyNodeHandlingList, redlandTriplesData);
2578 addBaseNodeExpression(PREFIX_OWL_TOP_DATATYPE, mOntologyBuilder->getTopDataRange(), mDatatypeNodeIdentifierDataHash, mDatatypeNodeHandlingList, redlandTriplesData);
2579 addBaseNodeExpression(PREFIX_OWL_BOTTOM_DATATYPE, mOntologyBuilder->getBottomDataRange(), mDatatypeNodeIdentifierDataHash, mDatatypeNodeHandlingList, redlandTriplesData);
2580
2581 return this;
2582 }
2583
2584
2585
2586
2587 librdf_node* CConcreteOntologyRedlandTriplesDataExpressionMapper::initDatatypeMapping(CRedlandStoredTriplesData* redlandTriplesData, const char* datatypeIri) {
2588 librdf_node* datatypeNode = librdf_new_node_from_uri_string(redlandTriplesData->getRedlandWorld(), (const unsigned char*)datatypeIri);
2589 CRedlandNodeProcessingData* datatypeProcessingData = new CRedlandNodeProcessingData(datatypeNode, mOntologyBuilder->getDatatype(datatypeIri));
2590 mDatatypeNodeIdentifierDataHash.insert(datatypeNode, datatypeProcessingData);
2591 return datatypeNode;
2592 }
2593
2594
2595 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::clearTripleDataProcessing() {
2596
2597
2598 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfOwlClass);
2599 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfOwlRestriction);
2600 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfOwlObjectProperty);
2601 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfOwlDataProperty);
2602 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfRDFSDatatype);
2603 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfOwlNamedIndividual);
2604
2605 clearPartialFilteringStatement(mPartialFilteringStatementForRDFFirstSuccessors);
2606 clearPartialFilteringStatement(mPartialFilteringStatementForRDFRestSuccessors);
2607
2608 clearPartialFilteringStatement(mPartialFilteringStatementForOWLComplementOfSuccessors);
2609 clearPartialFilteringStatement(mPartialFilteringStatementForOWLOneOfSuccessors);
2610 clearPartialFilteringStatement(mPartialFilteringStatementForOWLDatatypeComplementOfSuccessors);
2611 clearPartialFilteringStatement(mPartialFilteringStatementForOWLOnDatatypeSuccessors);
2612 clearPartialFilteringStatement(mPartialFilteringStatementForOWLWithRestrictionSuccessors);
2613 clearPartialFilteringStatement(mPartialFilteringStatementForOWLFacets);
2614 clearPartialFilteringStatement(mPartialFilteringStatementForOWLFacetSuccessors);
2615 clearPartialFilteringStatement(mPartialFilteringStatementForOWLOnPropertySuccessors);
2616 clearPartialFilteringStatement(mPartialFilteringStatementForOWLSomeValuesFromSuccessors);
2617 clearPartialFilteringStatement(mPartialFilteringStatementForOWLAllValuesFromSuccessors);
2618 clearPartialFilteringStatement(mPartialFilteringStatementForOWLHasValueSuccessors);
2619 clearPartialFilteringStatement(mPartialFilteringStatementForOWLHasSelfSuccessors);
2620 clearPartialFilteringStatement(mPartialFilteringStatementForOWLMinCardinalitySuccessors);
2621 clearPartialFilteringStatement(mPartialFilteringStatementForOWLMaxCardinalitySuccessors);
2622 clearPartialFilteringStatement(mPartialFilteringStatementForOWLCardinalitySuccessors);
2623 clearPartialFilteringStatement(mPartialFilteringStatementForOWLMinQualifiedCardinalitySuccessors);
2624 clearPartialFilteringStatement(mPartialFilteringStatementForOWLMaxQualifiedCardinalitySuccessors);
2625 clearPartialFilteringStatement(mPartialFilteringStatementForOWLQualifiedCardinalitySuccessors);
2626 clearPartialFilteringStatement(mPartialFilteringStatementForOWLOnDataRangeSuccessors);
2627 clearPartialFilteringStatement(mPartialFilteringStatementForOWLOnClassSuccessors);
2628
2629 clearPartialFilteringStatement(mPartialFilteringStatementForOWLObjectInverseOfPredecessors);
2630
2631 clearPartialFilteringStatement(mPartialFilteringStatementForOWLIntersectionOfSuccessors);
2632 clearPartialFilteringStatement(mPartialFilteringStatementForOWLUnionOfSuccessors);
2633
2634 clearPartialFilteringStatement(mPartialFilteringStatementForOWLDataRanges);
2635 clearPartialFilteringStatement(mPartialFilteringStatementForOWLClasses);
2636 clearPartialFilteringStatement(mPartialFilteringStatementForOWLAxioms);
2637
2638 clearPartialFilteringStatement(mPartialFilteringStatementForRDFSSubPropertySuccessors);
2639 clearPartialFilteringStatement(mPartialFilteringStatementForOWLPropertyChainAxiomSuccessors);
2640 clearPartialFilteringStatement(mPartialFilteringStatementForOWLEquivalentPropertySuccessors);
2641 clearPartialFilteringStatement(mPartialFilteringStatementForOWLPropertyDisjointWithSuccessors);
2642 clearPartialFilteringStatement(mPartialFilteringStatementForRDFSRangeSuccessors);
2643 clearPartialFilteringStatement(mPartialFilteringStatementForRDFSDomainSuccessors);
2644 clearPartialFilteringStatement(mPartialFilteringStatementForOWLInverseOfSuccessors);
2645
2646 clearPartialFilteringStatement(mPartialFilteringStatementForRDFSSubClassOfSuccessors);
2647 clearPartialFilteringStatement(mPartialFilteringStatementForOWLEquivalentClassesSuccessors);
2648 clearPartialFilteringStatement(mPartialFilteringStatementForOWLDisjointClassesSuccessors);
2649 clearPartialFilteringStatement(mPartialFilteringStatementForOWLDisjointUnionSuccessors);
2650
2651 clearPartialFilteringStatement(mPartialFilteringStatementForOWLMembers);
2652 clearPartialFilteringStatement(mPartialFilteringStatementForOWLDistinctMembers);
2653 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfAllDisjointClasses);
2654 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfAllDisjointProperties);
2655 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfAllDifferent);
2656 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfNegativePropertyAssertion);
2657
2658
2659 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfFunctionalProperty);
2660 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfInverseFunctionalProperty);
2661 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfReflexiveProperty);
2662 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfIrreflexiveProperty);
2663 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOSymmetricProperty);
2664 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfAsymmetricProperty);
2665 clearPartialFilteringStatement(mPartialFilteringStatementForAllRDFTypeOfTransetiveProperty);
2666
2667
2668 clearPartialFilteringStatement(mPartialFilteringStatementForOWLSourceIndividualSuccessors);
2669 clearPartialFilteringStatement(mPartialFilteringStatementForOWLTargetIndividualSuccessors);
2670 clearPartialFilteringStatement(mPartialFilteringStatementForOWLTargetValueSuccessors);
2671 clearPartialFilteringStatement(mPartialFilteringStatementForOWLAssertionPropertySuccessors);
2672
2673 clearPartialFilteringStatement(mPartialFilteringStatementForOWLAllRDFTypePredecessors);
2674
2675 clearPartialFilteringStatement(mPartialFilteringStatementForOWLPropertyAssertions);
2676 clearPartialFilteringStatement(mPartialFilteringStatementForOWLDifferentIndividuals);
2677 clearPartialFilteringStatement(mPartialFilteringStatementForOWLSameIndividuals);
2678
2679
2680 for (QHash<const char*, librdf_node*>::const_iterator it = mFacetUriNodeHash.constBegin(), itEnd = mFacetUriNodeHash.constEnd(); it != itEnd; ++it) {
2681 librdf_free_node(it.value());
2682 }
2683 mFacetUriNodeHash.clear();
2684
2685 mClassNodeIdentifierDataHash.clear();
2686 mClassNodeHandlingList.clear();
2687 mObjectPropertyNodeIdentifierDataHash.clear();
2688 mObjectPropertyNodeHandlingList.clear();
2689 mDataPropertyNodeIdentifierDataHash.clear();
2690 mDataPropertyNodeHandlingList.clear();
2691 mDatatypeNodeIdentifierDataHash.clear();
2692 mDataLiteralNodeIdentifierDataHash.clear();
2693 mDatatypeNodeHandlingList.clear();
2694 mNamedIndividualNodeIdentifierDataHash.clear();
2695 mNamedIndividualNodeHandlingList.clear();
2696
2697 mDataFacetRestrictionHandlingContainerList.clear();
2698
2699 if (mBooleanDatatypeUri) {
2700 librdf_free_uri(mBooleanDatatypeUri);
2701 mBooleanDatatypeUri = nullptr;
2702 }
2703 if (mRDFNilNode) {
2704 librdf_free_node(mRDFNilNode);
2705 mRDFNilNode = nullptr;
2706 }
2707
2708 mClassPredicateIndexHash.clear();
2709 clearIndexUriHash(mClassPredicateIndexUriNodeHash);
2710
2711 mDataRangePredicateIndexHash.clear();
2712 clearIndexUriHash(mDataRangePredicateIndexUriNodeHash);
2713
2714 mClassBasedAxiomPredicateIndexHash.clear();
2715 clearIndexUriHash(mClassBasedAxiomPredicateIndexUriNodeHash);
2716
2717 mDatatypeBasedAxiomPredicateIndexHash.clear();
2718 clearIndexUriHash(mDatatypeBasedAxiomPredicateIndexUriNodeHash);
2719
2720 mPropertyBasedAxiomPredicateIndexHash.clear();
2721 clearIndexUriHash(mPropertyBasedAxiomPredicateIndexUriNodeHash);
2722
2723 mPropertyBasedAxiomObjectIndexHash.clear();
2724 clearIndexUriHash(mPropertyBasedAxiomObjectIndexUriNodeHash);
2725 return this;
2726 }
2727
2728
2729 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::clearPartialFilteringStatement(librdf_statement*& partialFilteringStatement) {
2730 if (partialFilteringStatement) {
2731 librdf_free_statement(partialFilteringStatement);
2732 partialFilteringStatement = nullptr;
2733 }
2734 return this;
2735 }
2736
2737
2738 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::clearIndexUriHash(QHash<cint64, librdf_node*>& indexUriNodeHash) {
2739 for (QHash<cint64, librdf_node*>::const_iterator it = indexUriNodeHash.constBegin(), itEnd = indexUriNodeHash.constEnd(); it != itEnd; ++it) {
2740 librdf_node* node = it.value();
2741 librdf_free_node(node);
2742 }
2743 indexUriNodeHash.clear();
2744 return this;
2745 }
2746
2747
2748
2749
2750 librdf_node* CConcreteOntologyRedlandTriplesDataExpressionMapper::initPredicateIndexMapping(const char* predicateUriChar, cint64 predicateIndex, QHash<cint64, librdf_node*>* predicateIndexUriNodeHash, QHash<CRedlandNodeHasher, cint64>* predicateNodeIndexHash) {
2751 librdf_uri* predicateUri = librdf_new_uri(mRedlandTriplesData->getRedlandWorld(), (const unsigned char*)predicateUriChar);
2752 librdf_node* predicateNode = librdf_new_node_from_uri(mRedlandTriplesData->getRedlandWorld(), predicateUri);
2753 predicateIndexUriNodeHash->insert(predicateIndex, predicateNode);
2754 predicateNodeIndexHash->insert(CRedlandNodeHasher(predicateNode), predicateIndex);
2755 return predicateNode;
2756 }
2757
2758
2759
2760 librdf_statement* CConcreteOntologyRedlandTriplesDataExpressionMapper::initPartialFilteringStatement(const char* subjectFilterUri, const char* predicateFilterUri, const char* objectFilterUri, librdf_statement*& partialFilteringStatement) {
2761 if (partialFilteringStatement) {
2762 librdf_free_statement(partialFilteringStatement);
2763 partialFilteringStatement = nullptr;
2764 }
2765 librdf_statement* partial_statement = librdf_new_statement(mRedlandTriplesData->getRedlandWorld());
2766 librdf_node* subject = nullptr;
2767 if (subjectFilterUri) {
2768 subject = librdf_new_node_from_uri_string(mRedlandTriplesData->getRedlandWorld(), (const unsigned char*)subjectFilterUri);
2769 librdf_statement_set_subject(partial_statement, subject);
2770 }
2771 librdf_node* predicate = nullptr;
2772 if (predicateFilterUri) {
2773 predicate = librdf_new_node_from_uri_string(mRedlandTriplesData->getRedlandWorld(), (const unsigned char*)predicateFilterUri);
2774 librdf_statement_set_predicate(partial_statement, predicate);
2775 }
2776 librdf_node* object = nullptr;
2777 if (objectFilterUri) {
2778 object = librdf_new_node_from_uri_string(mRedlandTriplesData->getRedlandWorld(), (const unsigned char*)objectFilterUri);
2779 librdf_statement_set_object(partial_statement, object);
2780 }
2781 partialFilteringStatement = partial_statement;
2782 return partial_statement;
2783 }
2784
2785
2786 librdf_statement* CConcreteOntologyRedlandTriplesDataExpressionMapper::getAdaptedPartialFilteringStatement(librdf_node* subjectFilterNode, librdf_node* predicateFilterNode, librdf_node* objectFilterNode, librdf_statement*& partialFilteringStatement) {
2787 librdf_node* subject = nullptr;
2788 if (subjectFilterNode) {
2789 subject = librdf_new_node_from_node(subjectFilterNode);
2790 librdf_statement_set_subject(partialFilteringStatement, subject);
2791 }
2792 librdf_node* predicate = nullptr;
2793 if (predicateFilterNode) {
2794 predicate = librdf_new_node_from_node(predicateFilterNode);
2795 librdf_statement_set_predicate(partialFilteringStatement, predicate);
2796 }
2797 librdf_node* object = nullptr;
2798 if (objectFilterNode) {
2799 object = librdf_new_node_from_node(objectFilterNode);
2800 librdf_statement_set_object(partialFilteringStatement, object);
2801 }
2802 return partialFilteringStatement;
2803 }
2804
2805
2806 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLIntersectionOfSuccessorNodesStream(librdf_node* currentNode) {
2807 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLIntersectionOfSuccessors)), 2);
2808 }
2809
2810 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLUnionOfSuccessorNodesStream(librdf_node* currentNode) {
2811 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLUnionOfSuccessors)), 2);
2812 }
2813
2814 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLComplementOfSuccessorNodesStream(librdf_node* currentNode) {
2815 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLComplementOfSuccessors)), 2);
2816 }
2817
2818 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLOneOfSuccessorNodesStream(librdf_node* currentNode) {
2819 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLOneOfSuccessors)), 2);
2820 }
2821
2822 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLDatatypeComplementOfSuccessorNodesStream(librdf_node* currentNode) {
2823 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLDatatypeComplementOfSuccessors)), 2);
2824 }
2825
2826
2827 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLOnDatatypeSuccessorNodesStream(librdf_node* currentNode) {
2828 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLOnDatatypeSuccessors)), 2);
2829 }
2830
2831 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLWithRestrictionSuccessorNodesStream(librdf_node* currentNode) {
2832 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLWithRestrictionSuccessors)), 2);
2833 }
2834
2835
2836 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLOnPropertySuccessorNodesStream(librdf_node* currentNode) {
2837 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLOnPropertySuccessors)), 2);
2838 }
2839
2840
2841
2842 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLSomeValuesFromSuccessorNodesStream(librdf_node* currentNode) {
2843 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLSomeValuesFromSuccessors)), 2);
2844 }
2845
2846 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLAllValuesFromSuccessorNodesStream(librdf_node* currentNode) {
2847 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLAllValuesFromSuccessors)), 2);
2848 }
2849
2850 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLHasValueSuccessorNodesStream(librdf_node* currentNode) {
2851 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLHasValueSuccessors)), 2);
2852 }
2853
2854 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLHasSelfSuccessorNodesStream(librdf_node* currentNode) {
2855 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLHasSelfSuccessors)), 2);
2856 }
2857
2858 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLMinCardinalitySuccessorNodesStream(librdf_node* currentNode) {
2859 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLMinCardinalitySuccessors)), 2);
2860 }
2861
2862 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLMaxCardinalitySuccessorNodesStream(librdf_node* currentNode) {
2863 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLMaxCardinalitySuccessors)), 2);
2864 }
2865
2866 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLCardinalitySuccessorNodesStream(librdf_node* currentNode) {
2867 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLCardinalitySuccessors)), 2);
2868 }
2869
2870 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLMinQualifiedCardinalitySuccessorNodesStream(librdf_node* currentNode) {
2871 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLMinQualifiedCardinalitySuccessors)), 2);
2872 }
2873
2874 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLMaxQualifiedCardinalitySuccessorNodesStream(librdf_node* currentNode) {
2875 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLMaxQualifiedCardinalitySuccessors)), 2);
2876 }
2877
2878 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLQualifiedCardinalitySuccessorNodesStream(librdf_node* currentNode) {
2879 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLQualifiedCardinalitySuccessors)), 2);
2880 }
2881
2882 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLOnDataRangeSuccessorNodesStream(librdf_node* currentNode) {
2883 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLOnDataRangeSuccessors)), 2);
2884 }
2885
2886 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLOnClassSuccessorNodesStream(librdf_node* currentNode) {
2887 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(currentNode, nullptr, nullptr, mPartialFilteringStatementForOWLOnClassSuccessors)), 2);
2888 }
2889
2890
2891
2892 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLObjectInverseOfPredecessorNodesStream(librdf_node* currentNode) {
2893 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(getAdaptedPartialFilteringStatement(nullptr, nullptr, currentNode, mPartialFilteringStatementForOWLObjectInverseOfPredecessors)), 0);
2894 }
2895
2896 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLClassInstanceNodesStream() {
2897 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfOwlClass), 0);
2898 }
2899
2900 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLRestrictionInstanceNodesStream() {
2901 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfOwlRestriction), 0);
2902 }
2903
2904 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLObjectPropertyInstanceNodesStream() {
2905 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfOwlObjectProperty), 0);
2906 }
2907
2908 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLDatatypePropertyInstanceNodesStream() {
2909 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfOwlDataProperty), 0);
2910 }
2911
2912 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getRDFSDatatypeInstanceNodesStream() {
2913 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfRDFSDatatype), 0);
2914 }
2915
2916 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLNamedIndividualInstanceNodesStream() {
2917 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfOwlNamedIndividual), 0);
2918 }
2919
2920
2921
2922 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLAllDisjointClassesInstanceNodesStream() {
2923 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfAllDisjointClasses), 0);
2924 }
2925
2926
2927 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLAllDisjointPropertiesInstanceNodesStream() {
2928 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfAllDisjointProperties), 0);
2929 }
2930
2931
2932 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLAllDifferentInstanceNodesStream() {
2933 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfAllDifferent), 0);
2934 }
2935
2936 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLAllNegativePropertyAssertionInstanceNodesStream() {
2937 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfNegativePropertyAssertion), 0);
2938 }
2939
2940
2941
2942
2943 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLFunctionalPropertyInstanceNodesStream() {
2944 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfFunctionalProperty), 0);
2945 }
2946
2947 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLInverseFunctionalPropertyInstanceNodesStream() {
2948 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfInverseFunctionalProperty), 0);
2949 }
2950
2951 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLReflexivePropertyInstanceNodesStream() {
2952 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfReflexiveProperty), 0);
2953 }
2954
2955 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLIrreflexivePropertyInstanceNodesStream() {
2956 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfIrreflexiveProperty), 0);
2957 }
2958
2959 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLSymmetricPropertyInstanceNodesStream() {
2960 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOSymmetricProperty), 0);
2961 }
2962
2963 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLAsymmetricPropertyInstanceNodesStream() {
2964 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfAsymmetricProperty), 0);
2965 }
2966
2967 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::getOWLTransetivePropertyInstanceNodesStream() {
2968 return createRedlandNodeStreamWrapper()->init(getPartialStatementFilteredTripleStream(mPartialFilteringStatementForAllRDFTypeOfTransetiveProperty), 0);
2969 }
2970
2971
2972 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandTripleStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::createRedlandTripleStreamWrapper() {
2973 CRedlandTripleStream* nextWrapper = mFreeTripleStreamWrappers;
2974 if (mFreeTripleStreamWrappers) {
2975 mFreeTripleStreamWrappers = mFreeTripleStreamWrappers->getNext();
2976 nextWrapper->clearNext();
2977 } else {
2978 nextWrapper = new CRedlandTripleStream();
2979 }
2980 return nextWrapper;
2981 }
2982
2983 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::releaseRedlandTripleStreamWrapper(CRedlandTripleStream* streamWrapper) {
2984 mFreeTripleStreamWrappers = streamWrapper->clear()->append(mFreeTripleStreamWrappers);
2985 return this;
2986 }
2987
2988
2989 CConcreteOntologyRedlandTriplesDataExpressionMapper::CRedlandNodeStream* CConcreteOntologyRedlandTriplesDataExpressionMapper::createRedlandNodeStreamWrapper() {
2990 CRedlandNodeStream* nextWrapper = mFreeNodeStreamWrappers;
2991 if (mFreeNodeStreamWrappers) {
2992 mFreeNodeStreamWrappers = mFreeNodeStreamWrappers->getNext();
2993 nextWrapper->clearNext();
2994 } else {
2995 nextWrapper = new CRedlandNodeStream();
2996 }
2997 return nextWrapper;
2998 }
2999
3000 CConcreteOntologyRedlandTriplesDataExpressionMapper* CConcreteOntologyRedlandTriplesDataExpressionMapper::releaseRedlandNodeStreamWrapper(CRedlandNodeStream* streamWrapper) {
3001 mFreeNodeStreamWrappers = streamWrapper->clear([this](CRedlandTripleStream* streamWrapper) { releaseRedlandTripleStreamWrapper(streamWrapper); })->append(mFreeNodeStreamWrappers);
3002 return this;
3003 }
3004
3005
3006 }; // end namespace Generator
3007
3008 }; // end namespace Reasoner
3009
3010 }; // end namespace Konclude
3011
3012 #endif // !KONCLUDE_REDLAND_INTEGRATION