/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CTBox.h"
namespace Konclude {
namespace Reasoner {
namespace Ontology {
CTBox::CTBox(CBoxContext* boxContext) {
mBoxContext = boxContext;
mMemMan = CContext::getMemoryAllocationManager(mBoxContext);
concepts = nullptr;
mDeleteBoxContext = nullptr;
mTriggerImpHash = nullptr;
mEquivConCandidateHash = nullptr;
mCandidateEquivConHash = nullptr;
mEquivConNonCandidateSet = nullptr;
mConceptOfInterestSet = nullptr;
mTriggeredConceptOfInterestSet = nullptr;
mConceptOfInterestList = nullptr;
mConOfIntActivationTriggerHash = nullptr;
mCandidateConOfIntHash = nullptr;
mTriggerConOfIntHash = nullptr;
mRoleDomainTriggerConceptHash = nullptr;
mIndividualTriggerConceptHash = nullptr;
mUnivConnNomValueCon = nullptr;
gciConceptSet = 0;
activeConceptSet = 0;
mBottomConceptIndex = 0;
mTopConceptIndex = 1;
mIndividualTriggerConceptIndex = 2;
mTopDataRangeConceptIndex = 3;
mDatatypeVector = nullptr;
mMinimalNextConceptID = 4;
}
CTBox::~CTBox() {
delete mDeleteBoxContext;
COPADestroyAndRelease(gciConceptSet,mMemMan);
COPADestroyAndRelease(activeConceptSet,mMemMan);
COPADestroyAndRelease(concepts,mMemMan);
COPADestroyAndRelease(mTriggerImpHash,mMemMan);
COPADestroyAndRelease(mEquivConCandidateHash,mMemMan);
COPADestroyAndRelease(mCandidateEquivConHash,mMemMan);
COPADestroyAndRelease(mEquivConNonCandidateSet,mMemMan);
COPADestroyAndRelease(mConceptOfInterestSet, mMemMan);
COPADestroyAndRelease(mTriggeredConceptOfInterestSet, mMemMan);
COPADestroyAndRelease(mConceptOfInterestList, mMemMan);
COPADestroyAndRelease(mRoleDomainTriggerConceptHash,mMemMan);
COPADestroyAndRelease(mIndividualTriggerConceptHash,mMemMan);
COPADestroyAndRelease(mDatatypeVector,mMemMan);
COPADestroyAndRelease(mConOfIntActivationTriggerHash, mMemMan);
COPADestroyAndRelease(mCandidateConOfIntHash, mMemMan);
COPADestroyAndRelease(mTriggerConOfIntHash, mMemMan);
}
cint64 CTBox::getTopConceptIndex() {
return mTopConceptIndex;
}
cint64 CTBox::getBottomConceptIndex() {
return mBottomConceptIndex;
}
cint64 CTBox::getIndividualTriggerConceptIndex() {
return mIndividualTriggerConceptIndex;
}
cint64 CTBox::getTopDataRangeConceptIndex() {
return mTopDataRangeConceptIndex;
}
CConcept* CTBox::getTopConcept() {
CConcept* concept = nullptr;
if (concepts) {
concept = concepts->getData(mTopConceptIndex);
}
return concept;
}
CConcept* CTBox::getTopDataRangeConcept() {
CConcept* concept = nullptr;
if (concepts) {
concept = concepts->getData(mTopDataRangeConceptIndex);
}
return concept;
}
CConcept* CTBox::getIndividualTriggerConcept() {
CConcept* concept = nullptr;
if (concepts) {
concept = concepts->getData(mIndividualTriggerConceptIndex);
}
return concept;
}
CConcept* CTBox::getBottomConcept() {
CConcept* concept = nullptr;
if (concepts) {
concept = concepts->getData(mBottomConceptIndex);
}
return concept;
}
CTBox* CTBox::setTopConcept(CConcept* topConcept) {
getConceptVector(true)->setData(mTopConceptIndex,topConcept);
return this;
}
CTBox* CTBox::setBottomConcept(CConcept* bottomConcept) {
getConceptVector(true)->setData(mBottomConceptIndex,bottomConcept);
return this;
}
CTBox* CTBox::setIndividualTriggerConcept(CConcept* indTrigConcept) {
getConceptVector(true)->setData(mIndividualTriggerConceptIndex,indTrigConcept);
return this;
}
CTBox* CTBox::setTopDataRangeConcept(CConcept* topDataRangeConcept) {
getConceptVector(true)->setData(mTopDataRangeConceptIndex,topDataRangeConcept);
return this;
}
CBOXSET* CTBox::getGCIConceptSet() {
return gciConceptSet;
}
CTBox *CTBox::setGCIConceptSet(CBOXSET* takeContainsSet) {
COPADestroyAndRelease(gciConceptSet,mMemMan);
gciConceptSet = takeContainsSet;
return this;
}
CBOXSET *CTBox::getActiveClassConceptSet(bool create) {
if (!activeConceptSet && create) {
activeConceptSet = CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return activeConceptSet;
}
CTBox *CTBox::setActiveClassConceptSet(CBOXSET* takeActiveConceptSet) {
COPADestroyAndRelease(activeConceptSet,mMemMan);
activeConceptSet = takeActiveConceptSet;
return this;
}
CBOXHASH* CTBox::getTriggerImplicationHash(bool create) {
if (!mTriggerImpHash && create) {
mTriggerImpHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mTriggerImpHash;
}
CBOXHASH* CTBox::getEquivalentConceptCandidateHash(bool create) {
if (!mEquivConCandidateHash && create) {
mEquivConCandidateHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mEquivConCandidateHash;
}
CBOXHASH* CTBox::getCandidateEquivalentConceptHash(bool create) {
if (!mCandidateEquivConHash && create) {
mCandidateEquivConHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mCandidateEquivConHash;
}
CBOXSET* CTBox::getEquivalentConceptNonCandidateSet(bool create) {
if (!mEquivConNonCandidateSet && create) {
mEquivConNonCandidateSet = CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mEquivConNonCandidateSet;
}
CBOXHASH* CTBox::getRoleDomainTriggerConceptHash(bool create) {
if (!mRoleDomainTriggerConceptHash && create) {
mRoleDomainTriggerConceptHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mRoleDomainTriggerConceptHash;
}
CBOXHASH* CTBox::getIndividualTriggerConceptHash(bool create) {
if (!mIndividualTriggerConceptHash && create) {
mIndividualTriggerConceptHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mIndividualTriggerConceptHash;
}
CBOXSET* CTBox::getConceptOfInterestSet(bool create) {
if (!mConceptOfInterestSet && create) {
mConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
return mConceptOfInterestSet;
}
CBOXSET* CTBox::getTriggeredConceptOfInterestSet(bool create) {
if (!mTriggeredConceptOfInterestSet && create) {
mTriggeredConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
return mTriggeredConceptOfInterestSet;
}
CBOXLIST* CTBox::getConceptOfInterestList(bool create) {
if (!mConceptOfInterestList && create) {
mConceptOfInterestList = CObjectParameterizingAllocator< CBOXLIST, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
return mConceptOfInterestList;
}
CBOXHASH* CTBox::getConceptOfInterestActivationTriggerDataHash(bool create) {
if (!mConOfIntActivationTriggerHash && create) {
mConOfIntActivationTriggerHash = CObjectParameterizingAllocator< CBOXHASH, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
return mConOfIntActivationTriggerHash;
}
CBOXHASH* CTBox::getCandidateConceptOfInterestHash(bool create) {
if (!mCandidateConOfIntHash && create) {
mCandidateConOfIntHash = CObjectParameterizingAllocator< CBOXHASH, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
return mCandidateConOfIntHash;
}
CBOXHASH* CTBox::getTriggerConceptOfInterestHash(bool create) {
if (!mTriggerConOfIntHash && create) {
mTriggerConOfIntHash = CObjectParameterizingAllocator< CBOXHASH, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
return mTriggerConOfIntHash;
}
CTBox* CTBox::setTriggerImplicationHash(CBOXHASH* takeTriggerImplHash) {
COPADestroyAndRelease(mTriggerImpHash,mMemMan);
mTriggerImpHash = takeTriggerImplHash;
return this;
}
CTBox *CTBox::setConceptVector(CConceptVector* takeConceptVec) {
COPADestroyAndRelease(concepts,mMemMan);
concepts = takeConceptVec;
return this;
}
CConceptVector* CTBox::getConceptVector(bool create) {
if (!concepts && create) {
concepts = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return concepts;
}
qint64 CTBox::getConceptCount() {
cint64 conCount = 0;
if (concepts) {
conCount = concepts->getItemCount();
}
return conCount;
}
CTBox *CTBox::getTBoxReferenceCopy(CBoxContext* boxContext) {
CTBox *tBox = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(boxContext),boxContext);
tBox->referenceTBox(this);
return tBox;
}
CDatatypeVector *CTBox::getDatatypeVector(bool create) {
if (!mDatatypeVector && create) {
mDatatypeVector = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
return mDatatypeVector;
}
CTBox *CTBox::setDatatypeVector(CDatatypeVector* datatypeVector) {
COPADestroyAndRelease(mDatatypeVector,mMemMan);
mDatatypeVector = datatypeVector;
return this;
}
CTBox *CTBox::referenceTBox(CTBox *tBox) {
mMinimalNextConceptID = tBox->mMinimalNextConceptID;
if (tBox->concepts) {
getConceptVector();
concepts->referenceVector(tBox->concepts);
} else if (concepts) {
concepts->clear();
}
if (tBox->mDatatypeVector) {
getDatatypeVector();
mDatatypeVector->referenceVector(tBox->mDatatypeVector);
} else if (mDatatypeVector) {
mDatatypeVector->clear();
}
if (tBox->gciConceptSet) {
if (!gciConceptSet) {
gciConceptSet = CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
gciConceptSet->init(tBox->gciConceptSet,mBoxContext);
} else if (gciConceptSet) {
gciConceptSet->clear();
}
if (tBox->activeConceptSet) {
if (!activeConceptSet) {
activeConceptSet = CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
activeConceptSet->init(tBox->activeConceptSet,mBoxContext);
} else if (activeConceptSet) {
activeConceptSet->clear();
}
mUnivConnNomValueCon = tBox->mUnivConnNomValueCon;
if (tBox->mIndividualTriggerConceptHash) {
if (!mIndividualTriggerConceptHash) {
mIndividualTriggerConceptHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
mIndividualTriggerConceptHash->init(tBox->mIndividualTriggerConceptHash,mBoxContext);
} else if (mIndividualTriggerConceptHash) {
mIndividualTriggerConceptHash->clear();
}
if (tBox->mEquivConCandidateHash) {
if (!mEquivConCandidateHash) {
mEquivConCandidateHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
mEquivConCandidateHash->init(tBox->mEquivConCandidateHash,mBoxContext);
} else if (mEquivConCandidateHash) {
mEquivConCandidateHash->clear();
}
if (tBox->mCandidateEquivConHash) {
if (!mCandidateEquivConHash) {
mCandidateEquivConHash = CObjectParameterizingAllocator< CBOXHASH,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
mCandidateEquivConHash->init(tBox->mCandidateEquivConHash,mBoxContext);
} else if (mCandidateEquivConHash) {
mCandidateEquivConHash->clear();
}
if (tBox->mEquivConNonCandidateSet) {
if (!mEquivConNonCandidateSet) {
mEquivConNonCandidateSet = CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
mEquivConNonCandidateSet->init(tBox->mEquivConNonCandidateSet,mBoxContext);
} else if (mEquivConNonCandidateSet) {
mEquivConNonCandidateSet->clear();
}
if (tBox->mConceptOfInterestSet) {
if (!mConceptOfInterestSet) {
mConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext),mBoxContext);
}
mConceptOfInterestSet->init(tBox->mConceptOfInterestSet,mBoxContext);
} else if (mConceptOfInterestSet) {
mConceptOfInterestSet->clear();
}
if (tBox->mTriggeredConceptOfInterestSet) {
if (!mTriggeredConceptOfInterestSet) {
mTriggeredConceptOfInterestSet = CObjectParameterizingAllocator< CBOXSET, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
mTriggeredConceptOfInterestSet->init(tBox->mTriggeredConceptOfInterestSet, mBoxContext);
}
else if (mTriggeredConceptOfInterestSet) {
mTriggeredConceptOfInterestSet->clear();
}
if (tBox->mConceptOfInterestList) {
if (!mConceptOfInterestList) {
mConceptOfInterestList = CObjectParameterizingAllocator< CBOXLIST, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
mConceptOfInterestList->init(tBox->mConceptOfInterestList, mBoxContext);
}
else if (mConceptOfInterestList) {
mConceptOfInterestList->clear();
}
if (tBox->mConOfIntActivationTriggerHash) {
if (!mConOfIntActivationTriggerHash) {
mConOfIntActivationTriggerHash = CObjectParameterizingAllocator< CBOXHASH, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
mConOfIntActivationTriggerHash->init(tBox->mConOfIntActivationTriggerHash, mBoxContext);
} else if (mConOfIntActivationTriggerHash) {
mConOfIntActivationTriggerHash->clear();
}
if (tBox->mCandidateConOfIntHash) {
if (!mCandidateConOfIntHash) {
mCandidateConOfIntHash = CObjectParameterizingAllocator< CBOXHASH, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
mCandidateConOfIntHash->init(tBox->mCandidateConOfIntHash, mBoxContext);
} else if (mCandidateConOfIntHash) {
mCandidateConOfIntHash->clear();
}
if (tBox->mTriggerConOfIntHash) {
if (!mTriggerConOfIntHash) {
mTriggerConOfIntHash = CObjectParameterizingAllocator< CBOXHASH, CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mBoxContext), mBoxContext);
}
mTriggerConOfIntHash->init(tBox->mTriggerConOfIntHash, mBoxContext);
}
else if (mTriggerConOfIntHash) {
mTriggerConOfIntHash->clear();
}
return this;
}
CBoxContext *CTBox::getBoxContext(bool create) {
if (!mBoxContext && create) {
mBoxContext = new CConcreteOntologyContextBase();
mDeleteBoxContext = mBoxContext;
}
return mBoxContext;
}
QString CTBox::getTBoxString() {
QString tboxString;
if (concepts) {
for (qint64 i = 0; i < concepts->getItemCount(); ++i) {
CConcept *concept = concepts->getData(i);
if (concept) {
QString conceptString = QString::number(i);
while (conceptString.length() <= 5) {
conceptString.insert(0," ");
}
conceptString += ",";
qint64 conOpCode = concept->getOperatorCode();
QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker());
if (!iriClassNameString.isEmpty()) {
conceptString += iriClassNameString + " = ";
} else {
conceptString += " = ";
}
CRole *role = concept->getRole();
QString paramString = QString::number(concept->getParameter());
QString roleString;
if (role) {
roleString = QString::number(role->getRoleTag());
}
CIndividual* indi = concept->getNominalIndividual();
QString indiString;
if (indi) {
indiString = QString::number(indi->getIndividualID());
}
if (conOpCode == CCNONE) {
conceptString += "( ATOM )";
} else if (conOpCode == CCTOP) {
conceptString += "( TOP "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCBOTTOM) {
conceptString += "( BOTTOM )";
} else if (conOpCode == CCAND) {
conceptString += "( AND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCAQAND) {
conceptString += "( AQAND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCIMPLAQAND) {
conceptString += "( IMPLAQAND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCBRANCHAQAND) {
conceptString += "( BRANCHAQAND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCPBINDAQAND) {
conceptString += "( PBINDAQAND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARBINDAQAND) {
conceptString += "( VARBINDAQAND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARPBACKAQAND) {
conceptString += "( VARPBACKAQAND "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCEQ) {
conceptString += "( EQ "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCSUB) {
conceptString += "( SUB "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCIMPLTRIG) {
conceptString += "( IMPTRIGGER "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCBRANCHTRIG) {
conceptString += "( BRANCHTRIG "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCPBINDTRIG) {
conceptString += "( PBINDTRIG "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARBINDTRIG) {
conceptString += "( VARBINDTRIG "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARPBACKTRIG) {
conceptString += "( VARPBACKTRIG "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCBACKACTIVTRIG) {
conceptString += "( BACKACTIVTRIG "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCOR) {
conceptString += "( OR "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCAQCHOOCE) {
conceptString += "( AQCHOOCE "+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCSOME) {
conceptString += QString("( SOME %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCSELF) {
conceptString += QString("( SELF %1. ").arg(roleString)+")";
} else if (conOpCode == CCNOMINAL) {
conceptString += QString("( NOMINAL %1. ").arg(indiString)+")";
} else if (conOpCode == CCAQSOME) {
conceptString += QString("( AQSOME %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCATLEAST) {
conceptString += QString("( ATLEAST %1. [%2] ").arg(roleString).arg(paramString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCATMOST) {
conceptString += QString("( ATMOST %1. [%2] ").arg(roleString).arg(paramString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCALL) {
conceptString += QString("( ALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCIMPLALL) {
conceptString += QString("( IMPLALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCBRANCHALL) {
conceptString += QString("( BRANCHALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCPBINDALL) {
conceptString += QString("( PBINDALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARBINDALL) {
conceptString += QString("( VARBINDALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARPBACKALL) {
conceptString += QString("( VARPBACKALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCIMPLAQALL) {
conceptString += QString("( IMPLAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCAQALL) {
conceptString += QString("( AQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCBRANCHAQALL) {
conceptString += QString("( BRANCHAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCPBINDAQALL) {
conceptString += QString("( PBINDAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARBINDAQALL) {
conceptString += QString("( VARBINDAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCVARPBACKAQALL) {
conceptString += QString("( VARPBACKAQALL %1. ").arg(roleString)+getConceptOperandString(concept->getOperandList())+")";
} else if (conOpCode == CCNOT) {
conceptString += "( NOT "+getConceptOperandString(concept->getOperandList())+")";
}
conceptString += "\r\n";
tboxString += conceptString;
}
}
}
return tboxString;
}
QString CTBox::getConceptOperandString(CSortedNegLinker *ops) {
QString conceptString;
while (ops) {
if (ops->isNegated()) {
conceptString += "-";
}
conceptString += QString::number(ops->getData()->getConceptTag()) + " ";
ops = ops->getNext();
}
return conceptString;
}
CConcept* CTBox::getUniversalConnectionNominalValueConcept() {
return mUnivConnNomValueCon;
}
CTBox* CTBox::setUniversalConnectionNominalValueConcept(CConcept* valueCon) {
mUnivConnNomValueCon = valueCon;
return this;
}
CTBox* CTBox::setMinimalNextConceptID(cint64 nextId) {
mMinimalNextConceptID = nextId;
return this;
}
cint64 CTBox::getMinimalNextConceptID() {
return mMinimalNextConceptID;
}
cint64 CTBox::getNextConceptID() {
cint64 nextId = mMinimalNextConceptID;
if (concepts) {
nextId = qMax(nextId, concepts->getItemCount());
}
return nextId;
}
}; // end namespace Ontology
}; // end namespace Reasoner
}; // end namespace Konclude