Debian Codegraph @

Source/Reasoner/Ontology/CTBox.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CTBox.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CTBox::CTBox(CBoxContext* boxContext) {
32 mBoxContext = boxContext;
33 mMemMan = CContext::getMemoryAllocationManager(mBoxContext);
34 concepts = nullptr;
35 mDeleteBoxContext = nullptr;
36 mTriggerImpHash = nullptr;
37 mEquivConCandidateHash = nullptr;
38 mCandidateEquivConHash = nullptr;
39 mEquivConNonCandidateSet = nullptr;
40 mConceptOfInterestSet = nullptr;
41 mTriggeredConceptOfInterestSet = nullptr;
42 mConceptOfInterestList = nullptr;
43 mConOfIntActivationTriggerHash = nullptr;
44 mCandidateConOfIntHash = nullptr;
45 mTriggerConOfIntHash = nullptr;
46 mRoleDomainTriggerConceptHash = nullptr;
47 mIndividualTriggerConceptHash = nullptr;
48 mUnivConnNomValueCon = nullptr;
49 gciConceptSet = 0;
50 activeConceptSet = 0;
51 mBottomConceptIndex = 0;
52 mTopConceptIndex = 1;
53 mIndividualTriggerConceptIndex = 2;
54 mTopDataRangeConceptIndex = 3;
55 mDatatypeVector = nullptr;
56 mMinimalNextConceptID = 4;
57 }
58
59
60 CTBox::~CTBox() {
61 delete mDeleteBoxContext;
62 COPADestroyAndRelease(gciConceptSet,mMemMan);
63 COPADestroyAndRelease(activeConceptSet,mMemMan);
64 COPADestroyAndRelease(concepts,mMemMan);
65 COPADestroyAndRelease(mTriggerImpHash,mMemMan);
66 COPADestroyAndRelease(mEquivConCandidateHash,mMemMan);
67 COPADestroyAndRelease(mCandidateEquivConHash,mMemMan);
68 COPADestroyAndRelease(mEquivConNonCandidateSet,mMemMan);
69 COPADestroyAndRelease(mConceptOfInterestSet, mMemMan);
70 COPADestroyAndRelease(mTriggeredConceptOfInterestSet, mMemMan);
71 COPADestroyAndRelease(mConceptOfInterestList, mMemMan);
72 COPADestroyAndRelease(mRoleDomainTriggerConceptHash,mMemMan);
73 COPADestroyAndRelease(mIndividualTriggerConceptHash,mMemMan);
74 COPADestroyAndRelease(mDatatypeVector,mMemMan);
75 COPADestroyAndRelease(mConOfIntActivationTriggerHash, mMemMan);
76 COPADestroyAndRelease(mCandidateConOfIntHash, mMemMan);
77 COPADestroyAndRelease(mTriggerConOfIntHash, mMemMan);
78
79 }
80
81 cint64 CTBox::getTopConceptIndex() {
82 return mTopConceptIndex;
83 }
84
85 cint64 CTBox::getBottomConceptIndex() {
86 return mBottomConceptIndex;
87 }
88
89 cint64 CTBox::getIndividualTriggerConceptIndex() {
90 return mIndividualTriggerConceptIndex;
91 }
92
93
94 cint64 CTBox::getTopDataRangeConceptIndex() {
95 return mTopDataRangeConceptIndex;
96 }
97
98 CConcept* CTBox::getTopConcept() {
99 CConcept* concept = nullptr;
100 if (concepts) {
101 concept = concepts->getData(mTopConceptIndex);
102 }
103 return concept;
104 }
105
106
107
108 CConcept* CTBox::getTopDataRangeConcept() {
109 CConcept* concept = nullptr;
110 if (concepts) {
111 concept = concepts->getData(mTopDataRangeConceptIndex);
112 }
113 return concept;
114 }
115
116 CConcept* CTBox::getIndividualTriggerConcept() {
117 CConcept* concept = nullptr;
118 if (concepts) {
119 concept = concepts->getData(mIndividualTriggerConceptIndex);
120 }
121 return concept;
122 }
123
124 CConcept* CTBox::getBottomConcept() {
125 CConcept* concept = nullptr;
126 if (concepts) {
127 concept = concepts->getData(mBottomConceptIndex);
128 }
129 return concept;
130 }
131
132 CTBox* CTBox::setTopConcept(CConcept* topConcept) {
133 getConceptVector(true)->setData(mTopConceptIndex,topConcept);
134 return this;
135 }
136
137 CTBox* CTBox::setBottomConcept(CConcept* bottomConcept) {
138 getConceptVector(true)->setData(mBottomConceptIndex,bottomConcept);
139 return this;
140 }
141
142 CTBox* CTBox::setIndividualTriggerConcept(CConcept* indTrigConcept) {
143 getConceptVector(true)->setData(mIndividualTriggerConceptIndex,indTrigConcept);
144 return this;
145 }
146
147
148 CTBox* CTBox::setTopDataRangeConcept(CConcept* topDataRangeConcept) {
149 getConceptVector(true)->setData(mTopDataRangeConceptIndex,topDataRangeConcept);
150 return this;
151 }
152
153 CBOXSET<CConcept*>* CTBox::getGCIConceptSet() {
154 return gciConceptSet;
155 }
156
157 CTBox *CTBox::setGCIConceptSet(CBOXSET<CConcept*>* takeContainsSet) {
158 COPADestroyAndRelease(gciConceptSet,mMemMan);
159 gciConceptSet = takeContainsSet;
160 return this;
161 }
162
163
164 CBOXSET<CConcept*> *CTBox::getActiveClassConceptSet(bool create) {
165 if (!activeConceptSet && create) {
166 activeConceptSet = CObjectParameterizingAllocator< CBOXSET<CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
167 }
168 return activeConceptSet;
169 }
170
171 CTBox *CTBox::setActiveClassConceptSet(CBOXSET<CConcept*>* takeActiveConceptSet) {
172 COPADestroyAndRelease(activeConceptSet,mMemMan);
173 activeConceptSet = takeActiveConceptSet;
174 return this;
175 }
176
177
178 CBOXHASH<CConcept*,CConcept*>* CTBox::getTriggerImplicationHash(bool create) {
179 if (!mTriggerImpHash && create) {
180 mTriggerImpHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
181 }
182 return mTriggerImpHash;
183 }
184
185 CBOXHASH<CConcept*,CConcept*>* CTBox::getEquivalentConceptCandidateHash(bool create) {
186 if (!mEquivConCandidateHash && create) {
187 mEquivConCandidateHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
188 }
189 return mEquivConCandidateHash;
190 }
191
192 CBOXHASH<CConcept*,CConcept*>* CTBox::getCandidateEquivalentConceptHash(bool create) {
193 if (!mCandidateEquivConHash && create) {
194 mCandidateEquivConHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
195 }
196 return mCandidateEquivConHash;
197 }
198
199 CBOXSET<CConcept*>* CTBox::getEquivalentConceptNonCandidateSet(bool create) {
200 if (!mEquivConNonCandidateSet && create) {
201 mEquivConNonCandidateSet = CObjectParameterizingAllocator< CBOXSET<CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
202 }
203 return mEquivConNonCandidateSet;
204 }
205
206
207 CBOXHASH<CRole*,CConcept*>* CTBox::getRoleDomainTriggerConceptHash(bool create) {
208 if (!mRoleDomainTriggerConceptHash && create) {
209 mRoleDomainTriggerConceptHash = CObjectParameterizingAllocator< CBOXHASH<CRole*,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
210 }
211 return mRoleDomainTriggerConceptHash;
212 }
213
214 CBOXHASH<cint64,CConcept*>* CTBox::getIndividualTriggerConceptHash(bool create) {
215 if (!mIndividualTriggerConceptHash && create) {
216 mIndividualTriggerConceptHash = CObjectParameterizingAllocator< CBOXHASH<cint64,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
217 }
218 return mIndividualTriggerConceptHash;
219 }
220
221
222
223 CBOXSET<TConceptNegPair>* CTBox::getConceptOfInterestSet(bool create) {
224 if (!mConceptOfInterestSet && create) {
225 mConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET<TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
226 }
227 return mConceptOfInterestSet;
228 }
229
230
231 CBOXSET<TConceptNegPair>* CTBox::getTriggeredConceptOfInterestSet(bool create) {
232 if (!mTriggeredConceptOfInterestSet && create) {
233 mTriggeredConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET<TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
234 }
235 return mTriggeredConceptOfInterestSet;
236 }
237
238 CBOXLIST<TConceptNegPair>* CTBox::getConceptOfInterestList(bool create) {
239 if (!mConceptOfInterestList && create) {
240 mConceptOfInterestList = CObjectParameterizingAllocator< CBOXLIST<TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
241 }
242 return mConceptOfInterestList;
243 }
244
245 CBOXHASH<TConceptNegPair, CConceptOfInterestActivationTriggeringData>* CTBox::getConceptOfInterestActivationTriggerDataHash(bool create) {
246 if (!mConOfIntActivationTriggerHash && create) {
247 mConOfIntActivationTriggerHash = CObjectParameterizingAllocator< CBOXHASH<TConceptNegPair, CConceptOfInterestActivationTriggeringData>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
248 }
249 return mConOfIntActivationTriggerHash;
250 }
251
252 CBOXHASH<CConcept*, TConceptNegPair>* CTBox::getCandidateConceptOfInterestHash(bool create) {
253 if (!mCandidateConOfIntHash && create) {
254 mCandidateConOfIntHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*, TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
255 }
256 return mCandidateConOfIntHash;
257 }
258
259 CBOXHASH<CConcept*, TConceptNegPair>* CTBox::getTriggerConceptOfInterestHash(bool create) {
260 if (!mTriggerConOfIntHash && create) {
261 mTriggerConOfIntHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*, TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
262 }
263 return mTriggerConOfIntHash;
264 }
265
266 CTBox* CTBox::setTriggerImplicationHash(CBOXHASH<CConcept*,CConcept*>* takeTriggerImplHash) {
267 COPADestroyAndRelease(mTriggerImpHash,mMemMan);
268 mTriggerImpHash = takeTriggerImplHash;
269 return this;
270 }
271
272
273
274 CTBox *CTBox::setConceptVector(CConceptVector* takeConceptVec) {
275 COPADestroyAndRelease(concepts,mMemMan);
276 concepts = takeConceptVec;
277 return this;
278 }
279
280
281 CConceptVector* CTBox::getConceptVector(bool create) {
282 if (!concepts && create) {
283 concepts = CObjectParameterizingAllocator<CConceptVector,CContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
284 }
285 return concepts;
286 }
287
288
289 qint64 CTBox::getConceptCount() {
290 cint64 conCount = 0;
291 if (concepts) {
292 conCount = concepts->getItemCount();
293 }
294 return conCount;
295 }
296
297
298
299 CTBox *CTBox::getTBoxReferenceCopy(CBoxContext* boxContext) {
300 CTBox *tBox = CObjectParameterizingAllocator<CTBox,CBoxContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(boxContext),boxContext);
301 tBox->referenceTBox(this);
302 return tBox;
303 }
304
305
306 CDatatypeVector *CTBox::getDatatypeVector(bool create) {
307 if (!mDatatypeVector && create) {
308 mDatatypeVector = CObjectParameterizingAllocator<CDatatypeVector,CBoxContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
309 }
310 return mDatatypeVector;
311 }
312
313
314 CTBox *CTBox::setDatatypeVector(CDatatypeVector* datatypeVector) {
315 COPADestroyAndRelease(mDatatypeVector,mMemMan);
316 mDatatypeVector = datatypeVector;
317 return this;
318 }
319
320
321 CTBox *CTBox::referenceTBox(CTBox *tBox) {
322 mMinimalNextConceptID = tBox->mMinimalNextConceptID;
323 if (tBox->concepts) {
324 getConceptVector();
325 concepts->referenceVector(tBox->concepts);
326 } else if (concepts) {
327 concepts->clear();
328 }
329 if (tBox->mDatatypeVector) {
330 getDatatypeVector();
331 mDatatypeVector->referenceVector(tBox->mDatatypeVector);
332 } else if (mDatatypeVector) {
333 mDatatypeVector->clear();
334 }
335 if (tBox->gciConceptSet) {
336 if (!gciConceptSet) {
337 gciConceptSet = CObjectParameterizingAllocator< CBOXSET<CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
338 }
339 gciConceptSet->init(tBox->gciConceptSet,mBoxContext);
340 } else if (gciConceptSet) {
341 gciConceptSet->clear();
342 }
343 if (tBox->activeConceptSet) {
344 if (!activeConceptSet) {
345 activeConceptSet = CObjectParameterizingAllocator< CBOXSET<CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
346 }
347 activeConceptSet->init(tBox->activeConceptSet,mBoxContext);
348 } else if (activeConceptSet) {
349 activeConceptSet->clear();
350 }
351 mUnivConnNomValueCon = tBox->mUnivConnNomValueCon;
352 if (tBox->mIndividualTriggerConceptHash) {
353 if (!mIndividualTriggerConceptHash) {
354 mIndividualTriggerConceptHash = CObjectParameterizingAllocator< CBOXHASH<cint64,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
355 }
356 mIndividualTriggerConceptHash->init(tBox->mIndividualTriggerConceptHash,mBoxContext);
357 } else if (mIndividualTriggerConceptHash) {
358 mIndividualTriggerConceptHash->clear();
359 }
360 if (tBox->mEquivConCandidateHash) {
361 if (!mEquivConCandidateHash) {
362 mEquivConCandidateHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
363 }
364 mEquivConCandidateHash->init(tBox->mEquivConCandidateHash,mBoxContext);
365 } else if (mEquivConCandidateHash) {
366 mEquivConCandidateHash->clear();
367 }
368 if (tBox->mCandidateEquivConHash) {
369 if (!mCandidateEquivConHash) {
370 mCandidateEquivConHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*,CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
371 }
372 mCandidateEquivConHash->init(tBox->mCandidateEquivConHash,mBoxContext);
373 } else if (mCandidateEquivConHash) {
374 mCandidateEquivConHash->clear();
375 }
376 if (tBox->mEquivConNonCandidateSet) {
377 if (!mEquivConNonCandidateSet) {
378 mEquivConNonCandidateSet = CObjectParameterizingAllocator< CBOXSET<CConcept*>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
379 }
380 mEquivConNonCandidateSet->init(tBox->mEquivConNonCandidateSet,mBoxContext);
381 } else if (mEquivConNonCandidateSet) {
382 mEquivConNonCandidateSet->clear();
383 }
384 if (tBox->mConceptOfInterestSet) {
385 if (!mConceptOfInterestSet) {
386 mConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET<TConceptNegPair>,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
387 }
388 mConceptOfInterestSet->init(tBox->mConceptOfInterestSet,mBoxContext);
389 } else if (mConceptOfInterestSet) {
390 mConceptOfInterestSet->clear();
391 }
392 if (tBox->mTriggeredConceptOfInterestSet) {
393 if (!mTriggeredConceptOfInterestSet) {
394 mTriggeredConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET<TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
395 }
396 mTriggeredConceptOfInterestSet->init(tBox->mTriggeredConceptOfInterestSet, mBoxContext);
397 }
398 else if (mTriggeredConceptOfInterestSet) {
399 mTriggeredConceptOfInterestSet->clear();
400 }
401 if (tBox->mConceptOfInterestList) {
402 if (!mConceptOfInterestList) {
403 mConceptOfInterestList = CObjectParameterizingAllocator< CBOXLIST<TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
404 }
405 mConceptOfInterestList->init(tBox->mConceptOfInterestList, mBoxContext);
406 }
407 else if (mConceptOfInterestList) {
408 mConceptOfInterestList->clear();
409 }
410
411 if (tBox->mConOfIntActivationTriggerHash) {
412 if (!mConOfIntActivationTriggerHash) {
413 mConOfIntActivationTriggerHash = CObjectParameterizingAllocator< CBOXHASH<TConceptNegPair, CConceptOfInterestActivationTriggeringData>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
414 }
415 mConOfIntActivationTriggerHash->init(tBox->mConOfIntActivationTriggerHash, mBoxContext);
416 } else if (mConOfIntActivationTriggerHash) {
417 mConOfIntActivationTriggerHash->clear();
418 }
419 if (tBox->mCandidateConOfIntHash) {
420 if (!mCandidateConOfIntHash) {
421 mCandidateConOfIntHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*, TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
422 }
423 mCandidateConOfIntHash->init(tBox->mCandidateConOfIntHash, mBoxContext);
424 } else if (mCandidateConOfIntHash) {
425 mCandidateConOfIntHash->clear();
426 }
427 if (tBox->mTriggerConOfIntHash) {
428 if (!mTriggerConOfIntHash) {
429 mTriggerConOfIntHash = CObjectParameterizingAllocator< CBOXHASH<CConcept*, TConceptNegPair>, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
430 }
431 mTriggerConOfIntHash->init(tBox->mTriggerConOfIntHash, mBoxContext);
432 }
433 else if (mTriggerConOfIntHash) {
434 mTriggerConOfIntHash->clear();
435 }
436
437
438
439
440 return this;
441 }
442
443
444
445 CBoxContext *CTBox::getBoxContext(bool create) {
446 if (!mBoxContext && create) {
447 mBoxContext = new CConcreteOntologyContextBase();
448 mDeleteBoxContext = mBoxContext;
449 }
450 return mBoxContext;
451 }
452
453 QString CTBox::getTBoxString() {
454 QString tboxString;
455 if (concepts) {
456 for (qint64 i = 0; i < concepts->getItemCount(); ++i) {
457 CConcept *concept = concepts->getData(i);
458 if (concept) {
459 QString conceptString = QString::number(i);
460 while (conceptString.length() <= 5) {
461 conceptString.insert(0," ");
462 }
463 conceptString += ",";
464 qint64 conOpCode = concept->getOperatorCode();
465 QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker());
466 if (!iriClassNameString.isEmpty()) {
467 conceptString += iriClassNameString + " = ";
468 } else {
469 conceptString += " = ";
470 }
471 CRole *role = concept->getRole();
472 QString paramString = QString::number(concept->getParameter());
473 QString roleString;
474 if (role) {
475 roleString = QString::number(role->getRoleTag());
476 }
477 CIndividual* indi = concept->getNominalIndividual();
478 QString indiString;
479 if (indi) {
480 indiString = QString::number(indi->getIndividualID());
481 }
482
483 if (conOpCode == CCNONE) {
484 conceptString += "( ATOM )";
485 } else if (conOpCode == CCTOP) {
486 conceptString += "( TOP "+getConceptOperandString(concept->getOperandList())+")";
487 } else if (conOpCode == CCBOTTOM) {
488 conceptString += "( BOTTOM )";
489 } else if (conOpCode == CCAND) {
490 conceptString += "( AND "+getConceptOperandString(concept->getOperandList())+")";
491 } else if (conOpCode == CCAQAND) {
492 conceptString += "( AQAND "+getConceptOperandString(concept->getOperandList())+")";
493 } else if (conOpCode == CCIMPLAQAND) {
494 conceptString += "( IMPLAQAND "+getConceptOperandString(concept->getOperandList())+")";
495 } else if (conOpCode == CCBRANCHAQAND) {
496 conceptString += "( BRANCHAQAND "+getConceptOperandString(concept->getOperandList())+")";
497 } else if (conOpCode == CCPBINDAQAND) {
498 conceptString += "( PBINDAQAND "+getConceptOperandString(concept->getOperandList())+")";
499 } else if (conOpCode == CCVARBINDAQAND) {
500 conceptString += "( VARBINDAQAND "+getConceptOperandString(concept->getOperandList())+")";
501 } else if (conOpCode == CCVARPBACKAQAND) {
502 conceptString += "( VARPBACKAQAND "+getConceptOperandString(concept->getOperandList())+")";
503 } else if (conOpCode == CCEQ) {
504 conceptString += "( EQ "+getConceptOperandString(concept->getOperandList())+")";
505 } else if (conOpCode == CCSUB) {
506 conceptString += "( SUB "+getConceptOperandString(concept->getOperandList())+")";
507 } else if (conOpCode == CCIMPLTRIG) {
508 conceptString += "( IMPTRIGGER "+getConceptOperandString(concept->getOperandList())+")";
509 } else if (conOpCode == CCBRANCHTRIG) {
510 conceptString += "( BRANCHTRIG "+getConceptOperandString(concept->getOperandList())+")";
511 } else if (conOpCode == CCPBINDTRIG) {
512 conceptString += "( PBINDTRIG "+getConceptOperandString(concept->getOperandList())+")";
513 } else if (conOpCode == CCVARBINDTRIG) {
514 conceptString += "( VARBINDTRIG "+getConceptOperandString(concept->getOperandList())+")";
515 } else if (conOpCode == CCVARPBACKTRIG) {
516 conceptString += "( VARPBACKTRIG "+getConceptOperandString(concept->getOperandList())+")";
517 } else if (conOpCode == CCBACKACTIVTRIG) {
518 conceptString += "( BACKACTIVTRIG "+getConceptOperandString(concept->getOperandList())+")";
519 } else if (conOpCode == CCOR) {
520 conceptString += "( OR "+getConceptOperandString(concept->getOperandList())+")";
521 } else if (conOpCode == CCAQCHOOCE) {
522 conceptString += "( AQCHOOCE "+getConceptOperandString(concept->getOperandList())+")";
523 } else if (conOpCode == CCSOME) {
524 conceptString += QString("( SOME %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
525 } else if (conOpCode == CCSELF) {
526 conceptString += QString("( SELF %1. ").arg(roleString)+")";
527 } else if (conOpCode == CCNOMINAL) {
528 conceptString += QString("( NOMINAL %1. ").arg(indiString)+")";
529 } else if (conOpCode == CCAQSOME) {
530 conceptString += QString("( AQSOME %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
531 } else if (conOpCode == CCATLEAST) {
532 conceptString += QString("( ATLEAST %1. [%2] ").arg(roleString).arg(paramString)+getConceptOperandString(concept->getOperandList())+")";
533 } else if (conOpCode == CCATMOST) {
534 conceptString += QString("( ATMOST %1. [%2] ").arg(roleString).arg(paramString)+getConceptOperandString(concept->getOperandList())+")";
535 } else if (conOpCode == CCALL) {
536 conceptString += QString("( ALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
537 } else if (conOpCode == CCIMPLALL) {
538 conceptString += QString("( IMPLALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
539 } else if (conOpCode == CCBRANCHALL) {
540 conceptString += QString("( BRANCHALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
541 } else if (conOpCode == CCPBINDALL) {
542 conceptString += QString("( PBINDALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
543 } else if (conOpCode == CCVARBINDALL) {
544 conceptString += QString("( VARBINDALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
545 } else if (conOpCode == CCVARPBACKALL) {
546 conceptString += QString("( VARPBACKALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
547 } else if (conOpCode == CCIMPLAQALL) {
548 conceptString += QString("( IMPLAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
549 } else if (conOpCode == CCAQALL) {
550 conceptString += QString("( AQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
551 } else if (conOpCode == CCBRANCHAQALL) {
552 conceptString += QString("( BRANCHAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
553 } else if (conOpCode == CCPBINDAQALL) {
554 conceptString += QString("( PBINDAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
555 } else if (conOpCode == CCVARBINDAQALL) {
556 conceptString += QString("( VARBINDAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
557 } else if (conOpCode == CCVARPBACKAQALL) {
558 conceptString += QString("( VARPBACKAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
559 } else if (conOpCode == CCNOT) {
560 conceptString += "( NOT "+getConceptOperandString(concept->getOperandList())+")";
561 }
562 conceptString += "\r\n";
563 tboxString += conceptString;
564 }
565 }
566 }
567 return tboxString;
568 }
569
570
571 QString CTBox::getConceptOperandString(CSortedNegLinker<CConcept *> *ops) {
572 QString conceptString;
573 while (ops) {
574 if (ops->isNegated()) {
575 conceptString += "-";
576 }
577 conceptString += QString::number(ops->getData()->getConceptTag()) + " ";
578 ops = ops->getNext();
579 }
580 return conceptString;
581 }
582
583
584
585 CConcept* CTBox::getUniversalConnectionNominalValueConcept() {
586 return mUnivConnNomValueCon;
587 }
588
589 CTBox* CTBox::setUniversalConnectionNominalValueConcept(CConcept* valueCon) {
590 mUnivConnNomValueCon = valueCon;
591 return this;
592 }
593
594
595
596 CTBox* CTBox::setMinimalNextConceptID(cint64 nextId) {
597 mMinimalNextConceptID = nextId;
598 return this;
599 }
600
601 cint64 CTBox::getMinimalNextConceptID() {
602 return mMinimalNextConceptID;
603 }
604
605 cint64 CTBox::getNextConceptID() {
606 cint64 nextId = mMinimalNextConceptID;
607 if (concepts) {
608 nextId = qMax(nextId, concepts->getItemCount());
609 }
610 return nextId;
611 }
612
613
614
615 }; // end namespace Ontology
616
617 }; // end namespace Reasoner
618
619 }; // end namespace Konclude