Debian Codegraph @

Source/Renderer/COntologyParsedBuildExpressionRenderVisitor.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 "COntologyParsedBuildExpressionRenderVisitor.h"
21
22
23 namespace Konclude {
24
25 namespace Renderer {
26
27
28 COntologyParsedBuildExpressionRenderVisitor::COntologyParsedBuildExpressionRenderVisitor() {
29 }
30
31
32
33
34
35 bool COntologyParsedBuildExpressionRenderVisitor::visitAndRender(const QStringList& entityStringList, CConcreteOntology* ontology, COntologyRenderer* renderer) {
36 mOntology = ontology;
37 mRenderer = renderer;
38 COntologyBuildData* buildDataBox = ontology->getBuildData();
39 mConceptClassTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptClassTermMappingHash();
40 mClassTermExpClassAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermExpressionClassAxiomExpressionHash();
41
42 CBUILDHASH<CStringRefStringHasher,CClassExpression*>* classEntityHash = buildDataBox->getClassEntityBuildHash();
43
44 CQtList<CExpressionEntity*> entityList;
45 foreach (QString entityName, entityStringList) {
46 CClassExpression* classExp = classEntityHash->value(entityName);
47 if (classExp) {
48 entityList.append(classExp);
49 }
50 }
51 visitAndRender(entityList);
52 return true;
53 }
54
55
56 bool COntologyParsedBuildExpressionRenderVisitor::visitAndRender(const CQtList<CConcept*>& conceptList, CConcreteOntology* ontology, COntologyRenderer* renderer) {
57 mOntology = ontology;
58 mRenderer = renderer;
59 COntologyBuildData* buildDataBox = ontology->getBuildData();
60 mConceptClassTermMapHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptClassTermMappingHash();
61 mClassTermExpClassAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermExpressionClassAxiomExpressionHash();
62
63 CQtList<CExpressionEntity*> entityList;
64 foreach (CConcept* concept, conceptList) {
65 CClassTermExpression* classTermExp = mConceptClassTermMapHash->value(concept);
66 if (classTermExp) {
67 CClassExpression* classExp = dynamic_cast<CClassExpression*>(classTermExp);
68 if (classExp) {
69 entityList.append(classExp);
70 }
71 }
72 }
73 visitAndRender(entityList);
74 return true;
75 }
76
77
78 bool COntologyParsedBuildExpressionRenderVisitor::visitAndRender(const CQtList<CExpressionEntity*>& entityList) {
79 CRenderedItemLinker* renderedLinker = nullptr;
80 CRenderedItemLinker* lastRenderedLinker = nullptr;
81
82 if (mRenderer->beginRender()) {
83 foreach (CExpressionEntity* entityExp, entityList) {
84 addRemainingVisitingAndRenderEntity(entityExp);
85 }
86
87 while (!mRemainingEntityList.isEmpty() || !mRemainingAxiomList.isEmpty()) {
88
89 while (!mRemainingEntityList.isEmpty()) {
90 CExpressionEntity* entity = mRemainingEntityList.takeFirst();
91
92 mRenderer->beginRenderDeclarationAxiom();
93 CRenderedItemLinker* tmpRenderedLinker = getRenderedEntityExpression(entity);
94 tmpRenderedLinker = mRenderer->endRenderDeclarationAxiom(tmpRenderedLinker);
95
96 if (tmpRenderedLinker) {
97 if (lastRenderedLinker) {
98 lastRenderedLinker = lastRenderedLinker->append(tmpRenderedLinker);
99 } else {
100 renderedLinker = tmpRenderedLinker;
101 }
102 lastRenderedLinker = tmpRenderedLinker;
103 }
104 }
105
106 while (!mRemainingAxiomList.isEmpty()) {
107 CAxiomExpression* axiomExp = mRemainingAxiomList.takeFirst();
108 CRenderedItemLinker* tmpRenderedLinker = getRenderedAxiomExpression(axiomExp);
109
110 if (tmpRenderedLinker) {
111 if (lastRenderedLinker) {
112 lastRenderedLinker = lastRenderedLinker->append(tmpRenderedLinker);
113 } else {
114 renderedLinker = tmpRenderedLinker;
115 }
116 lastRenderedLinker = tmpRenderedLinker;
117 }
118 }
119 }
120 mRenderer->endRender(renderedLinker);
121 return true;
122 }
123 return false;
124 }
125
126
127 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedAxiomExpression(CAxiomExpression* axiomExp) {
128 CRenderedItemLinker* renderedLinker = nullptr;
129 CBuildExpression::ExpressionType type = axiomExp->getType();
130 if (type == CBuildExpression::BETESUBCLASSOF) {
131 renderedLinker = getRenderedSubClassOfAxiom(axiomExp);
132 }
133 return renderedLinker;
134 }
135
136 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedSubClassOfAxiom(CAxiomExpression* axiomExp) {
137 CRenderedItemLinker* renderedLinker = nullptr;
138 if (mRenderer->beginRenderSubClassOfAxiom()) {
139 CSubClassOfExpression* subClassOfExp = (CSubClassOfExpression*)axiomExp;
140 CClassTermExpression* subClassTermExp = subClassOfExp->getSubClassTermExpression();
141 renderedLinker = getRenderedClassTermExpression(subClassTermExp);
142 CClassTermExpression* superClassTermExp = subClassOfExp->getSuperClassTermExpression();
143 CRenderedItemLinker* tmpRenderedLinker = getRenderedClassTermExpression(superClassTermExp);
144 if (renderedLinker) {
145 renderedLinker->append(tmpRenderedLinker);
146 } else {
147 renderedLinker = tmpRenderedLinker;
148 }
149 renderedLinker = mRenderer->endRenderSubClassOfAxiom(renderedLinker);
150 }
151 return renderedLinker;
152 }
153
154
155 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedClassTermExpression(CClassTermExpression* classTermExp) {
156 CRenderedItemLinker* renderedLinker = nullptr;
157 CBuildExpression::ExpressionType type = classTermExp->getType();
158 if (type == CBuildExpression::BETCLASS) {
159 renderedLinker = getRenderedClassExpression(classTermExp);
160 } else if (type == CBuildExpression::BETOBJECTINTERSECTION) {
161 renderedLinker = getRenderedObjectIntersectionOfExpression(classTermExp);
162 } else if (type == CBuildExpression::BETOBJECTUNION) {
163 renderedLinker = getRenderedObjectUnionOfExpression(classTermExp);
164 } else if (type == CBuildExpression::BETOBJECTCOMPLEMENTOF) {
165 renderedLinker = getRenderedObjectComplementOfExpression(classTermExp);
166 } else if (type == CBuildExpression::BETOBJECTSOMEVALUEFROM) {
167 renderedLinker = getRenderedObjectSomeValuesFromExpression(classTermExp);
168 } else if (type == CBuildExpression::BETOBJECTALLVALUEFROM) {
169 renderedLinker = getRenderedObjectAllValuesFromExpression(classTermExp);
170 }
171 return renderedLinker;
172 }
173
174
175
176 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectPropertyTermExpression(CObjectPropertyTermExpression* objPropTermExp) {
177 CRenderedItemLinker* renderedLinker = nullptr;
178 CBuildExpression::ExpressionType type = objPropTermExp->getType();
179 if (type == CBuildExpression::BETOBJECTPROPERTY) {
180 renderedLinker = getRenderedObjectPropertyExpression(objPropTermExp);
181 }
182 return renderedLinker;
183 }
184
185
186 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectPropertyExpression(CObjectPropertyTermExpression* objPropTermExp) {
187 CRenderedItemLinker* renderedLinker = nullptr;
188 CObjectPropertyExpression* objPropExpression = (CObjectPropertyExpression*)objPropTermExp;
189 const QString& name = getNameFromEntityExpression(objPropExpression);
190 if (mRenderer->beginRenderObjectPropertyExpression(name)) {
191 addRemainingVisitingAndRenderEntity(objPropExpression);
192 renderedLinker = mRenderer->endRenderObjectPropertyExpression(name);
193 }
194 return renderedLinker;
195 }
196
197
198
199
200 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedClassExpression(CClassTermExpression* classTermExp) {
201 CRenderedItemLinker* renderedLinker = nullptr;
202 CClassExpression* classExpression = (CClassExpression*)classTermExp;
203 const QString& name = getNameFromEntityExpression(classExpression);
204 if (mRenderer->beginRenderClassExpression(name)) {
205 addRemainingVisitingAndRenderEntity(classExpression);
206 renderedLinker = mRenderer->endRenderClassExpression(name);
207 }
208 return renderedLinker;
209 }
210
211
212 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectSomeValuesFromExpression(CClassTermExpression* classTermExp) {
213 CRenderedItemLinker* renderedLinker = nullptr;
214 if (mRenderer->beginRenderObjectSomeValuesFromExpression()) {
215 serachRemainingVisitingAndRenderAxiom(classTermExp);
216 CObjectSomeValuesFromExpression* someValuesFromExp = (CObjectSomeValuesFromExpression*)classTermExp;
217 renderedLinker = getRenderedObjectPropertyTermExpression(someValuesFromExp->getObjectPropertyTermExpression());
218 CRenderedItemLinker* tmpRenderedLinker = getRenderedClassTermExpression(someValuesFromExp->getClassTermExpression());
219 if (renderedLinker) {
220 renderedLinker->append(tmpRenderedLinker);
221 } else {
222 renderedLinker = tmpRenderedLinker;
223 }
224 renderedLinker = mRenderer->endRenderObjectSomeValuesFromExpression(renderedLinker);
225 }
226 return renderedLinker;
227 }
228
229
230 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectAllValuesFromExpression(CClassTermExpression* classTermExp) {
231 CRenderedItemLinker* renderedLinker = nullptr;
232 if (mRenderer->beginRenderObjectAllValuesFromExpression()) {
233 serachRemainingVisitingAndRenderAxiom(classTermExp);
234 CObjectAllValuesFromExpression* allValuesFromExp = (CObjectAllValuesFromExpression*)classTermExp;
235 renderedLinker = getRenderedObjectPropertyTermExpression(allValuesFromExp->getObjectPropertyTermExpression());
236 CRenderedItemLinker* tmpRenderedLinker = getRenderedClassTermExpression(allValuesFromExp->getClassTermExpression());
237 if (renderedLinker) {
238 renderedLinker->append(tmpRenderedLinker);
239 } else {
240 renderedLinker = tmpRenderedLinker;
241 }
242 renderedLinker = mRenderer->endRenderObjectAllValuesFromExpression(renderedLinker);
243 }
244 return renderedLinker;
245 }
246
247
248 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectIntersectionOfExpression(CClassTermExpression* classTermExp) {
249 CRenderedItemLinker* renderedLinker = nullptr;
250 CRenderedItemLinker* lastRenderedLinker = nullptr;
251 if (mRenderer->beginRenderObjectIntersectionOfExpression()) {
252 serachRemainingVisitingAndRenderAxiom(classTermExp);
253 CObjectIntersectionOfExpression* intersectionOfExp = (CObjectIntersectionOfExpression*)classTermExp;
254 foreach (CClassTermExpression* nextClassTermExp, *intersectionOfExp->getClassTermExpressionList()) {
255 CRenderedItemLinker* tmpRenderedLinker = getRenderedClassTermExpression(nextClassTermExp);
256 if (tmpRenderedLinker) {
257 if (lastRenderedLinker) {
258 lastRenderedLinker = lastRenderedLinker->append(tmpRenderedLinker);
259 } else {
260 renderedLinker = tmpRenderedLinker;
261 }
262 lastRenderedLinker = tmpRenderedLinker;
263 }
264 }
265 renderedLinker = mRenderer->endRenderObjectIntersectionOfExpression(renderedLinker);
266 }
267 return renderedLinker;
268 }
269
270
271 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectUnionOfExpression(CClassTermExpression* classTermExp) {
272 CRenderedItemLinker* renderedLinker = nullptr;
273 CRenderedItemLinker* lastRenderedLinker = nullptr;
274 if (mRenderer->beginRenderObjectUnionOfExpression()) {
275 serachRemainingVisitingAndRenderAxiom(classTermExp);
276 CObjectUnionOfExpression* unionOfExp = (CObjectUnionOfExpression*)classTermExp;
277 foreach (CClassTermExpression* nextClassTermExp, *unionOfExp->getClassTermExpressionList()) {
278 CRenderedItemLinker* tmpRenderedLinker = getRenderedClassTermExpression(nextClassTermExp);
279 if (tmpRenderedLinker) {
280 if (lastRenderedLinker) {
281 lastRenderedLinker = lastRenderedLinker->append(tmpRenderedLinker);
282 } else {
283 renderedLinker = tmpRenderedLinker;
284 }
285 lastRenderedLinker = tmpRenderedLinker;
286 }
287 }
288 renderedLinker = mRenderer->endRenderObjectUnionOfExpression(renderedLinker);
289 }
290 return renderedLinker;
291 }
292
293
294 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedObjectComplementOfExpression(CClassTermExpression* classTermExp) {
295 CRenderedItemLinker* renderedLinker = nullptr;
296 if (mRenderer->beginRenderObjectComplementOfExpression()) {
297 serachRemainingVisitingAndRenderAxiom(classTermExp);
298 CObjectComplementOfExpression* unionOfExp = (CObjectComplementOfExpression*)classTermExp;
299 renderedLinker = getRenderedClassTermExpression(unionOfExp->getComplementExpression());
300 renderedLinker = mRenderer->endRenderObjectComplementOfExpression(renderedLinker);
301 }
302 return renderedLinker;
303 }
304
305
306
307 QString COntologyParsedBuildExpressionRenderVisitor::getNameFromEntityExpression(CExpressionEntity* entity) {
308 return entity->getName();
309 }
310
311 CRenderedItemLinker* COntologyParsedBuildExpressionRenderVisitor::getRenderedEntityExpression(CExpressionEntity* entity) {
312 CRenderedItemLinker* renderedLinker = nullptr;
313 const QString& name = getNameFromEntityExpression(entity);
314 CClassExpression* classExpression = dynamic_cast<CClassExpression*>(entity);
315 if (classExpression) {
316 if (mRenderer->beginRenderClassExpression(name)) {
317 renderedLinker = mRenderer->endRenderClassExpression(name);
318 serachRemainingVisitingAndRenderAxiom(classExpression);
319 }
320 } else {
321 CObjectPropertyExpression* propertyExpression = dynamic_cast<CObjectPropertyExpression*>(entity);
322 if (propertyExpression) {
323 if (mRenderer->beginRenderObjectPropertyExpression(name)) {
324 renderedLinker = mRenderer->endRenderObjectPropertyExpression(name);
325 serachRemainingVisitingAndRenderAxiom(propertyExpression);
326 }
327 }
328 }
329 return renderedLinker;
330 }
331
332
333 bool COntologyParsedBuildExpressionRenderVisitor::serachRemainingVisitingAndRenderAxiom(CClassTermExpression* expression) {
334 bool foundAxiom = false;
335 if (!mTestedAxiomSet.contains(expression)) {
336 mTestedAxiomSet.insert(expression);
337 foreach (CClassAxiomExpression* axiomExpression, mClassTermExpClassAxiomHash->values(expression)) {
338 if (!mVisitedAxiomSet.contains(axiomExpression)) {
339 mVisitedAxiomSet.insert(axiomExpression);
340 mRemainingAxiomList.append(axiomExpression);
341 foundAxiom = true;
342 }
343 }
344 }
345 return foundAxiom;
346 }
347
348
349 bool COntologyParsedBuildExpressionRenderVisitor::serachRemainingVisitingAndRenderAxiom(CObjectPropertyTermExpression* expression) {
350 bool foundAxiom = false;
351 if (!mTestedAxiomSet.contains(expression)) {
352 mTestedAxiomSet.insert(expression);
353 }
354 return foundAxiom;
355 }
356
357
358 bool COntologyParsedBuildExpressionRenderVisitor::addRemainingVisitingAndRenderEntity(CExpressionEntity* entity) {
359 if (!mVisitedEntitySet.contains(entity)) {
360 mVisitedEntitySet.insert(entity);
361 mRemainingEntityList.append(entity);
362 return true;
363 }
364 return false;
365 }
366
367
368 }; // end namespace Renderer
369
370 }; // end namespace Konclude