Debian Codegraph @

Source/Renderer/COntologyAxiomExpressionsRenderVisitor.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 #include "COntologyAxiomExpressionsRenderVisitor.h"
21
22
23 namespace Konclude {
24
25 namespace Renderer {
26
27
28 COntologyAxiomExpressionsRenderVisitor::COntologyAxiomExpressionsRenderVisitor() {
29 }
30
31
32
33
34
35
36 bool COntologyAxiomExpressionsRenderVisitor::visitAndRender(const CQtList<CAxiomExpression*>& axiomList, CConcreteOntology* ontology, COntologyRenderer* renderer) {
37 mOntology = ontology;
38 mRenderer = renderer;
39 COntologyBuildData* buildDataBox = ontology->getBuildData();
40 mConceptClassTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptClassTermMappingHash();
41 mClassTermExpClassAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermExpressionClassAxiomExpressionHash();
42 mRoleObjectPropertyTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
43 mRoleDataPropertyTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleDataPropertyTermMappingHash();
44 mDatatypeDatatypeExpHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDatatypeDatatypeExpessionHash();
45
46 CRenderedItemLinker* renderedLinker = nullptr;
47 CRenderedItemLinker* lastRenderedLinker = nullptr;
48 mRenderer->beginRender();
49 foreach(CAxiomExpression* axiomExpression, axiomList) {
50 CRenderedItemLinker* tmpRenderedLinker = getRenderedAxiomExpression(axiomExpression);
51 if (!renderedLinker) {
52 renderedLinker = tmpRenderedLinker;
53 lastRenderedLinker = renderedLinker->getLastListLink();
54 } else {
55 lastRenderedLinker->append(tmpRenderedLinker);
56 lastRenderedLinker = tmpRenderedLinker->getLastListLink();
57 }
58 }
59 mRenderer->endRender(renderedLinker);
60 return true;
61 }
62
63 bool COntologyAxiomExpressionsRenderVisitor::visitAndRender(COntologyTriplesData* ontTriplesData, CConcreteOntology* ontology, COntologyRenderer* renderer) {
64 mOntology = ontology;
65 mRenderer = renderer;
66 COntologyBuildData* buildDataBox = ontology->getBuildData();
67 mConceptClassTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptClassTermMappingHash();
68 mClassTermExpClassAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermExpressionClassAxiomExpressionHash();
69 mRoleObjectPropertyTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
70 mRoleDataPropertyTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleDataPropertyTermMappingHash();
71 mDatatypeDatatypeExpHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDatatypeDatatypeExpessionHash();
72 CRenderedItemLinker* renderedLinker = nullptr;
73 CRenderedItemLinker* lastRenderedLinker = nullptr;
74
75 mRenderer->beginRender();
76 if (ontTriplesData) {
77 COntologyTriplesAssertionsAccessor* accessor = ontTriplesData->getTripleAssertionAccessor();
78 if (accessor) {
79 cint64 maxIndiId = accessor->getMaxIndexedIndividualId();
80 mTriplesAssertionVisitingIndividualId = 0;
81 mTriplesAssertionVisitingIndividualName = "";
82 for (cint64 i = 0; i < maxIndiId; ++i) {
83 mVisitingTempRenderedLinker = nullptr;
84 mTriplesAssertionVisitingIndividualId = i;
85 mTriplesAssertionVisitingIndividualName = "";
86 accessor->visitIndividualName(i, this);
87 accessor->visitIndividualAssertions(i, this);
88
89 if (mVisitingTempRenderedLinker) {
90 if (!renderedLinker) {
91 renderedLinker = mVisitingTempRenderedLinker;
92 lastRenderedLinker = renderedLinker->getLastListLink();
93 } else {
94 lastRenderedLinker->append(mVisitingTempRenderedLinker);
95 lastRenderedLinker = mVisitingTempRenderedLinker->getLastListLink();
96 }
97 }
98 }
99 }
100 }
101 mRenderer->endRender(renderedLinker);
102 return true;
103 }
104
105
106 bool COntologyAxiomExpressionsRenderVisitor::visitAndRender(QList<CTriplesData*>* triplesDataList, CConcreteOntology* ontology, COntologyRenderer* renderer) {
107 mOntology = ontology;
108 mRenderer = renderer;
109 COntologyBuildData* buildDataBox = ontology->getBuildData();
110 mConceptClassTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptClassTermMappingHash();
111 mClassTermExpClassAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermExpressionClassAxiomExpressionHash();
112 mRoleObjectPropertyTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
113 mRoleDataPropertyTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleDataPropertyTermMappingHash();
114 mDatatypeDatatypeExpHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDatatypeDatatypeExpessionHash();
115 CRenderedItemLinker* renderedLinker = nullptr;
116 CRenderedItemLinker* lastRenderedLinker = nullptr;
117
118 CBUILDHASH<CStringRefStringHasher, CClassExpression*>* classNameExphash = ontology->getBuildData()->getClassEntityBuildHash();
119 CBUILDHASH<CStringRefStringHasher, CObjectPropertyExpression*>* objectPropertyNameExphash = ontology->getBuildData()->getObjectPropertyEntityBuildHash();
120 CBUILDHASH<CStringRefStringHasher, CDataPropertyExpression*>* dataPropertyNameExphash = ontology->getBuildData()->getDataPropertyEntityBuildHash();
121 CBUILDHASH<CStringRefStringHasher, CDatatypeExpression*>* datatypeNameExphash = ontology->getBuildData()->getDatatypeIRIBuildHash();
122 CDatatypeExpression* stringDatatypeNameExp = datatypeNameExphash->value(QString(PREFIX_XML_STRING_DATATYPE));
123
124 mRenderer->beginRender();
125 for (CTriplesData* triplesData : *triplesDataList) {
126 CTriplesDataIterator* triplesDatIt = triplesData->getTriplesDataIterator();
127 while (triplesDatIt->hasValue()) {
128 if (triplesDatIt->getNodeType(1) == CTriplesDataIterator::TRIPLE_URI_NODE_TYPE) {
129 QString predicateString = triplesDatIt->getNodeString(1);
130 QString objectString = triplesDatIt->getNodeString(2);
131 QString subjectString = triplesDatIt->getNodeString(0);
132 CRenderedItemLinker* tmpRenderedLinker = nullptr;
133 if (predicateString == PREFIX_RDF_TYPE) {
134 CNamedIndividualExpression namedIndiExp(subjectString);
135 CClassExpression* classExp = classNameExphash->value(objectString);
136 if (classExp) {
137 CClassAssertionExpression classAssExp(&namedIndiExp, classExp);
138 tmpRenderedLinker = getRenderedClassAssertionAxiom(&classAssExp);
139 }
140
141 } else if (objectPropertyNameExphash->contains(predicateString)) {
142 CNamedIndividualExpression namedIndiExp1(subjectString);
143 CNamedIndividualExpression namedIndiExp2(objectString);
144 CObjectPropertyExpression* objPropExp = objectPropertyNameExphash->value(predicateString);
145 CObjectPropertyAssertionExpression objPropAssExp(objPropExp, &namedIndiExp1, &namedIndiExp2);
146 tmpRenderedLinker = getRenderedObjectPropertyAssertionAxiom(&objPropAssExp);
147
148 } else if (dataPropertyNameExphash->contains(predicateString)) {
149 CNamedIndividualExpression namedIndiExp1(subjectString);
150
151 cint64 sepPos = objectString.lastIndexOf("^^");
152 QString literalString = objectString.mid(1, sepPos - 2);
153 QString datatypeString = objectString.mid(sepPos + 2);
154
155 CDataLexicalValueExpression dataLexicalValueExpression(literalString);
156 CDatatypeExpression* dataTypeExpression;
157 if (!datatypeString.isEmpty()) {
158 dataTypeExpression = datatypeNameExphash->value(datatypeString);
159 } else {
160 dataTypeExpression = stringDatatypeNameExp;
161 }
162 CDataLiteralExpression dataLitExp(&dataLexicalValueExpression, dataTypeExpression);
163
164 CNamedIndividualExpression namedIndiExp2(objectString);
165 CDataPropertyExpression* dataPropExp = dataPropertyNameExphash->value(predicateString);
166 CDataPropertyAssertionExpression dataPropAssExp(dataPropExp, &namedIndiExp1, &dataLitExp);
167 tmpRenderedLinker = getRenderedDataPropertyAssertionAxiom(&dataPropAssExp);
168 }
169
170 if (tmpRenderedLinker) {
171 if (!renderedLinker) {
172 renderedLinker = tmpRenderedLinker;
173 lastRenderedLinker = renderedLinker->getLastListLink();
174 } else {
175 lastRenderedLinker->append(tmpRenderedLinker);
176 lastRenderedLinker = tmpRenderedLinker->getLastListLink();
177 }
178 }
179 }
180 triplesDatIt->moveNext();
181 }
182 delete triplesDatIt;
183 }
184
185 mRenderer->endRender(renderedLinker);
186 return true;
187 }
188
189
190
191 bool COntologyAxiomExpressionsRenderVisitor::visitRoleAssertion(CRole* role, cint64 otherIndividualId, COntologyTriplesAssertionsAccessor* accessor) {
192 CNamedIndividualExpression namedIndiExp(mTriplesAssertionVisitingIndividualName);
193 QString otherNamedIndiName;
194 accessor->visitIndividualName(otherIndividualId, [&](const QString& name)->bool{
195 otherNamedIndiName = name;
196 return true;
197 });
198
199 CNamedIndividualExpression otherNamedIndiExp(otherNamedIndiName);
200 CObjectPropertyTermExpression* propExp = mRoleObjectPropertyTermMapHash->value(role);
201 if (propExp) {
202 CObjectPropertyAssertionExpression objPropAssExp(propExp, &namedIndiExp, &otherNamedIndiExp);
203 CRenderedItemLinker* tmpRenderedLinker = getRenderedObjectPropertyAssertionAxiom(&objPropAssExp);
204 mVisitingTempRenderedLinker = tmpRenderedLinker;
205 }
206 return true;
207 }
208
209 bool COntologyAxiomExpressionsRenderVisitor::visitReverseRoleAssertion(CRole* role, cint64 otherIndividualId, COntologyTriplesAssertionsAccessor* accessor) {
210 return true;
211 }
212
213 bool COntologyAxiomExpressionsRenderVisitor::visitDataAssertion(CRole* role, CDataLiteral* dataLiteral, COntologyTriplesAssertionsAccessor* accessor) {
214 CNamedIndividualExpression namedIndiExp(mTriplesAssertionVisitingIndividualName);
215
216 CDataPropertyTermExpression* propExp = mRoleDataPropertyTermMapHash->value(role);
217 CDataLexicalValueExpression dataLexicalValueExpression(dataLiteral->getLexicalDataLiteralValueString());
218 CDatatypeExpression* dataTypeExpression = mDatatypeDatatypeExpHash->value(dataLiteral->getDatatype());
219 if (propExp && dataTypeExpression) {
220 CDataLiteralExpression dataLitExp(&dataLexicalValueExpression, dataTypeExpression);
221 CDataPropertyAssertionExpression dataPropAssExp(propExp, &namedIndiExp, &dataLitExp);
222 CRenderedItemLinker* tmpRenderedLinker = getRenderedDataPropertyAssertionAxiom(&dataPropAssExp);
223 mVisitingTempRenderedLinker = tmpRenderedLinker;
224 }
225 return true;
226 }
227
228 bool COntologyAxiomExpressionsRenderVisitor::visitConceptAssertion(CConcept* concept, COntologyTriplesAssertionsAccessor* accessor) {
229 CNamedIndividualExpression namedIndiExp(mTriplesAssertionVisitingIndividualName);
230 CIndividualTermExpression* indiExp = &namedIndiExp;
231 CClassTermExpression* classExp = mConceptClassTermMapHash->value(concept);
232 if (classExp) {
233 CClassAssertionExpression classAssExp(indiExp, classExp);
234 CRenderedItemLinker* tmpRenderedLinker = getRenderedClassAssertionAxiom(&classAssExp);
235 mVisitingTempRenderedLinker = tmpRenderedLinker;
236 }
237 return true;
238 }
239
240 bool COntologyAxiomExpressionsRenderVisitor::visitIndividualName(const QString& indiName, COntologyTriplesAssertionsAccessor* accessor) {
241 mTriplesAssertionVisitingIndividualName = indiName;
242 return true;
243 }
244
245
246
247
248
249
250 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedAxiomExpression(CAxiomExpression* axiomExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
251 CRenderedItemLinker* tmpRenderedLinker = nullptr;
252 CBuildExpression::ExpressionType type = axiomExp->getType();
253
254 if (type == CBuildExpression::BETDECLARATION) {
255 tmpRenderedLinker = getRenderedDeclarationAxiom(axiomExp);
256
257 } else if(type == CBuildExpression::BETESUBCLASSOF) {
258 tmpRenderedLinker = getRenderedSubClassOfAxiom(axiomExp);
259 } else if (type == CBuildExpression::BETEQUIVALENTCLASSES) {
260 tmpRenderedLinker = getRenderedEquivalentClassesAxiom(axiomExp);
261 } else if (type == CBuildExpression::BETDISJOINTUNION) {
262 tmpRenderedLinker = getRenderedDisjointUnionAxiom(axiomExp);
263 } else if (type == CBuildExpression::BETDISJOINTCLASSES) {
264 tmpRenderedLinker = getRenderedDisjointClassesAxiom(axiomExp);
265
266 } else if (type == CBuildExpression::BETSUBOBJECTPROPERTYOF) {
267 tmpRenderedLinker = getRenderedSubObjectPropertyOfAxiom(axiomExp);
268 } else if (type == CBuildExpression::BETOBJECTPROPERTYDOMAIN) {
269 tmpRenderedLinker = getRenderedObjectPropertyDomainAxiom(axiomExp);
270 } else if (type == CBuildExpression::BETOBJECTPROPERTYRANGE) {
271 tmpRenderedLinker = getRenderedObjectPropertyRangeAxiom(axiomExp);
272 } else if (type == CBuildExpression::BETFUNCTIONALOBJECTPROPERTY) {
273 tmpRenderedLinker = getRenderedFunctionalObjectPropertyAxiom(axiomExp);
274 } else if (type == CBuildExpression::BETSYMMETRICPROPERTY) {
275 tmpRenderedLinker = getRenderedSymmetricObjectPropertyAxiom(axiomExp);
276 } else if (type == CBuildExpression::BETASYMMETRICPROPERTY) {
277 tmpRenderedLinker = getRenderedAsymmetricObjectPropertyAxiom(axiomExp);
278 } else if (type == CBuildExpression::BETTRANSITIVEOBJECTPROPERTY) {
279 tmpRenderedLinker = getRenderedTransetiveObjectPropertyAxiom(axiomExp);
280 } else if (type == CBuildExpression::BETINVERSEOBJECTPROPERTIES) {
281 tmpRenderedLinker = getRenderedInverseObjectPropertiesAxiom(axiomExp);
282 } else if (type == CBuildExpression::BETEQUIVALENTOBJECTPROPERTIES) {
283 tmpRenderedLinker = getRenderedEquivalentObjectPropertiesAxiom(axiomExp);
284 } else if (type == CBuildExpression::BETDISJOINTOBJECTPROPERTIES) {
285 tmpRenderedLinker = getRenderedDisjointObjectPropertiesAxiom(axiomExp);
286 } else if (type == CBuildExpression::BETREFLEXIVEPROPERTY) {
287 tmpRenderedLinker = getRenderedReflexiveObjectPropertyAxiom(axiomExp);
288 } else if (type == CBuildExpression::BETIRREFLEXIVEPROPERTY) {
289 tmpRenderedLinker = getRenderedIrreflexiveObjectPropertyAxiom(axiomExp);
290
291 } else if (type == CBuildExpression::BETDATAPROPERTYDOMAIN) {
292 tmpRenderedLinker = getRenderedDataPropertyDomainAxiom(axiomExp);
293 } else if (type == CBuildExpression::BETDATAPROPERTYRANGE) {
294 tmpRenderedLinker = getRenderedDataPropertyRangeAxiom(axiomExp);
295 } else if (type == CBuildExpression::BETSUBDATAPROPERTYOF) {
296 tmpRenderedLinker = getRenderedSubDataPropertyOfAxiom(axiomExp);
297 } else if (type == CBuildExpression::BETDISJOINTDATAPROPERTIES) {
298 tmpRenderedLinker = getRenderedDisjointDataPropertiesAxiom(axiomExp);
299 } else if (type == CBuildExpression::BETEQUIVALENTDATAPROPERTIES) {
300 tmpRenderedLinker = getRenderedEquivalentDataPropertiesAxiom(axiomExp);
301 } else if (type == CBuildExpression::BETFUNCTIONALDATAPROPERTY) {
302 tmpRenderedLinker = getRenderedFunctionalDataPropertyAxiom(axiomExp);
303 } else if (type == CBuildExpression::BETDATAPROPERTYASSERTION) {
304 tmpRenderedLinker = getRenderedDataPropertyAssertionAxiom(axiomExp);
305 } else if (type == CBuildExpression::BETNEGATIVEDATAPROPERTYASSERTION) {
306 tmpRenderedLinker = getRenderedNegativeDataPropertyAssertionAxiom(axiomExp);
307
308
309 } else if (type == CBuildExpression::BETOBJECTPROPERTYASSERTION) {
310 tmpRenderedLinker = getRenderedObjectPropertyAssertionAxiom(axiomExp);
311 } else if (type == CBuildExpression::BETNEGATIVEOBJECTPROPERTYASSERTION) {
312 tmpRenderedLinker = getRenderedNegativeObjectPropertyAssertionAxiom(axiomExp);
313 } else if (type == CBuildExpression::BETCLASSASSERTION) {
314 tmpRenderedLinker = getRenderedClassAssertionAxiom(axiomExp);
315 } else if (type == CBuildExpression::BETSAMEINDIVIDUAL) {
316 tmpRenderedLinker = getRenderedSameIndividualAxiom(axiomExp);
317 } else if (type == CBuildExpression::BETDIFFERENTINDIVIDUAL) {
318 tmpRenderedLinker = getRenderedDifferentIndividualsAxiom(axiomExp);
319
320 }
321 return appendPrepandRenderedItemLinker(tmpRenderedLinker, prependRenderedLinker, appendRenderedLinker);
322 }
323
324
325 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDifferentIndividualsAxiom(CAxiomExpression* axiomExp) {
326 CRenderedItemLinker* renderedLinker = nullptr;
327 if (mRenderer->beginRenderDifferentIndividualsAxiom()) {
328 CDifferentIndividualsExpression* diffIndExp = (CDifferentIndividualsExpression*)axiomExp;
329 renderedLinker = getRenderedIndividualTermExpressions(diffIndExp->getIndividualTermExpressionList());
330 renderedLinker = mRenderer->endRenderDifferentIndividualsAxiom(renderedLinker);
331 }
332 return renderedLinker;
333 }
334
335 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedSameIndividualAxiom(CAxiomExpression* axiomExp) {
336 CRenderedItemLinker* renderedLinker = nullptr;
337 if (mRenderer->beginRenderSameIndividualAxiom()) {
338 CSameIndividualExpression* sameIndExp = (CSameIndividualExpression*)axiomExp;
339 renderedLinker = getRenderedIndividualTermExpressions(sameIndExp->getIndividualTermExpressionList());
340 renderedLinker = mRenderer->endRenderSameIndividualAxiom(renderedLinker);
341 }
342 return renderedLinker;
343 }
344
345
346 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedClassAssertionAxiom(CAxiomExpression* axiomExp) {
347 CRenderedItemLinker* renderedLinker = nullptr;
348 if (mRenderer->beginRenderClassAssertionAxiom()) {
349 CClassAssertionExpression* classAssExp = (CClassAssertionExpression*)axiomExp;
350 renderedLinker = getRenderedIndividualTermExpression(classAssExp->getIndividualTermExpression());
351 renderedLinker = getRenderedClassTermExpression(classAssExp->getClassTermExpression(), renderedLinker);
352 renderedLinker = mRenderer->endRenderClassAssertionAxiom(renderedLinker);
353 }
354 return renderedLinker;
355 }
356
357
358 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedNegativeObjectPropertyAssertionAxiom(CAxiomExpression* axiomExp) {
359 CRenderedItemLinker* renderedLinker = nullptr;
360 if (mRenderer->beginRenderNegativeObjectPropertyAssertionAxiom()) {
361 CNegativeObjectPropertyAssertionExpression* negObjPropAssExp = (CNegativeObjectPropertyAssertionExpression*)axiomExp;
362 renderedLinker = getRenderedIndividualTermExpression(negObjPropAssExp->getFirstIndividualTermExpression());
363 renderedLinker = getRenderedObjectPropertyTermExpression(negObjPropAssExp->getObjectPropertyTermExpression(), renderedLinker);
364 renderedLinker = getRenderedIndividualTermExpression(negObjPropAssExp->getSecondIndividualTermExpression(), renderedLinker);
365 renderedLinker = mRenderer->endRenderNegativeObjectPropertyAssertionAxiom(renderedLinker);
366 }
367 return renderedLinker;
368 }
369
370
371 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyAssertionAxiom(CAxiomExpression* axiomExp) {
372 CRenderedItemLinker* renderedLinker = nullptr;
373 if (mRenderer->beginRenderObjectPropertyAssertionAxiom()) {
374 CObjectPropertyAssertionExpression* objPropAssExp = (CObjectPropertyAssertionExpression*)axiomExp;
375 renderedLinker = getRenderedIndividualTermExpression(objPropAssExp->getFirstIndividualTermExpression());
376 renderedLinker = getRenderedObjectPropertyTermExpression(objPropAssExp->getObjectPropertyTermExpression(), renderedLinker);
377 renderedLinker = getRenderedIndividualTermExpression(objPropAssExp->getSecondIndividualTermExpression(), renderedLinker);
378 renderedLinker = mRenderer->endRenderObjectPropertyAssertionAxiom(renderedLinker);
379 }
380 return renderedLinker;
381 }
382
383
384
385 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedNegativeDataPropertyAssertionAxiom(CAxiomExpression* axiomExp) {
386 CRenderedItemLinker* renderedLinker = nullptr;
387 if (mRenderer->beginRenderNegativeDataPropertyAssertionAxiom()) {
388 CNegativeDataPropertyAssertionExpression* negDataPropAssExp = (CNegativeDataPropertyAssertionExpression*)axiomExp;
389 renderedLinker = getRenderedIndividualTermExpression(negDataPropAssExp->getIndividualTermExpression());
390 renderedLinker = getRenderedDataPropertyTermExpression(negDataPropAssExp->getDataPropertyTermExpression(), renderedLinker);
391 renderedLinker = getRenderedDataRangeTermExpression(negDataPropAssExp->getDataLiteralTermExpression(), renderedLinker);
392 renderedLinker = mRenderer->endRenderNegativeDataPropertyAssertionAxiom(renderedLinker);
393 }
394 return renderedLinker;
395 }
396
397 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataPropertyAssertionAxiom(CAxiomExpression* axiomExp) {
398 CRenderedItemLinker* renderedLinker = nullptr;
399 if (mRenderer->beginRenderDataPropertyAssertionAxiom()) {
400 CDataPropertyAssertionExpression* dataPropAssExp = (CDataPropertyAssertionExpression*)axiomExp;
401 renderedLinker = getRenderedIndividualTermExpression(dataPropAssExp->getIndividualTermExpression());
402 renderedLinker = getRenderedDataPropertyTermExpression(dataPropAssExp->getDataPropertyTermExpression(), renderedLinker);
403 renderedLinker = getRenderedDataRangeTermExpression(dataPropAssExp->getDataLiteralTermExpression(), renderedLinker);
404 renderedLinker = mRenderer->endRenderDataPropertyAssertionAxiom(renderedLinker);
405 }
406 return renderedLinker;
407 }
408
409
410 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedFunctionalDataPropertyAxiom(CAxiomExpression* axiomExp) {
411 CRenderedItemLinker* renderedLinker = nullptr;
412 if (mRenderer->beginRenderFunctionalDataPropertyAxiom()) {
413 CFunctionalDataPropertyExpression* funDataPropExp = (CFunctionalDataPropertyExpression*)axiomExp;
414 renderedLinker = getRenderedDataPropertyTermExpression(funDataPropExp->getFunctionalDataPropertyExpression());
415 renderedLinker = mRenderer->endRenderFunctionalDataPropertyAxiom(renderedLinker);
416 }
417 return renderedLinker;
418 }
419
420
421 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedEquivalentDataPropertiesAxiom(CAxiomExpression* axiomExp) {
422 CRenderedItemLinker* renderedLinker = nullptr;
423 if (mRenderer->beginRenderEquivalentDataPropertiesAxiom()) {
424 CEquivalentDataPropertiesExpression* eqDataPropExp = (CEquivalentDataPropertiesExpression*)axiomExp;
425 renderedLinker = getRenderedDataPropertyTermExpressions(eqDataPropExp->getDataPropertyTermExpressionList());
426 renderedLinker = mRenderer->endRenderEquivalentDataPropertiesAxiom(renderedLinker);
427 }
428 return renderedLinker;
429 }
430
431
432
433 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDisjointDataPropertiesAxiom(CAxiomExpression* axiomExp) {
434 CRenderedItemLinker* renderedLinker = nullptr;
435 if (mRenderer->beginRenderDisjointDataPropertiesAxiom()) {
436 CDisjointDataPropertiesExpression* disjDataPropExp = (CDisjointDataPropertiesExpression*)axiomExp;
437 renderedLinker = getRenderedDataPropertyTermExpressions(disjDataPropExp->getDataPropertyTermExpressionList());
438 renderedLinker = mRenderer->endRenderDisjointDataPropertiesAxiom(renderedLinker);
439 }
440 return renderedLinker;
441 }
442
443
444
445 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedSubDataPropertyOfAxiom(CAxiomExpression* axiomExp) {
446 CRenderedItemLinker* renderedLinker = nullptr;
447 if (mRenderer->beginRenderSubDataPropertyOfAxiom()) {
448 CSubDataPropertyOfExpression* subDataPropExp = (CSubDataPropertyOfExpression*)axiomExp;
449 renderedLinker = getRenderedDataPropertyTermExpression(subDataPropExp->getSubDataPropertyTermExpression());
450 renderedLinker = getRenderedDataPropertyTermExpression(subDataPropExp->getSuperDataPropertyTermExpression(), renderedLinker);
451 renderedLinker = mRenderer->endRenderSubDataPropertyOfAxiom(renderedLinker);
452 }
453 return renderedLinker;
454 }
455
456
457 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataPropertyRangeAxiom(CAxiomExpression* axiomExp) {
458 CRenderedItemLinker* renderedLinker = nullptr;
459 if (mRenderer->beginRenderDataPropertyRangeAxiom()) {
460 CDataPropertyRangeExpression* rangeDataPropExp = (CDataPropertyRangeExpression*)axiomExp;
461 renderedLinker = getRenderedDataPropertyTermExpression(rangeDataPropExp->getDataPropertyTermExpression());
462 renderedLinker = getRenderedDataRangeTermExpression(rangeDataPropExp->getDataRangeTermExpression(), renderedLinker);
463 renderedLinker = mRenderer->endRenderDataPropertyRangeAxiom(renderedLinker);
464 }
465 return renderedLinker;
466 }
467
468
469 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataPropertyDomainAxiom(CAxiomExpression* axiomExp) {
470 CRenderedItemLinker* renderedLinker = nullptr;
471 if (mRenderer->beginRenderDataPropertyDomainAxiom()) {
472 CDataPropertyDomainExpression* domainDataPropExp = (CDataPropertyDomainExpression*)axiomExp;
473 renderedLinker = getRenderedDataPropertyTermExpression(domainDataPropExp->getDataPropertyTermExpression());
474 renderedLinker = getRenderedClassTermExpression(domainDataPropExp->getClassTermExpression(), renderedLinker);
475 renderedLinker = mRenderer->endRenderDataPropertyDomainAxiom(renderedLinker);
476 }
477 return renderedLinker;
478 }
479
480
481
482
483
484
485
486
487
488
489
490
491
492 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedInverseFunctionalObjectPropertyAxiom(CAxiomExpression* axiomExp) {
493 CRenderedItemLinker* renderedLinker = nullptr;
494 if (mRenderer->beginRenderInverseFunctionalObjectPropertyAxiom()) {
495 CInverseFunctionalObjectPropertyExpression* invFuncObjectPropExp = (CInverseFunctionalObjectPropertyExpression*)axiomExp;
496 renderedLinker = getRenderedObjectPropertyTermExpression(invFuncObjectPropExp->getInverseFunctionalObjectPropertyExpression());
497 renderedLinker = mRenderer->endRenderInverseFunctionalObjectPropertyAxiom(renderedLinker);
498 }
499 return renderedLinker;
500 }
501
502
503 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedIrreflexiveObjectPropertyAxiom(CAxiomExpression* axiomExp) {
504 CRenderedItemLinker* renderedLinker = nullptr;
505 if (mRenderer->beginRenderIrreflexiveObjectPropertyAxiom()) {
506 CIrreflexiveObjectPropertyExpression* irreflObjectPropExp = (CIrreflexiveObjectPropertyExpression*)axiomExp;
507 renderedLinker = getRenderedObjectPropertyTermExpression(irreflObjectPropExp->getIreflexiveObjectPropertyExpression());
508 renderedLinker = mRenderer->endRenderIrreflexiveObjectPropertyAxiom(renderedLinker);
509 }
510 return renderedLinker;
511 }
512
513 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedReflexiveObjectPropertyAxiom(CAxiomExpression* axiomExp) {
514 CRenderedItemLinker* renderedLinker = nullptr;
515 if (mRenderer->beginRenderReflexiveObjectPropertyAxiom()) {
516 CReflexiveObjectPropertyExpression* reflObjectPropExp = (CReflexiveObjectPropertyExpression*)axiomExp;
517 renderedLinker = getRenderedObjectPropertyTermExpression(reflObjectPropExp->getReflexiveObjectPropertyExpression());
518 renderedLinker = mRenderer->endRenderReflexiveObjectPropertyAxiom(renderedLinker);
519 }
520 return renderedLinker;
521 }
522
523
524 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDisjointObjectPropertiesAxiom(CAxiomExpression* axiomExp) {
525 CRenderedItemLinker* renderedLinker = nullptr;
526 if (mRenderer->beginRenderDisjointObjectPropertiesAxiom()) {
527 CDisjointObjectPropertiesExpression* disjObjectPropExp = (CDisjointObjectPropertiesExpression*)axiomExp;
528 renderedLinker = getRenderedObjectPropertyTermExpressions(disjObjectPropExp->getObjectPropertyTermExpressionList());
529 renderedLinker = mRenderer->endRenderDisjointObjectPropertiesAxiom(renderedLinker);
530 }
531 return renderedLinker;
532 }
533
534 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedEquivalentObjectPropertiesAxiom(CAxiomExpression* axiomExp) {
535 CRenderedItemLinker* renderedLinker = nullptr;
536 if (mRenderer->beginRenderInverseObjectPropertiesAxiom()) {
537 CEquivalentObjectPropertiesExpression* equivObjectPropExp = (CEquivalentObjectPropertiesExpression*)axiomExp;
538 renderedLinker = getRenderedObjectPropertyTermExpressions(equivObjectPropExp->getObjectPropertyTermExpressionList());
539 renderedLinker = mRenderer->endRenderInverseObjectPropertiesAxiom(renderedLinker);
540 }
541 return renderedLinker;
542 }
543
544 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedInverseObjectPropertiesAxiom(CAxiomExpression* axiomExp) {
545 CRenderedItemLinker* renderedLinker = nullptr;
546 if (mRenderer->beginRenderInverseObjectPropertiesAxiom()) {
547 CInverseObjectPropertiesExpression* invObjectPropExp = (CInverseObjectPropertiesExpression*)axiomExp;
548 renderedLinker = getRenderedObjectPropertyTermExpression(invObjectPropExp->getFirstObjectPropertyTermExpression());
549 renderedLinker = getRenderedObjectPropertyTermExpression(invObjectPropExp->getSecondObjectPropertyTermExpression(), renderedLinker);
550 renderedLinker = mRenderer->endRenderInverseObjectPropertiesAxiom(renderedLinker);
551 }
552 return renderedLinker;
553 }
554
555 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyRangeAxiom(CAxiomExpression* axiomExp) {
556 CRenderedItemLinker* renderedLinker = nullptr;
557 if (mRenderer->beginRenderObjectPropertyRangeAxiom()) {
558 CObjectPropertyRangeExpression* rangeObjectPropExp = (CObjectPropertyRangeExpression*)axiomExp;
559 renderedLinker = getRenderedObjectPropertyTermExpression(rangeObjectPropExp->getObjectPropertyTermExpression());
560 renderedLinker = getRenderedClassTermExpression(rangeObjectPropExp->getClassTermExpression(), renderedLinker);
561 renderedLinker = mRenderer->endRenderObjectPropertyRangeAxiom(renderedLinker);
562 }
563 return renderedLinker;
564 }
565
566
567 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyDomainAxiom(CAxiomExpression* axiomExp) {
568 CRenderedItemLinker* renderedLinker = nullptr;
569 if (mRenderer->beginRenderObjectPropertyDomainAxiom()) {
570 CObjectPropertyDomainExpression* domainObjectPropExp = (CObjectPropertyDomainExpression*)axiomExp;
571 renderedLinker = getRenderedObjectPropertyTermExpression(domainObjectPropExp->getObjectPropertyTermExpression());
572 renderedLinker = getRenderedClassTermExpression(domainObjectPropExp->getClassTermExpression(), renderedLinker);
573 renderedLinker = mRenderer->endRenderObjectPropertyDomainAxiom(renderedLinker);
574 }
575 return renderedLinker;
576 }
577
578 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedSubObjectPropertyOfAxiom(CAxiomExpression* axiomExp) {
579 CRenderedItemLinker* renderedLinker = nullptr;
580 if (mRenderer->beginRenderSubObjectPropertyOfAxiom()) {
581 CSubObjectPropertyOfExpression* subObjectPropOfExp = (CSubObjectPropertyOfExpression*)axiomExp;
582 renderedLinker = getRenderedObjectPropertyTermExpressions(subObjectPropOfExp->getSubObjectPropertyTermExpressionList());
583 renderedLinker = getRenderedObjectPropertyTermExpression(subObjectPropOfExp->getSuperObjectPropertyTermExpression(), renderedLinker);
584 renderedLinker = mRenderer->endRenderSubObjectPropertyOfAxiom(renderedLinker);
585 }
586 return renderedLinker;
587 }
588
589
590 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedFunctionalObjectPropertyAxiom(CAxiomExpression* axiomExp) {
591 CRenderedItemLinker* renderedLinker = nullptr;
592 if (mRenderer->beginRenderFunctionalObjectPropertyAxiom()) {
593 CFunctionalObjectPropertyExpression* funcObjectPropExp = (CFunctionalObjectPropertyExpression*)axiomExp;
594 renderedLinker = getRenderedObjectPropertyTermExpression(funcObjectPropExp->getFunctionalObjectPropertyExpression());
595 renderedLinker = mRenderer->endRenderFunctionalObjectPropertyAxiom(renderedLinker);
596 }
597 return renderedLinker;
598 }
599
600
601 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedSymmetricObjectPropertyAxiom(CAxiomExpression* axiomExp) {
602 CRenderedItemLinker* renderedLinker = nullptr;
603 if (mRenderer->beginRenderSymmetricObjectPropertyAxiom()) {
604 CSymmetricObjectPropertyExpression* symmObjectPropExp = (CSymmetricObjectPropertyExpression*)axiomExp;
605 renderedLinker = getRenderedObjectPropertyTermExpression(symmObjectPropExp->getSymmetricObjectPropertyExpression());
606 renderedLinker = mRenderer->endRenderSymmetricObjectPropertyAxiom(renderedLinker);
607 }
608 return renderedLinker;
609 }
610
611
612 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedAsymmetricObjectPropertyAxiom(CAxiomExpression* axiomExp) {
613 CRenderedItemLinker* renderedLinker = nullptr;
614 if (mRenderer->beginRenderAsymmetricObjectPropertyAxiom()) {
615 CAsymmetricObjectPropertyExpression* asymmObjectPropExp = (CAsymmetricObjectPropertyExpression*)axiomExp;
616 renderedLinker = getRenderedObjectPropertyTermExpression(asymmObjectPropExp->getAsymmetricObjectPropertyExpression());
617 renderedLinker = mRenderer->endRenderAsymmetricObjectPropertyAxiom(renderedLinker);
618 }
619 return renderedLinker;
620 }
621
622 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedTransetiveObjectPropertyAxiom(CAxiomExpression* axiomExp) {
623 CRenderedItemLinker* renderedLinker = nullptr;
624 if (mRenderer->beginRenderTransetiveObjectPropertyAxiom()) {
625 CTransetiveObjectPropertyExpression* transObjectPropExp = (CTransetiveObjectPropertyExpression*)axiomExp;
626 renderedLinker = getRenderedObjectPropertyTermExpression(transObjectPropExp->getTransetivePropertyExpression());
627 renderedLinker = mRenderer->endRenderTransetiveObjectPropertyAxiom(renderedLinker);
628 }
629 return renderedLinker;
630 }
631
632 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDisjointClassesAxiom(CAxiomExpression* axiomExp) {
633 CRenderedItemLinker* renderedLinker = nullptr;
634 if (mRenderer->beginRenderDisjointClassesAxiom()) {
635 CDisjointClassesExpression* disjClassesExp = (CDisjointClassesExpression*)axiomExp;
636 renderedLinker = getRenderedClassTermExpressions(disjClassesExp->getClassTermExpressionList());
637 renderedLinker = mRenderer->endRenderDisjointClassesAxiom(renderedLinker);
638 }
639 return renderedLinker;
640 }
641
642 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDisjointUnionAxiom(CAxiomExpression* axiomExp) {
643 CRenderedItemLinker* renderedLinker = nullptr;
644 if (mRenderer->beginRenderDisjontUnionAxiom()) {
645 CDisjointUnionExpression* disjUnionExp = (CDisjointUnionExpression*)axiomExp;
646 renderedLinker = getRenderedClassTermExpression(disjUnionExp->getClassExpression());
647 renderedLinker = getRenderedClassTermExpressions(disjUnionExp->getClassTermExpressionList(), renderedLinker);
648 renderedLinker = mRenderer->endRenderDisjontUnionAxiom(renderedLinker);
649 }
650 return renderedLinker;
651 }
652
653 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedEquivalentClassesAxiom(CAxiomExpression* axiomExp) {
654 CRenderedItemLinker* renderedLinker = nullptr;
655 if (mRenderer->beginRenderEquivalentClassesAxiom()) {
656 CEquivalentClassesExpression* equivClassesExp = (CEquivalentClassesExpression*)axiomExp;
657 renderedLinker = getRenderedClassTermExpressions(equivClassesExp->getClassTermExpressionList());
658 renderedLinker = mRenderer->endRenderEquivalentClassesAxiom(renderedLinker);
659 }
660 return renderedLinker;
661 }
662
663 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedSubClassOfAxiom(CAxiomExpression* axiomExp) {
664 CRenderedItemLinker* renderedLinker = nullptr;
665 if (mRenderer->beginRenderSubClassOfAxiom()) {
666 CSubClassOfExpression* subClassOfExp = (CSubClassOfExpression*)axiomExp;
667 renderedLinker = getRenderedClassTermExpression(subClassOfExp->getSubClassTermExpression(), renderedLinker);
668 renderedLinker = getRenderedClassTermExpression(subClassOfExp->getSuperClassTermExpression(), renderedLinker);
669 renderedLinker = mRenderer->endRenderSubClassOfAxiom(renderedLinker);
670 }
671 return renderedLinker;
672 }
673
674 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDeclarationAxiom(CAxiomExpression* axiomExp) {
675 CRenderedItemLinker* renderedLinker = nullptr;
676 if (mRenderer->beginRenderDeclarationAxiom()) {
677 CDeclarationAxiomExpression* declExp = (CDeclarationAxiomExpression*)axiomExp;
678 CExpressionEntity* entExp = declExp->getEntity();
679 if (dynamic_cast<CNamedIndividualExpression*>(entExp)) {
680 renderedLinker = getRenderedIndividualTermExpression((CNamedIndividualExpression*)entExp);
681 } else if (dynamic_cast<CAnonymousIndividualExpression*>(entExp)) {
682 renderedLinker = getRenderedIndividualTermExpression((CAnonymousIndividualExpression*)entExp);
683 } else if (dynamic_cast<CClassExpression*>(entExp)) {
684 renderedLinker = getRenderedClassTermExpression((CClassExpression*)entExp);
685 } else if (dynamic_cast<CObjectPropertyExpression*>(entExp)) {
686 renderedLinker = getRenderedObjectPropertyTermExpression((CObjectPropertyExpression*)entExp);
687 } else if (dynamic_cast<CDataPropertyExpression*>(entExp)) {
688 renderedLinker = getRenderedDataPropertyTermExpression((CDataPropertyExpression*)entExp);
689 } else if (dynamic_cast<CDatatypeExpression*>(entExp)) {
690 renderedLinker = getRenderedDataRangeTermExpression((CDatatypeExpression*)entExp);
691 }
692 renderedLinker = mRenderer->endRenderDeclarationAxiom(renderedLinker);
693 }
694 return renderedLinker;
695 }
696
697
698 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedClassTermExpressions(CEXPRESSIONLIST<CClassTermExpression*>* classTermExpList, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
699 CRenderedItemLinker* tmpRenderedLinker = nullptr;
700 foreach(CClassTermExpression* nextClassTermExp, *classTermExpList) {
701 tmpRenderedLinker = getRenderedClassTermExpression(nextClassTermExp, tmpRenderedLinker);
702 }
703 return tmpRenderedLinker;
704 }
705
706
707 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedClassTermExpression(CClassTermExpression* classTermExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
708 CRenderedItemLinker* tmpRenderedLinker = nullptr;
709 CBuildExpression::ExpressionType type = classTermExp->getType();
710 if (type == CBuildExpression::BETCLASS) {
711 tmpRenderedLinker = getRenderedClassExpression(classTermExp);
712 } else if (type == CBuildExpression::BETOBJECTINTERSECTION) {
713 tmpRenderedLinker = getRenderedObjectIntersectionOfExpression(classTermExp);
714 } else if (type == CBuildExpression::BETOBJECTUNION) {
715 tmpRenderedLinker = getRenderedObjectUnionOfExpression(classTermExp);
716 } else if (type == CBuildExpression::BETOBJECTCOMPLEMENTOF) {
717 tmpRenderedLinker = getRenderedObjectComplementOfExpression(classTermExp);
718 } else if (type == CBuildExpression::BETOBJECTSOMEVALUEFROM) {
719 tmpRenderedLinker = getRenderedObjectSomeValuesFromExpression(classTermExp);
720 } else if (type == CBuildExpression::BETOBJECTALLVALUEFROM) {
721 tmpRenderedLinker = getRenderedObjectAllValuesFromExpression(classTermExp);
722 } else if (type == CBuildExpression::BETOBJECTEXACTLYCARDINALITY) {
723 tmpRenderedLinker = getRenderedObjectExactCardinalityExpression(classTermExp);
724 } else if (type == CBuildExpression::BETOBJECTMINCARDINALITY) {
725 tmpRenderedLinker = getRenderedObjectMinCardinalityExpression(classTermExp);
726 } else if (type == CBuildExpression::BETOBJECTMAXCARDINALITY) {
727 tmpRenderedLinker = getRenderedObjectMaxCardinalityExpression(classTermExp);
728 } else if (type == CBuildExpression::BETOBJECTHASSELF) {
729 tmpRenderedLinker = getRenderedObjectHasSelfExpression(classTermExp);
730 } else if (type == CBuildExpression::BETOBJECTONEOF) {
731 tmpRenderedLinker = getRenderedObjectOneOfExpression(classTermExp);
732 } else if (type == CBuildExpression::BETOBJECTHASVALUE) {
733 tmpRenderedLinker = getRenderedObjectHasValueFromExpression(classTermExp);
734
735 } else if (type == CBuildExpression::BETDATASOMEVALUEFROM) {
736 tmpRenderedLinker = getRenderedObjectDataSomeValueFromExpression(classTermExp);
737 } else if (type == CBuildExpression::BETDATAHASVALUE) {
738 tmpRenderedLinker = getRenderedObjectDataHasValueExpression(classTermExp);
739 } else if (type == CBuildExpression::BETDATAALLVALUEFROM) {
740 tmpRenderedLinker = getRenderedObjectDataAllValuesFromExpression(classTermExp);
741 } else if (type == CBuildExpression::BETDATAMINCARDINALITY) {
742 tmpRenderedLinker = getRenderedObjectDataMinCardinalityExpression(classTermExp);
743 } else if (type == CBuildExpression::BETDATAMAXCARDINALITY) {
744 tmpRenderedLinker = getRenderedObjectDataMaxCardinalityExpression(classTermExp);
745 } else if (type == CBuildExpression::BETDATAEXACTCARDINALITY) {
746 tmpRenderedLinker = getRenderedObjectDataExactCardinalityExpression(classTermExp);
747
748 }
749 return appendPrepandRenderedItemLinker(tmpRenderedLinker,prependRenderedLinker,appendRenderedLinker);
750 }
751
752
753
754 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectDataExactCardinalityExpression(CClassTermExpression* classTermExp) {
755 CRenderedItemLinker* renderedLinker = nullptr;
756 CDataExactCardinalityExpression* dataExactCardExp = (CDataExactCardinalityExpression*)classTermExp;
757 cint64 cardinality = dataExactCardExp->getCardinality();
758 if (mRenderer->beginRenderDataExactCardinalityExpression(cardinality)) {
759 renderedLinker = getRenderedDataPropertyTermExpression(dataExactCardExp->getDataPropertyTermExpression());
760 renderedLinker = getRenderedDataRangeTermExpression(dataExactCardExp->getDataRangeTermExpression(), renderedLinker);
761 renderedLinker = mRenderer->endRenderDataExactCardinalityExpression(renderedLinker, cardinality);
762 }
763 return renderedLinker;
764 }
765
766
767 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectDataMaxCardinalityExpression(CClassTermExpression* classTermExp) {
768 CRenderedItemLinker* renderedLinker = nullptr;
769 CDataMaxCardinalityExpression* dataMaxCardExp = (CDataMaxCardinalityExpression*)classTermExp;
770 cint64 cardinality = dataMaxCardExp->getCardinality();
771 if (mRenderer->beginRenderDataMaxCardinalityExpression(cardinality)) {
772 renderedLinker = getRenderedDataPropertyTermExpression(dataMaxCardExp->getDataPropertyTermExpression());
773 renderedLinker = getRenderedDataRangeTermExpression(dataMaxCardExp->getDataRangeTermExpression(), renderedLinker);
774 renderedLinker = mRenderer->endRenderDataMaxCardinalityExpression(renderedLinker, cardinality);
775 }
776 return renderedLinker;
777 }
778
779
780 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectDataMinCardinalityExpression(CClassTermExpression* classTermExp) {
781 CRenderedItemLinker* renderedLinker = nullptr;
782 CDataMinCardinalityExpression* dataMinCardExp = (CDataMinCardinalityExpression*)classTermExp;
783 cint64 cardinality = dataMinCardExp->getCardinality();
784 if (mRenderer->beginRenderDataMinCardinalityExpression(cardinality)) {
785 renderedLinker = getRenderedDataPropertyTermExpression(dataMinCardExp->getDataPropertyTermExpression());
786 renderedLinker = getRenderedDataRangeTermExpression(dataMinCardExp->getDataRangeTermExpression(), renderedLinker);
787 renderedLinker = mRenderer->endRenderDataMinCardinalityExpression(renderedLinker,cardinality);
788 }
789 return renderedLinker;
790 }
791
792
793 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectDataAllValuesFromExpression(CClassTermExpression* classTermExp) {
794 CRenderedItemLinker* renderedLinker = nullptr;
795 if (mRenderer->beginRenderDataAllValuesExpression()) {
796 CDataAllValuesFromExpression* dataAllValuesFromExp = (CDataAllValuesFromExpression*)classTermExp;
797 renderedLinker = getRenderedDataPropertyTermExpression(dataAllValuesFromExp->getDataPropertyTermExpression());
798 renderedLinker = getRenderedDataRangeTermExpression(dataAllValuesFromExp->getDataRangeTermExpression(), renderedLinker);
799 renderedLinker = mRenderer->endRenderDataAllValuesExpression(renderedLinker);
800 }
801 return renderedLinker;
802 }
803
804
805 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectDataHasValueExpression(CClassTermExpression* classTermExp) {
806 CRenderedItemLinker* renderedLinker = nullptr;
807 if (mRenderer->beginRenderDataHasValueExpression()) {
808 CDataHasValueExpression* dataHasValueExp = (CDataHasValueExpression*)classTermExp;
809 renderedLinker = getRenderedDataPropertyTermExpression(dataHasValueExp->getDataPropertyTermExpression());
810 renderedLinker = getRenderedDataRangeTermExpression(dataHasValueExp->getDataRangeTermExpression(), renderedLinker);
811 renderedLinker = mRenderer->endRenderDataHasValueExpression(renderedLinker);
812 }
813 return renderedLinker;
814 }
815
816
817 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectDataSomeValueFromExpression(CClassTermExpression* classTermExp) {
818 CRenderedItemLinker* renderedLinker = nullptr;
819 if (mRenderer->beginRenderDataSomeValuesFromExpression()) {
820 CDataSomeValuesFromExpression* dataSomeValueExp = (CDataSomeValuesFromExpression*)classTermExp;
821 renderedLinker = getRenderedDataPropertyTermExpression(dataSomeValueExp->getDataPropertyTermExpression());
822 renderedLinker = getRenderedDataRangeTermExpression(dataSomeValueExp->getDataRangeTermExpression(), renderedLinker);
823 renderedLinker = mRenderer->endRenderDataSomeValuesFromExpression(renderedLinker);
824 }
825 return renderedLinker;
826 }
827
828
829
830 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectOneOfExpression(CClassTermExpression* classTermExp) {
831 CRenderedItemLinker* renderedLinker = nullptr;
832 if (mRenderer->beginRenderObjectOneOfExpression()) {
833 CObjectOneOfExpression* objectOneOfExp = (CObjectOneOfExpression*)classTermExp;
834 renderedLinker = getRenderedIndividualTermExpressions(objectOneOfExp->getIndividualTermExpressionList());
835 renderedLinker = mRenderer->endRenderObjectOneOfExpression(renderedLinker);
836 }
837 return renderedLinker;
838 }
839
840 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectHasValueFromExpression(CClassTermExpression* classTermExp) {
841 CRenderedItemLinker* renderedLinker = nullptr;
842 if (mRenderer->beginRenderObjectHasValueExpression()) {
843 CObjectHasValueExpression* hasValueExp = (CObjectHasValueExpression*)classTermExp;
844 renderedLinker = getRenderedObjectPropertyTermExpression(hasValueExp->getObjectPropertyTermExpression());
845 renderedLinker = getRenderedIndividualTermExpression(hasValueExp->getIndividualTermExpression(), renderedLinker);
846 renderedLinker = mRenderer->endRenderObjectHasValueExpression(renderedLinker);
847 }
848 return renderedLinker;
849 }
850
851 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectHasSelfExpression(CClassTermExpression* classTermExp) {
852 CRenderedItemLinker* renderedLinker = nullptr;
853 if (mRenderer->beginRenderObjectHasSelfExpression()) {
854 CObjectHasSelfExpression* hasSelfExp = (CObjectHasSelfExpression*)classTermExp;
855 renderedLinker = getRenderedObjectPropertyTermExpression(hasSelfExp->getObjectPropertyTermExpression());
856 renderedLinker = mRenderer->endRenderObjectHasSelfExpression(renderedLinker);
857 }
858 return renderedLinker;
859 }
860
861
862 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectMinCardinalityExpression(CClassTermExpression* classTermExp) {
863 CRenderedItemLinker* renderedLinker = nullptr;
864 CObjectMinCardinalityExpression* minCardExp = (CObjectMinCardinalityExpression*)classTermExp;
865 cint64 cardinality = minCardExp->getCardinality();
866 if (mRenderer->beginRenderObjectExactCardinalityExpression(cardinality)) {
867 renderedLinker = getRenderedObjectPropertyTermExpression(minCardExp->getObjectPropertyTermExpression());
868 renderedLinker = getRenderedClassTermExpression(minCardExp->getClassTermExpression(), renderedLinker);
869 renderedLinker = mRenderer->endRenderObjectExactCardinalityExpression(renderedLinker, cardinality);
870 }
871 return renderedLinker;
872 }
873
874
875 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectMaxCardinalityExpression(CClassTermExpression* classTermExp) {
876 CRenderedItemLinker* renderedLinker = nullptr;
877 CObjectMaxCardinalityExpression* maxCardExp = (CObjectMaxCardinalityExpression*)classTermExp;
878 cint64 cardinality = maxCardExp->getCardinality();
879 if (mRenderer->beginRenderObjectExactCardinalityExpression(cardinality)) {
880 renderedLinker = getRenderedObjectPropertyTermExpression(maxCardExp->getObjectPropertyTermExpression());
881 renderedLinker = getRenderedClassTermExpression(maxCardExp->getClassTermExpression(), renderedLinker);
882 renderedLinker = mRenderer->endRenderObjectExactCardinalityExpression(renderedLinker, cardinality);
883 }
884 return renderedLinker;
885 }
886
887 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectExactCardinalityExpression(CClassTermExpression* classTermExp) {
888 CRenderedItemLinker* renderedLinker = nullptr;
889 CObjectExactlyCardinalityExpression* exactCardExp = (CObjectExactlyCardinalityExpression*)classTermExp;
890 cint64 cardinality = exactCardExp->getCardinality();
891 if (mRenderer->beginRenderObjectExactCardinalityExpression(cardinality)) {
892 renderedLinker = getRenderedObjectPropertyTermExpression(exactCardExp->getObjectPropertyTermExpression());
893 renderedLinker = getRenderedClassTermExpression(exactCardExp->getClassTermExpression(), renderedLinker);
894 renderedLinker = mRenderer->endRenderObjectExactCardinalityExpression(renderedLinker, cardinality);
895 }
896 return renderedLinker;
897 }
898
899
900
901 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::appendPrepandRenderedItemLinker(CRenderedItemLinker* tmpRenderedLinker, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
902 if (tmpRenderedLinker) {
903 if (appendRenderedLinker) {
904 tmpRenderedLinker->append(appendRenderedLinker);
905 }
906 if (prependRenderedLinker) {
907 tmpRenderedLinker = prependRenderedLinker->append(tmpRenderedLinker);
908 }
909 } else {
910 if (appendRenderedLinker) {
911 tmpRenderedLinker = appendRenderedLinker;
912 } else if (prependRenderedLinker) {
913 tmpRenderedLinker = prependRenderedLinker;
914 } else if (appendRenderedLinker && prependRenderedLinker) {
915 tmpRenderedLinker = prependRenderedLinker->append(appendRenderedLinker);
916 }
917 }
918 return tmpRenderedLinker;
919 }
920
921
922
923
924 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedIndividualTermExpressions(CEXPRESSIONLIST<CIndividualTermExpression*>* indiTermExpList, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
925 CRenderedItemLinker* tmpRenderedLinker = nullptr;
926 foreach (CIndividualTermExpression* nextIndiTermExp, *indiTermExpList) {
927 tmpRenderedLinker = getRenderedIndividualTermExpression(nextIndiTermExp, tmpRenderedLinker);
928 }
929 return tmpRenderedLinker;
930 }
931
932
933
934 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedIndividualTermExpression(CIndividualTermExpression* indiTermExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
935 CRenderedItemLinker* renderedLinker = nullptr;
936 CBuildExpression::ExpressionType type = indiTermExp->getType();
937 if (type == CBuildExpression::BETNAMEDINDIVIDUAL) {
938 renderedLinker = getRenderedNamedIndividualExpression(indiTermExp);
939 } else if (type == CBuildExpression::BETANONYMOUSINDIVIDUAL) {
940 renderedLinker = getRenderedAnonymousIndividualExpression(indiTermExp);
941 }
942 return appendPrepandRenderedItemLinker(renderedLinker, prependRenderedLinker, appendRenderedLinker);
943 }
944
945
946
947
948
949 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedAnonymousIndividualExpression(CIndividualTermExpression* indiTermExp) {
950 CRenderedItemLinker* renderedLinker = nullptr;
951 CAnonymousIndividualExpression* anonymousIndiExpression = (CAnonymousIndividualExpression*)indiTermExp;
952 const QString& name = getNameFromEntityExpression(anonymousIndiExpression);
953 if (mRenderer->beginRenderAnonymousIndividualExpression(name)) {
954 renderedLinker = mRenderer->endRenderAnonymousIndividualExpression(name);
955 }
956 return renderedLinker;
957 }
958
959 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedNamedIndividualExpression(CIndividualTermExpression* indiTermExp) {
960 CRenderedItemLinker* renderedLinker = nullptr;
961 CNamedIndividualExpression* namedIndiExpression = (CNamedIndividualExpression*)indiTermExp;
962 const QString& name = getNameFromEntityExpression(namedIndiExpression);
963 if (mRenderer->beginRenderNamedIndividualExpression(name)) {
964 renderedLinker = mRenderer->endRenderNamedIndividualExpression(name);
965 }
966 return renderedLinker;
967 }
968
969
970
971 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyTermExpressions(CEXPRESSIONLIST<CObjectPropertyTermExpression*>* objPropTermExpList, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
972 CRenderedItemLinker* tmpRenderedLinker = nullptr;
973 foreach(CObjectPropertyTermExpression* nextObjPropTermExp, *objPropTermExpList) {
974 tmpRenderedLinker = getRenderedObjectPropertyTermExpression(nextObjPropTermExp, tmpRenderedLinker);
975 }
976 return tmpRenderedLinker;
977 }
978
979
980 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyTermExpression(CObjectPropertyTermExpression* objPropTermExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
981 CRenderedItemLinker* renderedLinker = nullptr;
982 CBuildExpression::ExpressionType type = objPropTermExp->getType();
983 if (type == CBuildExpression::BETOBJECTPROPERTY) {
984 renderedLinker = getRenderedObjectPropertyExpression(objPropTermExp);
985 } else if (type == CBuildExpression::BETOBJECTPROPERTYCHAIN) {
986 renderedLinker = getRenderedObjectPropertyChainExpression(objPropTermExp);
987 } else if (type == CBuildExpression::BETINVERSEOBJECTPROPERTYOF) {
988 renderedLinker = getRenderedInverseObjectPropertyOfExpression(objPropTermExp);
989 }
990 return appendPrepandRenderedItemLinker(renderedLinker, prependRenderedLinker, appendRenderedLinker);
991 }
992
993
994
995
996 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedInverseObjectPropertyOfExpression(CObjectPropertyTermExpression* objPropTermExp) {
997 CRenderedItemLinker* renderedLinker = nullptr;
998 if (mRenderer->beginRenderInverseObjectPropertyOf()) {
999 CInverseObjectPropertyOfExpression* invObjPropExp = (CInverseObjectPropertyOfExpression*)objPropTermExp;
1000 renderedLinker = getRenderedObjectPropertyTermExpression(invObjPropExp->getInverseOfExpression());
1001 renderedLinker = mRenderer->endRenderInverseObjectPropertyOf(renderedLinker);
1002 }
1003 return renderedLinker;
1004 }
1005
1006
1007
1008 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyChainExpression(CObjectPropertyTermExpression* objPropTermExp) {
1009 CRenderedItemLinker* renderedLinker = nullptr;
1010 if (mRenderer->beginRenderObjectPropertyChainAxiom()) {
1011 CObjectPropertyChainExpression* objPropChainExp = (CObjectPropertyChainExpression*)objPropTermExp;
1012 renderedLinker = getRenderedObjectPropertyTermExpressions(objPropChainExp->getOrderedObjectPropertyTermExpressionList());
1013 renderedLinker = mRenderer->endRenderObjectPropertyChainAxiom(renderedLinker);
1014 }
1015 return renderedLinker;
1016 }
1017
1018
1019
1020 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataPropertyTermExpressions(CEXPRESSIONLIST<CDataPropertyTermExpression*>* dataPropTermExpList, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
1021 CRenderedItemLinker* tmpRenderedLinker = nullptr;
1022 foreach(CDataPropertyTermExpression* nextDataPropTermExp, *dataPropTermExpList) {
1023 tmpRenderedLinker = getRenderedDataPropertyTermExpression(nextDataPropTermExp, tmpRenderedLinker);
1024 }
1025 return tmpRenderedLinker;
1026 }
1027
1028
1029 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataPropertyTermExpression(CDataPropertyTermExpression* dataPropTermExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
1030 CRenderedItemLinker* renderedLinker = nullptr;
1031 CBuildExpression::ExpressionType type = dataPropTermExp->getType();
1032 if (type == CBuildExpression::BETDATAPROPERTY) {
1033 renderedLinker = getRenderedDataPropertyExpression(dataPropTermExp);
1034 }
1035 return appendPrepandRenderedItemLinker(renderedLinker, prependRenderedLinker, appendRenderedLinker);
1036 }
1037
1038
1039
1040
1041
1042 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataRangeTermExpressions(CEXPRESSIONLIST<CDataRangeTermExpression*>* dataTermExpList, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
1043 CRenderedItemLinker* tmpRenderedLinker = nullptr;
1044 foreach(CDataRangeTermExpression* dataTermExp, *dataTermExpList) {
1045 tmpRenderedLinker = getRenderedDataRangeTermExpression(dataTermExp, tmpRenderedLinker);
1046 }
1047 return tmpRenderedLinker;
1048 }
1049
1050
1051 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataRangeTermExpression(CDataRangeTermExpression* dataRangeTermExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
1052 CRenderedItemLinker* tmpRenderedLinker = nullptr;
1053 CBuildExpression::ExpressionType type = dataRangeTermExp->getType();
1054 if (type == CBuildExpression::BETDATATYPE) {
1055 tmpRenderedLinker = getRenderedDatatypeExpression(dataRangeTermExp);
1056 } else if (type == CBuildExpression::BETDATALITERAL) {
1057 tmpRenderedLinker = getRenderedDataLiteralExpression(dataRangeTermExp);
1058 } else if (type == CBuildExpression::BETDATAINTERSECTIONOF) {
1059 tmpRenderedLinker = getRenderedDataIntersectionOfExpression(dataRangeTermExp);
1060 } else if (type == CBuildExpression::BETDATAUNIONOF) {
1061 tmpRenderedLinker = getRenderedDataUnionOfExpression(dataRangeTermExp);
1062 } else if (type == CBuildExpression::BETDATACOMPLEMENTOF) {
1063 tmpRenderedLinker = getRenderedDataComplementOfExpression(dataRangeTermExp);
1064 } else if (type == CBuildExpression::BETDATAONEOF) {
1065 tmpRenderedLinker = getRenderedDataOneOfExpression(dataRangeTermExp);
1066 } else if (type == CBuildExpression::BETDATATYPERESTRICTION) {
1067 tmpRenderedLinker = getRenderedDatatypeRestrictionExpression(dataRangeTermExp);
1068 }
1069 return appendPrepandRenderedItemLinker(tmpRenderedLinker, prependRenderedLinker, appendRenderedLinker);
1070 }
1071
1072
1073
1074 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDatatypeRestrictionExpression(CDataRangeTermExpression* dataRangeTermExp) {
1075 CRenderedItemLinker* renderedLinker = nullptr;
1076 if (mRenderer->beginRenderDatatypeRestrictionExpression()) {
1077 CDatatypeRestrictionExpression* datatypeRestExp = (CDatatypeRestrictionExpression*)dataRangeTermExp;
1078 renderedLinker = getRenderedDataRangeTermExpression(datatypeRestExp->getDatatypeExpression());
1079 renderedLinker = getRenderedDataFacetRestrictionExpressions(datatypeRestExp->getDataFacetRestrictionExpressionList(), renderedLinker);
1080 renderedLinker = mRenderer->endRenderDatatypeRestrictionExpression(renderedLinker);
1081 }
1082 return renderedLinker;
1083 }
1084
1085
1086
1087
1088 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataFacetRestrictionExpressions(CEXPRESSIONLIST<CDataFacetRestrictionExpression*>* dataFacetRestExpList, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
1089 CRenderedItemLinker* tmpRenderedLinker = nullptr;
1090 foreach(CDataFacetRestrictionExpression* dataFacetRestExp, *dataFacetRestExpList) {
1091 tmpRenderedLinker = getRenderedDataFacetRestrictionExpression(dataFacetRestExp, tmpRenderedLinker);
1092 }
1093 return tmpRenderedLinker;
1094 }
1095
1096
1097
1098
1099 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataFacetRestrictionExpression(CDataFacetRestrictionExpression* dataFacetRestExp, CRenderedItemLinker* prependRenderedLinker, CRenderedItemLinker* appendRenderedLinker) {
1100 CRenderedItemLinker* renderedLinker = nullptr;
1101 const QString& facetName = getNameFromEntityExpression(dataFacetRestExp->getDataFacetExpression());
1102 if (mRenderer->beginRenderDataFacetRestrictionExpression(facetName)) {
1103 renderedLinker = getRenderedDataLiteralExpression(dataFacetRestExp->getDataLiteralExpression());
1104 renderedLinker = mRenderer->endRenderDataFacetRestrictionExpression(renderedLinker, facetName);
1105 }
1106 return appendPrepandRenderedItemLinker(renderedLinker,prependRenderedLinker,appendRenderedLinker);
1107 }
1108
1109
1110 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataOneOfExpression(CDataRangeTermExpression* dataRangeTermExp) {
1111 CRenderedItemLinker* renderedLinker = nullptr;
1112 if (mRenderer->beginRenderDataOneOfExpression()) {
1113 CDataOneOfExpression* dataOneExp = (CDataOneOfExpression*)dataRangeTermExp;
1114 renderedLinker = getRenderedDataRangeTermExpressions(dataOneExp->getDataRangeTermExpressionList());
1115 renderedLinker = mRenderer->endRenderDataOneOfExpression(renderedLinker);
1116 }
1117 return renderedLinker;
1118 }
1119
1120
1121 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataComplementOfExpression(CDataRangeTermExpression* dataRangeTermExp) {
1122 CRenderedItemLinker* renderedLinker = nullptr;
1123 if (mRenderer->beginRenderDataComplementOfExpression()) {
1124 CDataComplementOfExpression* dataComplExp = (CDataComplementOfExpression*)dataRangeTermExp;
1125 renderedLinker = getRenderedDataRangeTermExpression(dataComplExp->getDataRangeTermExpression());
1126 renderedLinker = mRenderer->endRenderDataComplementOfExpression(renderedLinker);
1127 }
1128 return renderedLinker;
1129 }
1130
1131
1132 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataUnionOfExpression(CDataRangeTermExpression* dataRangeTermExp) {
1133 CRenderedItemLinker* renderedLinker = nullptr;
1134 if (mRenderer->beginRenderDataUnionOfExpression()) {
1135 CDataUnionOfExpression* dataUnionExp = (CDataUnionOfExpression*)dataRangeTermExp;
1136 renderedLinker = getRenderedDataRangeTermExpressions(dataUnionExp->getDataRangeTermExpressionList());
1137 renderedLinker = mRenderer->endRenderDataUnionOfExpression(renderedLinker);
1138 }
1139 return renderedLinker;
1140 }
1141
1142
1143
1144 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataIntersectionOfExpression(CDataRangeTermExpression* dataRangeTermExp) {
1145 CRenderedItemLinker* renderedLinker = nullptr;
1146 if (mRenderer->beginRenderDataIntersectionOfExpression()) {
1147 CDataIntersectionOfExpression* dataIntExp = (CDataIntersectionOfExpression*)dataRangeTermExp;
1148 renderedLinker = getRenderedDataRangeTermExpressions(dataIntExp->getDataRangeTermExpressionList());
1149 renderedLinker = mRenderer->endRenderDataIntersectionOfExpression(renderedLinker);
1150 }
1151 return renderedLinker;
1152 }
1153
1154
1155 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataLiteralExpression(CDataRangeTermExpression* dataRangeTermExp) {
1156 CRenderedItemLinker* renderedLinker = nullptr;
1157 CDataLiteralExpression* dataLiteralExpression = (CDataLiteralExpression*)dataRangeTermExp;
1158 const QString& literalValue = getNameFromEntityExpression(dataLiteralExpression->getDataLexicalValueExpression());
1159 const QString& datatypeName = getNameFromEntityExpression(dataLiteralExpression->getDatatypeExpression());
1160 if (mRenderer->beginRenderDataLiteralExpression(literalValue,datatypeName)) {
1161 renderedLinker = mRenderer->endRenderDataLiteralExpression(literalValue, datatypeName);
1162 }
1163 return renderedLinker;
1164 }
1165
1166 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectPropertyExpression(CObjectPropertyTermExpression* objPropTermExp) {
1167 CRenderedItemLinker* renderedLinker = nullptr;
1168 CObjectPropertyExpression* objPropExpression = (CObjectPropertyExpression*)objPropTermExp;
1169 const QString& name = getNameFromEntityExpression(objPropExpression);
1170 if (mRenderer->beginRenderObjectPropertyExpression(name)) {
1171 renderedLinker = mRenderer->endRenderObjectPropertyExpression(name);
1172 }
1173 return renderedLinker;
1174 }
1175
1176
1177
1178 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDataPropertyExpression(CDataPropertyTermExpression* dataPropTermExp) {
1179 CRenderedItemLinker* renderedLinker = nullptr;
1180 CDataPropertyExpression* dataPropExpression = (CDataPropertyExpression*)dataPropTermExp;
1181 const QString& name = getNameFromEntityExpression(dataPropExpression);
1182 if (mRenderer->beginRenderDataPropertyExpression(name)) {
1183 renderedLinker = mRenderer->endRenderDataPropertyExpression(name);
1184 }
1185 return renderedLinker;
1186 }
1187
1188
1189
1190
1191 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedClassExpression(CClassTermExpression* classTermExp) {
1192 CRenderedItemLinker* renderedLinker = nullptr;
1193 CClassExpression* classExpression = (CClassExpression*)classTermExp;
1194 const QString& name = getNameFromEntityExpression(classExpression);
1195 if (mRenderer->beginRenderClassExpression(name)) {
1196 renderedLinker = mRenderer->endRenderClassExpression(name);
1197 }
1198 return renderedLinker;
1199 }
1200
1201
1202 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedDatatypeExpression(CDataRangeTermExpression* dataRangeTermExp) {
1203 CRenderedItemLinker* renderedLinker = nullptr;
1204 CDatatypeExpression* datatypeExpression = (CDatatypeExpression*)dataRangeTermExp;
1205 const QString& name = getNameFromEntityExpression(datatypeExpression);
1206 if (mRenderer->beginRenderDatatypeExpression(name)) {
1207 renderedLinker = mRenderer->endRenderDatatypeExpression(name);
1208 }
1209 return renderedLinker;
1210 }
1211
1212 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectSomeValuesFromExpression(CClassTermExpression* classTermExp) {
1213 CRenderedItemLinker* renderedLinker = nullptr;
1214 if (mRenderer->beginRenderObjectSomeValuesFromExpression()) {
1215 CObjectSomeValuesFromExpression* someValuesFromExp = (CObjectSomeValuesFromExpression*)classTermExp;
1216 renderedLinker = getRenderedObjectPropertyTermExpression(someValuesFromExp->getObjectPropertyTermExpression());
1217 renderedLinker = getRenderedClassTermExpression(someValuesFromExp->getClassTermExpression(), renderedLinker);
1218 renderedLinker = mRenderer->endRenderObjectSomeValuesFromExpression(renderedLinker);
1219 }
1220 return renderedLinker;
1221 }
1222
1223
1224 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectAllValuesFromExpression(CClassTermExpression* classTermExp) {
1225 CRenderedItemLinker* renderedLinker = nullptr;
1226 if (mRenderer->beginRenderObjectAllValuesFromExpression()) {
1227 CObjectAllValuesFromExpression* allValuesFromExp = (CObjectAllValuesFromExpression*)classTermExp;
1228 renderedLinker = getRenderedObjectPropertyTermExpression(allValuesFromExp->getObjectPropertyTermExpression());
1229 renderedLinker = getRenderedClassTermExpression(allValuesFromExp->getClassTermExpression(), renderedLinker);
1230 renderedLinker = mRenderer->endRenderObjectAllValuesFromExpression(renderedLinker);
1231 }
1232 return renderedLinker;
1233 }
1234
1235
1236 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectIntersectionOfExpression(CClassTermExpression* classTermExp) {
1237 CRenderedItemLinker* renderedLinker = nullptr;
1238 CRenderedItemLinker* lastRenderedLinker = nullptr;
1239 if (mRenderer->beginRenderObjectIntersectionOfExpression()) {
1240 CObjectIntersectionOfExpression* intersectionOfExp = (CObjectIntersectionOfExpression*)classTermExp;
1241 renderedLinker = getRenderedClassTermExpressions(intersectionOfExp->getClassTermExpressionList());
1242 renderedLinker = mRenderer->endRenderObjectIntersectionOfExpression(renderedLinker);
1243 }
1244 return renderedLinker;
1245 }
1246
1247
1248 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectUnionOfExpression(CClassTermExpression* classTermExp) {
1249 CRenderedItemLinker* renderedLinker = nullptr;
1250 if (mRenderer->beginRenderObjectUnionOfExpression()) {
1251 CObjectUnionOfExpression* unionOfExp = (CObjectUnionOfExpression*)classTermExp;
1252 renderedLinker = getRenderedClassTermExpressions(unionOfExp->getClassTermExpressionList());
1253 renderedLinker = mRenderer->endRenderObjectUnionOfExpression(renderedLinker);
1254 }
1255 return renderedLinker;
1256 }
1257
1258
1259 CRenderedItemLinker* COntologyAxiomExpressionsRenderVisitor::getRenderedObjectComplementOfExpression(CClassTermExpression* classTermExp) {
1260 CRenderedItemLinker* renderedLinker = nullptr;
1261 if (mRenderer->beginRenderObjectComplementOfExpression()) {
1262 CObjectComplementOfExpression* compOfExp = (CObjectComplementOfExpression*)classTermExp;
1263 renderedLinker = getRenderedClassTermExpression(compOfExp->getComplementExpression());
1264 renderedLinker = mRenderer->endRenderObjectComplementOfExpression(renderedLinker);
1265 }
1266 return renderedLinker;
1267 }
1268
1269
1270
1271 QString COntologyAxiomExpressionsRenderVisitor::getNameFromEntityExpression(CExpressionEntity* entity) {
1272 return entity->getName();
1273 }
1274
1275
1276
1277 }; // end namespace Renderer
1278
1279 }; // end namespace Konclude