| 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 "CDatatypeIndividualProcessNodeHandler.h" |
| 22 |
|
| 23 |
|
| 24 |
namespace Konclude { |
| 25 |
|
| 26 |
namespace Reasoner { |
| 27 |
|
| 28 |
namespace Kernel { |
| 29 |
|
| 30 |
namespace Algorithm { |
| 31 |
|
| 32 |
|
| 33 |
CDatatypeIndividualProcessNodeHandler::CDatatypeIndividualProcessNodeHandler() { |
| 34 |
mConfBuildDependencies = true; |
| 35 |
|
| 36 |
CDatatypeValueSpaceTypes* valueSpaceTypes = CDatatypeValueSpaceTypes::getValueSpaceTypes(); |
| 37 |
|
| 38 |
CDatatypeValueSpaceRealType* realValueSpaceType = valueSpaceTypes->getValueSpaceRealType(); |
| 39 |
mValueSpaceHandlerArray[realValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeRealValueSpaceHandler(realValueSpaceType); |
| 40 |
CDatatypeValueSpaceUnknownType* unknownValueSpaceType = valueSpaceTypes->getValueSpaceUnkownType(); |
| 41 |
mValueSpaceHandlerArray[unknownValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeUnknownValueSpaceHandler(unknownValueSpaceType); |
| 42 |
CDatatypeValueSpaceStringType* stringValueSpaceType = valueSpaceTypes->getValueSpaceStringType(); |
| 43 |
mValueSpaceHandlerArray[stringValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeStringValueSpaceHandler(stringValueSpaceType); |
| 44 |
CDatatypeValueSpaceBooleanType* booleanValueSpaceType = valueSpaceTypes->getValueSpaceBooleanType(); |
| 45 |
mValueSpaceHandlerArray[booleanValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeBooleanValueSpaceHandler(booleanValueSpaceType); |
| 46 |
CDatatypeValueSpaceDoubleType* doubleValueSpaceType = valueSpaceTypes->getValueSpaceDoubleType(); |
| 47 |
mValueSpaceHandlerArray[doubleValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeDoubleValueSpaceHandler(doubleValueSpaceType); |
| 48 |
CDatatypeValueSpaceFloatType* floatValueSpaceType = valueSpaceTypes->getValueSpaceFloatType(); |
| 49 |
mValueSpaceHandlerArray[floatValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeFloatValueSpaceHandler(floatValueSpaceType); |
| 50 |
CDatatypeValueSpaceIRIType* iriValueSpaceType = valueSpaceTypes->getValueSpaceIRIType(); |
| 51 |
mValueSpaceHandlerArray[iriValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeIRIValueSpaceHandler(iriValueSpaceType); |
| 52 |
CDatatypeValueSpaceBinaryBase64DataType* binaryBase64DataValueSpaceType = valueSpaceTypes->getValueSpaceBinaryBase64DataType(); |
| 53 |
mValueSpaceHandlerArray[binaryBase64DataValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeBinaryBase64DataValueSpaceHandler(binaryBase64DataValueSpaceType); |
| 54 |
CDatatypeValueSpaceBinaryHexDataType* binaryHexDataValueSpaceType = valueSpaceTypes->getValueSpaceBinaryHexDataType(); |
| 55 |
mValueSpaceHandlerArray[binaryHexDataValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeBinaryHexDataValueSpaceHandler(binaryHexDataValueSpaceType); |
| 56 |
CDatatypeValueSpaceXMLType* xmlValueSpaceType = valueSpaceTypes->getValueSpaceXMLType(); |
| 57 |
mValueSpaceHandlerArray[xmlValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeXMLValueSpaceHandler(xmlValueSpaceType); |
| 58 |
CDatatypeValueSpaceDateTimeType* dateTimeValueSpaceType = valueSpaceTypes->getValueSpaceDateTimeType(); |
| 59 |
mValueSpaceHandlerArray[dateTimeValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeDateTimeValueSpaceHandler(dateTimeValueSpaceType); |
| 60 |
} |
| 61 |
|
| 62 |
|
| 63 |
CDatatypeIndividualProcessNodeHandler::~CDatatypeIndividualProcessNodeHandler() { |
| 64 |
} |
| 65 |
|
| 66 |
|
| 67 |
|
| 68 |
|
| 69 |
|
| 70 |
bool CDatatypeIndividualProcessNodeHandler::triggerDataLiteralConcept(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) { |
| 71 |
bool triggerInstalled = false; |
| 72 |
bool directlyTriggered = false; |
| 73 |
CDatatype* datatype = dataLiteral->getDatatype(); |
| 74 |
|
| 75 |
if (datatype) { |
| 76 |
CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType(); |
| 77 |
if (valueSpaceType) { |
| 78 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 79 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType, true); |
| 80 |
if (!valueSpaceData->isValueSpaceClashed()) { |
| 81 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType, calcAlgContext); |
| 82 |
CConceptDescriptor* conceptTriggerLinker = nullptr; |
| 83 |
CDatatypeDependencyCollection depCollection(calcAlgContext); |
| 84 |
bool otherValueSpacesClosed = false; |
| 85 |
if (areOtherValueSpacesClosed(indiProcNode,valueSpaceType,calcAlgContext)) { |
| 86 |
otherValueSpacesClosed = true; |
| 87 |
} |
| 88 |
triggerInstalled |= valueSpaceHandler->triggerDataLiteralConcept(indiProcNode, dataLiteral, negated, depTrackPoint, triggerConcept, otherValueSpacesClosed, &directlyTriggered, &depCollection, calcAlgContext); |
| 89 |
if (directlyTriggered) { |
| 90 |
CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr; |
| 91 |
addClosedValueSpacedDependencies(indiProcNode, &depCollection, calcAlgContext); |
| 92 |
datatypeTriggerDepTrackPoint = depCollection.getDatatypeTriggerDependencyTrackPoint(); |
| 93 |
CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager()); |
| 94 |
newConceptLinker->initConceptDescriptor(triggerConcept, false, datatypeTriggerDepTrackPoint); |
| 95 |
triggeredConcepts = newConceptLinker; |
| 96 |
} |
| 97 |
} |
| 98 |
} |
| 99 |
} |
| 100 |
if (triggerInstalled) { |
| 101 |
processValueSpaceModified(indiProcNode, calcAlgContext); |
| 102 |
} |
| 103 |
return triggerInstalled; |
| 104 |
} |
| 105 |
|
| 106 |
|
| 107 |
|
| 108 |
bool CDatatypeIndividualProcessNodeHandler::triggerDatatypeConcept(CIndividualProcessNode* indiProcNode, CDatatype* datatype, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) { |
| 109 |
bool triggerInstalled = false; |
| 110 |
bool directlyTriggered = false; |
| 111 |
CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType(); |
| 112 |
if (valueSpaceType) { |
| 113 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 114 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType, true); |
| 115 |
if (!valueSpaceData->isValueSpaceClashed()) { |
| 116 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType, calcAlgContext); |
| 117 |
CConceptDescriptor* conceptTriggerLinker = nullptr; |
| 118 |
CDatatypeDependencyCollection depCollection(calcAlgContext); |
| 119 |
bool otherValueSpacesClosed = false; |
| 120 |
if (areOtherValueSpacesClosed(indiProcNode, valueSpaceType, calcAlgContext)) { |
| 121 |
otherValueSpacesClosed = true; |
| 122 |
} |
| 123 |
triggerInstalled |= valueSpaceHandler->triggerDatatypeConcept(indiProcNode, datatype, negated, depTrackPoint, triggerConcept, otherValueSpacesClosed, &directlyTriggered, &depCollection, calcAlgContext); |
| 124 |
if (directlyTriggered) { |
| 125 |
CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr; |
| 126 |
addClosedValueSpacedDependencies(indiProcNode, &depCollection, calcAlgContext); |
| 127 |
datatypeTriggerDepTrackPoint = depCollection.getDatatypeTriggerDependencyTrackPoint(); |
| 128 |
CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager()); |
| 129 |
newConceptLinker->initConceptDescriptor(triggerConcept, false, datatypeTriggerDepTrackPoint); |
| 130 |
triggeredConcepts = newConceptLinker; |
| 131 |
} |
| 132 |
} |
| 133 |
} |
| 134 |
if (triggerInstalled) { |
| 135 |
processValueSpaceModified(indiProcNode, calcAlgContext); |
| 136 |
} |
| 137 |
return triggerInstalled; |
| 138 |
} |
| 139 |
|
| 140 |
|
| 141 |
|
| 142 |
|
| 143 |
|
| 144 |
bool CDatatypeIndividualProcessNodeHandler::triggerDataRestrictionConcept(CIndividualProcessNode* indiProcNode, CConcept* dataRestriction, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) { |
| 145 |
bool triggerInstalled = false; |
| 146 |
bool directlyTriggered = false; |
| 147 |
CDatatypeValueSpaceType* valueSpaceType = dataRestriction->getDatatype()->getValueSpaceType(); |
| 148 |
if (valueSpaceType) { |
| 149 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 150 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType, true); |
| 151 |
if (!valueSpaceData->isValueSpaceClashed()) { |
| 152 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType, calcAlgContext); |
| 153 |
CConceptDescriptor* conceptTriggerLinker = nullptr; |
| 154 |
CDatatypeDependencyCollection depCollection(calcAlgContext); |
| 155 |
bool otherValueSpacesClosed = false; |
| 156 |
if (areOtherValueSpacesClosed(indiProcNode, valueSpaceType, calcAlgContext)) { |
| 157 |
otherValueSpacesClosed = true; |
| 158 |
} |
| 159 |
triggerInstalled |= valueSpaceHandler->triggerDataRestrictionConcept(indiProcNode, dataRestriction, negated, depTrackPoint, triggerConcept, otherValueSpacesClosed, &directlyTriggered, &depCollection, calcAlgContext); |
| 160 |
if (directlyTriggered) { |
| 161 |
CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr; |
| 162 |
addClosedValueSpacedDependencies(indiProcNode, &depCollection, calcAlgContext); |
| 163 |
datatypeTriggerDepTrackPoint = depCollection.getDatatypeTriggerDependencyTrackPoint(); |
| 164 |
CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager()); |
| 165 |
newConceptLinker->initConceptDescriptor(triggerConcept, false, datatypeTriggerDepTrackPoint); |
| 166 |
triggeredConcepts = newConceptLinker; |
| 167 |
} |
| 168 |
} |
| 169 |
} |
| 170 |
if (triggerInstalled) { |
| 171 |
processValueSpaceModified(indiProcNode, calcAlgContext); |
| 172 |
} |
| 173 |
return triggerInstalled; |
| 174 |
} |
| 175 |
|
| 176 |
|
| 177 |
|
| 178 |
bool CDatatypeIndividualProcessNodeHandler::areOtherValueSpacesClosed(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceType* openValueSpaceType, CCalculationAlgorithmContext* calcAlgContext) { |
| 179 |
bool allOtherClosed = true; |
| 180 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 181 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 182 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 183 |
if (valueSpaceTypeIt != openValueSpaceType) { |
| 184 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt, false); |
| 185 |
if (!valueSpaceData || !valueSpaceData->isValueSpaceClashed()) { |
| 186 |
allOtherClosed = false; |
| 187 |
} |
| 188 |
} |
| 189 |
} |
| 190 |
return allOtherClosed; |
| 191 |
} |
| 192 |
|
| 193 |
|
| 194 |
|
| 195 |
CDatatypeDependencyCollection* CDatatypeIndividualProcessNodeHandler::addClosedValueSpacedDependencies(CIndividualProcessNode* indiProcNode, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) { |
| 196 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 197 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 198 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 199 |
if (valueSpaceTypeIt) { |
| 200 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt, false); |
| 201 |
if (valueSpaceData && valueSpaceData->isValueSpaceClashed()) { |
| 202 |
addValueSpaceDependencies(indiProcNode, valueSpaceData, valueSpaceTypeIt, depCollection, calcAlgContext); |
| 203 |
} |
| 204 |
} |
| 205 |
} |
| 206 |
return depCollection; |
| 207 |
} |
| 208 |
|
| 209 |
|
| 210 |
bool CDatatypeIndividualProcessNodeHandler::addDatatype(CIndividualProcessNode* indiProcNode, CConcept* datatypeConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) { |
| 211 |
bool potentiallyModified = false; |
| 212 |
CDatatype* datatype = datatypeConcept->getDatatype(); |
| 213 |
|
| 214 |
if (datatype) { |
| 215 |
CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType(); |
| 216 |
if (valueSpaceType) { |
| 217 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 218 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType,true); |
| 219 |
valueSpaceData->setValueSpaceInitialisationDependencyTrackPointCandidate(depTrackPoint); |
| 220 |
|
| 221 |
if (!negated) { |
| 222 |
potentiallyModified |= closeOtherValueSpaces(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext); |
| 223 |
} else { |
| 224 |
potentiallyModified |= closeValueSpace(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext); |
| 225 |
} |
| 226 |
} |
| 227 |
} |
| 228 |
|
| 229 |
|
| 230 |
if (potentiallyModified) { |
| 231 |
processValueSpaceModified(indiProcNode,calcAlgContext); |
| 232 |
} |
| 233 |
return potentiallyModified; |
| 234 |
} |
| 235 |
|
| 236 |
|
| 237 |
|
| 238 |
bool CDatatypeIndividualProcessNodeHandler::addDataLiteral(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) { |
| 239 |
bool potentiallyModified = false; |
| 240 |
CDatatype* datatype = dataLiteral->getDatatype(); |
| 241 |
|
| 242 |
if (datatype) { |
| 243 |
CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType(); |
| 244 |
if (valueSpaceType) { |
| 245 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext); |
| 246 |
potentiallyModified |= valueSpaceHandler->addDataLiteral(indiProcNode,dataLiteral,negated,depTrackPoint,calcAlgContext); |
| 247 |
if (!negated) { |
| 248 |
potentiallyModified |= closeOtherValueSpaces(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext); |
| 249 |
} |
| 250 |
} |
| 251 |
} |
| 252 |
if (potentiallyModified) { |
| 253 |
processValueSpaceModified(indiProcNode,calcAlgContext); |
| 254 |
} |
| 255 |
return potentiallyModified; |
| 256 |
} |
| 257 |
|
| 258 |
|
| 259 |
|
| 260 |
|
| 261 |
bool CDatatypeIndividualProcessNodeHandler::addDataRestriction(CIndividualProcessNode* indiProcNode, CConcept* dataRestricionConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) { |
| 262 |
bool potentiallyModified = false; |
| 263 |
CDatatype* datatype = dataRestricionConcept->getDatatype(); |
| 264 |
|
| 265 |
cint64 restrictionCode = dataRestricionConcept->getParameter(); |
| 266 |
CDataLiteral* dataLiteral = dataRestricionConcept->getDataLiteral(); |
| 267 |
if (datatype) { |
| 268 |
CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType(); |
| 269 |
if (valueSpaceType) { |
| 270 |
if (dataLiteral && dataLiteral->getDatatype()) { |
| 271 |
if (valueSpaceType != dataLiteral->getDatatype()->getValueSpaceType()) { |
| 272 |
return false; |
| 273 |
} |
| 274 |
} |
| 275 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext); |
| 276 |
potentiallyModified |= valueSpaceHandler->addDataRestriction(indiProcNode,dataRestricionConcept,negated,depTrackPoint,calcAlgContext); |
| 277 |
if (!negated && restrictionCode > 0) { |
| 278 |
potentiallyModified |= closeOtherValueSpaces(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext); |
| 279 |
} |
| 280 |
} |
| 281 |
} |
| 282 |
if (potentiallyModified) { |
| 283 |
processValueSpaceModified(indiProcNode,calcAlgContext); |
| 284 |
} |
| 285 |
return potentiallyModified; |
| 286 |
} |
| 287 |
|
| 288 |
|
| 289 |
bool CDatatypeIndividualProcessNodeHandler::processValueSpaceModified(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 290 |
// test clashes |
| 291 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false); |
| 292 |
if (datatypesSpaceValue->isValueSpaceClashCheckingRequired()) { |
| 293 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 294 |
datatypesSpaceValue->setValueSpaceClashCheckingRequired(false); |
| 295 |
testAllValueSpacesClashed(indiProcNode,calcAlgContext); |
| 296 |
} |
| 297 |
// queue triggering |
| 298 |
if (datatypesSpaceValue->isValueSpaceTriggeringRequired()) { |
| 299 |
if (!datatypesSpaceValue->isValueSpaceTriggeringQueued()) { |
| 300 |
CDatatypeValueSpacesTriggers* valueSpacesTriggers = calcAlgContext->getUsedProcessingDataBox()->getOntology()->getDataBoxes()->getMBox()->getValueSpacesTriggers(false); |
| 301 |
if (valueSpacesTriggers) { |
| 302 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 303 |
calcAlgContext->getUsedProcessingDataBox()->getValueSpaceTriggeringProcessingQueue(true)->insertProcessIndiviudal(indiProcNode); |
| 304 |
datatypesSpaceValue->setValueSpaceTriggeringQueued(true); |
| 305 |
} |
| 306 |
} |
| 307 |
} |
| 308 |
// queue satisfiability checking |
| 309 |
if (datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingRequired()) { |
| 310 |
if (!datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingQueued()) { |
| 311 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 312 |
CDatatypeValueSpaceValuesCounter valuesCounter; |
| 313 |
countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext); |
| 314 |
cint64 disjointCount = getDisjointCount(indiProcNode,calcAlgContext); |
| 315 |
if (!valuesCounter.hasValueAchieved(disjointCount+1)) { |
| 316 |
// requires detailed satisfiability checking |
| 317 |
calcAlgContext->getUsedProcessingDataBox()->getDistinctValueSpaceSatisfiabilityCheckingQueue(true)->insertProcessIndiviudal(indiProcNode); |
| 318 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingQueued(true); |
| 319 |
} else { |
| 320 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false); |
| 321 |
} |
| 322 |
} |
| 323 |
} |
| 324 |
return true; |
| 325 |
} |
| 326 |
|
| 327 |
|
| 328 |
|
| 329 |
|
| 330 |
|
| 331 |
|
| 332 |
bool CDatatypeIndividualProcessNodeHandler::triggerValueSpaceConcepts(CIndividualProcessNode* indiProcNode, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) { |
| 333 |
cint64 distinctCount = getDisjointCount(indiProcNode,calcAlgContext); |
| 334 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 335 |
CConceptDescriptor* conceptTriggerLinker = nullptr; |
| 336 |
bool triggered = false; |
| 337 |
|
| 338 |
if (datatypesSpaceValue->isValueSpaceTriggeringRequired() || distinctCount > datatypesSpaceValue->getLastTriggeringDisjointCount()) { |
| 339 |
datatypesSpaceValue->setLastTriggeringDisjointCount(distinctCount); |
| 340 |
|
| 341 |
cint64 remainingRequiredValueCount = distinctCount+1; |
| 342 |
|
| 343 |
CDatatypeDependencyCollection depCollection(calcAlgContext); |
| 344 |
addDistinctDependencies(indiProcNode,&depCollection,calcAlgContext); |
| 345 |
|
| 346 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 347 |
CDatatypeValueSpaceType* valueSpaceTypeLinker = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); |
| 348 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypeLinker; remainingRequiredValueCount > 0 && valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 349 |
CDatatypeValueSpaceType* valueSpaceType = valueSpaceTypeIt; |
| 350 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType,false); |
| 351 |
if (valueSpaceData && valueSpaceData->isValueSpaceClashed()) { |
| 352 |
addValueSpaceDependencies(indiProcNode,valueSpaceData,valueSpaceType,&depCollection,calcAlgContext); |
| 353 |
} else { |
| 354 |
conceptTriggerLinker = triggerValueSpaceConcepts(indiProcNode,conceptTriggerLinker,remainingRequiredValueCount,valueSpaceData,valueSpaceType,&depCollection,calcAlgContext); |
| 355 |
} |
| 356 |
} |
| 357 |
|
| 358 |
datatypesSpaceValue->setValueSpaceTriggeringRequired(false); |
| 359 |
triggered = true; |
| 360 |
} |
| 361 |
datatypesSpaceValue->setValueSpaceTriggeringQueued(false); |
| 362 |
|
| 363 |
triggeredConcepts = conceptTriggerLinker; |
| 364 |
return triggered; |
| 365 |
} |
| 366 |
|
| 367 |
|
| 368 |
|
| 369 |
|
| 370 |
bool CDatatypeIndividualProcessNodeHandler::notifyDistinctChanges(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 371 |
bool queued = false; |
| 372 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false); |
| 373 |
if (datatypesSpaceValue) { |
| 374 |
|
| 375 |
if (!datatypesSpaceValue->isValueSpaceTriggeringQueued()) { |
| 376 |
cint64 disjointCount = getDisjointCount(indiProcNode,calcAlgContext); |
| 377 |
if (datatypesSpaceValue->isValueSpaceTriggeringRequired() || datatypesSpaceValue->getLastTriggeringDisjointCount() < disjointCount) { |
| 378 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 379 |
calcAlgContext->getUsedProcessingDataBox()->getValueSpaceTriggeringProcessingQueue(true)->insertProcessIndiviudal(indiProcNode); |
| 380 |
datatypesSpaceValue->setValueSpaceTriggeringQueued(true); |
| 381 |
datatypesSpaceValue->setValueSpaceTriggeringRequired(true); |
| 382 |
queued = true; |
| 383 |
} |
| 384 |
} |
| 385 |
|
| 386 |
if (!datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingQueued()) { |
| 387 |
CDatatypeValueSpaceValuesCounter valuesCounter; |
| 388 |
countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext); |
| 389 |
cint64 disjointCount = getDisjointCount(indiProcNode,calcAlgContext); |
| 390 |
if (datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingRequired() || !valuesCounter.hasValueAchieved(disjointCount+1)) { |
| 391 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 392 |
calcAlgContext->getUsedProcessingDataBox()->getDistinctValueSpaceSatisfiabilityCheckingQueue(true)->insertProcessIndiviudal(indiProcNode); |
| 393 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingQueued(true); |
| 394 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(true); |
| 395 |
queued = true; |
| 396 |
} |
| 397 |
} |
| 398 |
|
| 399 |
} |
| 400 |
return queued; |
| 401 |
} |
| 402 |
|
| 403 |
|
| 404 |
|
| 405 |
|
| 406 |
bool CDatatypeIndividualProcessNodeHandler::involveDistinctNodeForSatisfiabilityChecking(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 407 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false); |
| 408 |
if (datatypesSpaceValue) { |
| 409 |
cint64 requiredValueCount = getDisjointCount(indiProcNode,calcAlgContext)+1; |
| 410 |
CDatatypeValueSpaceValuesCounter valuesCounter; |
| 411 |
countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext); |
| 412 |
if (!valuesCounter.hasValueAchieved(requiredValueCount)) { |
| 413 |
return true; |
| 414 |
} |
| 415 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 416 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false); |
| 417 |
} |
| 418 |
return false; |
| 419 |
} |
| 420 |
|
| 421 |
|
| 422 |
bool CDatatypeIndividualProcessNodeHandler::requiresSatisfiabilityChecking(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 423 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false); |
| 424 |
if (datatypesSpaceValue) { |
| 425 |
if (datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingRequired()) { |
| 426 |
|
| 427 |
cint64 requiredValueCount = getDisjointCount(indiProcNode,calcAlgContext)+1; |
| 428 |
CDatatypeValueSpaceValuesCounter valuesCounter; |
| 429 |
countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext); |
| 430 |
if (!valuesCounter.hasValueAchieved(requiredValueCount)) { |
| 431 |
return true; |
| 432 |
} |
| 433 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 434 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false); |
| 435 |
} |
| 436 |
} |
| 437 |
return false; |
| 438 |
} |
| 439 |
|
| 440 |
|
| 441 |
|
| 442 |
|
| 443 |
|
| 444 |
bool CDatatypeIndividualProcessNodeHandler::checkSatisfiability(CIndividualProcessNode* indiProcNode, CPROCESSINGSET<CIndividualProcessNode*>* distinctIndividualNodeSet, CCalculationAlgorithmContext* calcAlgContext) { |
| 445 |
|
| 446 |
|
| 447 |
indiProcNode->getDatatypesValueSpaceData(true)->setValueSpaceSatisfiabilityCheckingQueued(false); |
| 448 |
|
| 449 |
if (distinctIndividualNodeSet->size() > 1) { |
| 450 |
|
| 451 |
CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext(); |
| 452 |
CIndividualProcessNodeVector* indiNodeVector = calcAlgContext->getProcessingDataBox()->getIndividualProcessNodeVector(); |
| 453 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 454 |
CDatatypeValueSpaceTypes* valueSpaceTypes = ontology->getDataBoxes()->getDatatypeValueSpaceTypes(); |
| 455 |
CDatatypeValueSpaceType* valueSpaceLinker = valueSpaceTypes->getValueSpaceTypeLinker(); |
| 456 |
|
| 457 |
|
| 458 |
CPROCESSINGMAP<cint64,CIndividualProcessNode*>* sortedDistinctNodeMap = CObjectParameterizingAllocator< CPROCESSINGMAP<cint64,CIndividualProcessNode*>,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext); |
| 459 |
for (CPROCESSINGSET<CIndividualProcessNode*>::const_iterator it = distinctIndividualNodeSet->constBegin(), itEnd = distinctIndividualNodeSet->constEnd(); it != itEnd; ++it) { |
| 460 |
CIndividualProcessNode* distinctIndiNode(*it); |
| 461 |
cint64 distinctIndiID = distinctIndiNode->getIndividualNodeID(); |
| 462 |
sortedDistinctNodeMap->insert(distinctIndiID,distinctIndiNode); |
| 463 |
} |
| 464 |
|
| 465 |
|
| 466 |
CDatatypeValueTestingCollection valueTestingCollection(calcAlgContext); |
| 467 |
CPROCESSINGHASH<cint64,CDataLiteralValue*>* nodeValueAssociationHash = CObjectParameterizingAllocator< CPROCESSINGHASH<cint64,CDataLiteralValue*>,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext); |
| 468 |
CPROCESSINGHASH<cint64,CDatatypeValueSpaceType*>* nodeValueTypeAssociationHash = CObjectParameterizingAllocator< CPROCESSINGHASH<cint64,CDatatypeValueSpaceType*>,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext); |
| 469 |
|
| 470 |
|
| 471 |
|
| 472 |
CPROCESSINGMAP<cint64,CIndividualProcessNode*>::iterator firstValueit = sortedDistinctNodeMap->begin(); |
| 473 |
cint64 firstIndiNodeID = firstValueit.key(); |
| 474 |
CIndividualProcessNode* firstIndiNode = firstValueit.value(); |
| 475 |
sortedDistinctNodeMap->erase(firstValueit); |
| 476 |
CDatatypeValueSpaceType* firstIndiNodeValueSpaceType = valueSpaceLinker; |
| 477 |
CDataLiteralValue* firstIndiNextValue = nullptr; |
| 478 |
CDataLiteralValue* firstIndiLastValue = nullptr; |
| 479 |
|
| 480 |
|
| 481 |
bool foundSatisfiableValues = false; |
| 482 |
bool moreValuesPossible = true; |
| 483 |
while (moreValuesPossible && !foundSatisfiableValues) { |
| 484 |
valueTestingCollection.releaseUsedDataLiteralValues(); |
| 485 |
CDatatypeValueSpaceType* firstIndiNodeLastValueSpaceType = firstIndiNodeValueSpaceType; |
| 486 |
bool firstNodeFoundValue = seachNextPossibleDataValue(firstIndiNode,firstIndiNextValue,firstIndiNodeValueSpaceType,firstIndiLastValue,&valueTestingCollection,calcAlgContext); |
| 487 |
if (firstNodeFoundValue) { |
| 488 |
if (firstIndiLastValue) { |
| 489 |
valueTestingCollection.releaseDataLiteralValue(firstIndiLastValue,firstIndiNodeLastValueSpaceType); |
| 490 |
} |
| 491 |
firstIndiLastValue = firstIndiNextValue; |
| 492 |
|
| 493 |
for (CPROCESSINGMAP<cint64,CIndividualProcessNode*>::const_iterator it = sortedDistinctNodeMap->constBegin(), itEnd = sortedDistinctNodeMap->constEnd(); it != itEnd; ++it) { |
| 494 |
cint64 indiNodeID = it.key(); |
| 495 |
CIndividualProcessNode* indiNode = it.value(); |
| 496 |
nodeValueAssociationHash->insert(indiNodeID,nullptr); |
| 497 |
nodeValueTypeAssociationHash->insert(indiNodeID,valueSpaceLinker); |
| 498 |
} |
| 499 |
|
| 500 |
|
| 501 |
nodeValueAssociationHash->insert(firstIndiNodeID,firstIndiLastValue); |
| 502 |
nodeValueTypeAssociationHash->insert(firstIndiNodeID,firstIndiNodeValueSpaceType); |
| 503 |
|
| 504 |
|
| 505 |
|
| 506 |
bool allNodesFoundValue = true; |
| 507 |
|
| 508 |
for (CPROCESSINGMAP<cint64,CIndividualProcessNode*>::const_iterator it = sortedDistinctNodeMap->constBegin(), itEnd = sortedDistinctNodeMap->constEnd(); allNodesFoundValue && it != itEnd; ++it) { |
| 509 |
valueTestingCollection.releaseUsedDataLiteralValues(); |
| 510 |
cint64 indiNodeID = it.key(); |
| 511 |
CIndividualProcessNode* indiNode = it.value(); |
| 512 |
CDataLiteralValue* nodeLastTestingValue = nodeValueAssociationHash->value(indiNodeID); |
| 513 |
CDatatypeValueSpaceType* nodeValueSpaceType = nodeValueTypeAssociationHash->value(indiNodeID); |
| 514 |
CDataLiteralValue* nodeNextTestingValue = nullptr; |
| 515 |
|
| 516 |
|
| 517 |
CDistinctHash* distinctHash = indiNode->getDistinctHash(false); |
| 518 |
if (distinctHash) { |
| 519 |
CDistinctIterator distinctIterator = distinctHash->getDistinctIterator(); |
| 520 |
while (distinctIterator.hasNext()) { |
| 521 |
cint64 distinctIndiID = distinctIterator.nextDistinctIndividualID(); |
| 522 |
if (distinctIndiID < indiNodeID && sortedDistinctNodeMap->contains(distinctIndiID)) { |
| 523 |
CDataLiteralValue* distinctValue = nodeValueAssociationHash->value(distinctIndiID); |
| 524 |
CDatatypeValueSpaceType* distinctValueSpaceType = nodeValueTypeAssociationHash->value(distinctIndiID); |
| 525 |
valueTestingCollection.addDataLiteralValueUse(distinctValue,distinctValueSpaceType); |
| 526 |
} |
| 527 |
} |
| 528 |
} |
| 529 |
|
| 530 |
|
| 531 |
CDatatypeValueSpaceType* nodeLastValueSpaceType = nodeValueSpaceType; |
| 532 |
bool foundValue = seachNextPossibleDataValue(indiNode,nodeNextTestingValue,nodeValueSpaceType,nodeLastTestingValue,&valueTestingCollection,calcAlgContext); |
| 533 |
if (!foundValue) { |
| 534 |
allNodesFoundValue = false; |
| 535 |
} else { |
| 536 |
if (nodeLastTestingValue) { |
| 537 |
valueTestingCollection.releaseDataLiteralValue(nodeLastTestingValue,nodeLastValueSpaceType); |
| 538 |
} |
| 539 |
nodeValueAssociationHash->insert(indiNodeID,nodeNextTestingValue); |
| 540 |
nodeValueTypeAssociationHash->insert(indiNodeID,nodeValueSpaceType); |
| 541 |
} |
| 542 |
} |
| 543 |
|
| 544 |
|
| 545 |
if (allNodesFoundValue) { |
| 546 |
foundSatisfiableValues = true; |
| 547 |
} |
| 548 |
|
| 549 |
|
| 550 |
} else { |
| 551 |
moreValuesPossible = false; |
| 552 |
} |
| 553 |
} |
| 554 |
|
| 555 |
|
| 556 |
if (foundSatisfiableValues) { |
| 557 |
// mark for all nodes that value space satisfiability is checked |
| 558 |
|
| 559 |
for (CPROCESSINGSET<CIndividualProcessNode*>::const_iterator it = distinctIndividualNodeSet->constBegin(), itEnd = distinctIndividualNodeSet->constEnd(); it != itEnd; ++it) { |
| 560 |
CIndividualProcessNode* distinctIndiNode(*it); |
| 561 |
CDatatypesValueSpaceData* datatypesSpaceValue = distinctIndiNode->getDatatypesValueSpaceData(true); |
| 562 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false); |
| 563 |
} |
| 564 |
|
| 565 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 566 |
datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false); |
| 567 |
} else { |
| 568 |
// create clash |
| 569 |
CDatatypeDependencyTrackPointCollection clashedDepTrackPointCollection(calcAlgContext->getUsedProcessContext()); |
| 570 |
for (CPROCESSINGSET<CIndividualProcessNode*>::const_iterator it = distinctIndividualNodeSet->constBegin(), itEnd = distinctIndividualNodeSet->constEnd(); it != itEnd; ++it) { |
| 571 |
CIndividualProcessNode* distinctIndiNode(*it); |
| 572 |
addValueSpacesDependencies(distinctIndiNode,&clashedDepTrackPointCollection,calcAlgContext); |
| 573 |
addDistinctDependencies(distinctIndiNode,&clashedDepTrackPointCollection,calcAlgContext); |
| 574 |
} |
| 575 |
|
| 576 |
CClashedDependencyDescriptor* depDesLinker = nullptr; |
| 577 |
depDesLinker = copyClashedDependencyDescriptors(depDesLinker,clashedDepTrackPointCollection.getClashedDependencyDescriptors(),calcAlgContext); |
| 578 |
throwDatatypeValueSpaceExclusionClash(depDesLinker,indiProcNode,calcAlgContext); |
| 579 |
|
| 580 |
} |
| 581 |
} |
| 582 |
|
| 583 |
|
| 584 |
|
| 585 |
return true; |
| 586 |
} |
| 587 |
|
| 588 |
|
| 589 |
bool CDatatypeIndividualProcessNodeHandler::addDistinctDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) { |
| 590 |
|
| 591 |
bool dependenciesAdded = false; |
| 592 |
cint64 indiNodeID = indiProcNode->getIndividualNodeID(); |
| 593 |
CDistinctHash* distinctHash = indiProcNode->getDistinctHash(false); |
| 594 |
if (distinctHash) { |
| 595 |
CDistinctIterator distinctIterator = distinctHash->getDistinctIterator(); |
| 596 |
while (distinctIterator.hasNext()) { |
| 597 |
CDistinctEdge* distinctEdge = distinctIterator.next(); |
| 598 |
CDependencyTrackPoint* depTrackPoint = distinctEdge->getDependencyTrackPoint(); |
| 599 |
dependenciesAdded |= depCollection->addDependency(depTrackPoint); |
| 600 |
} |
| 601 |
} |
| 602 |
return dependenciesAdded; |
| 603 |
} |
| 604 |
|
| 605 |
|
| 606 |
|
| 607 |
bool CDatatypeIndividualProcessNodeHandler::seachNextPossibleDataValue(CIndividualProcessNode* indiProcNode, CDataLiteralValue*& nextValue, CDatatypeValueSpaceType*& nextValueSpaceType, CDataLiteralValue* lastValue, CDatatypeValueTestingCollection* valueTestingCollection, CCalculationAlgorithmContext* calcAlgContext) { |
| 608 |
|
| 609 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 610 |
|
| 611 |
for (; nextValueSpaceType; nextValueSpaceType = nextValueSpaceType->getNextValueSpaceType()) { |
| 612 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(nextValueSpaceType,false); |
| 613 |
if (!valueSpaceData->isValueSpaceClashed()) { |
| 614 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(nextValueSpaceType,calcAlgContext); |
| 615 |
if (valueSpaceHandler->getNextPossibleDataValue(indiProcNode,nextValue,lastValue,valueTestingCollection,calcAlgContext)) { |
| 616 |
return true; |
| 617 |
} |
| 618 |
} |
| 619 |
} |
| 620 |
|
| 621 |
return false; |
| 622 |
} |
| 623 |
|
| 624 |
|
| 625 |
|
| 626 |
bool CDatatypeIndividualProcessNodeHandler::countPossibleValues(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceValuesCounter* valuesCounter, CCalculationAlgorithmContext* calcAlgContext) { |
| 627 |
|
| 628 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false); |
| 629 |
|
| 630 |
if (!datatypesSpaceValue->isValueSpaceCounted() || datatypesSpaceValue->isValueSpaceCountingRequired()) { |
| 631 |
datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 632 |
datatypesSpaceValue->setValueSpaceCounted(true); |
| 633 |
datatypesSpaceValue->setValueSpaceCountingRequired(false); |
| 634 |
|
| 635 |
CDatatypeValueSpaceValuesCounter* valueSpacesValuesCounter = datatypesSpaceValue->getValuesCounter(); |
| 636 |
valueSpacesValuesCounter->resetValueCounter(); |
| 637 |
|
| 638 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 639 |
CDatatypeValueSpaceType* valueSpaceTypeLinker = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); |
| 640 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypeLinker; valueSpaceTypeIt && !valueSpacesValuesCounter->isInfinite(); valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 641 |
CDatatypeValueSpaceType* valueSpaceType = valueSpaceTypeIt; |
| 642 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext); |
| 643 |
valueSpaceHandler->countPossibleValueSpaceValues(indiProcNode,valueSpacesValuesCounter,calcAlgContext); |
| 644 |
} |
| 645 |
} |
| 646 |
|
| 647 |
bool counted = false; |
| 648 |
if (valuesCounter) { |
| 649 |
CDatatypeValueSpaceValuesCounter* valueSpacesValuesCounter = datatypesSpaceValue->getValuesCounter(); |
| 650 |
counted = valuesCounter->combineWithValueCounter(valueSpacesValuesCounter); |
| 651 |
} |
| 652 |
return counted; |
| 653 |
} |
| 654 |
|
| 655 |
|
| 656 |
|
| 657 |
|
| 658 |
bool CDatatypeIndividualProcessNodeHandler::addValueSpacesDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) { |
| 659 |
bool dependenciesAdded = false; |
| 660 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 661 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 662 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 663 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt,false); |
| 664 |
if (valueSpaceData) { |
| 665 |
dependenciesAdded = addValueSpaceDependencies(indiProcNode,valueSpaceData,valueSpaceTypeIt,depCollection,calcAlgContext); |
| 666 |
} |
| 667 |
} |
| 668 |
return dependenciesAdded; |
| 669 |
} |
| 670 |
|
| 671 |
|
| 672 |
|
| 673 |
bool CDatatypeIndividualProcessNodeHandler::addValueSpaceDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceData* valueSpaceData, CDatatypeValueSpaceType* valueSpaceType, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) { |
| 674 |
if (valueSpaceData->isValueSpaceClashed()) { |
| 675 |
bool depAddeds = false; |
| 676 |
CClashedDependencyDescriptor* clashedDepDesLinker = valueSpaceData->getClashDependencyDescriptorLinker(); |
| 677 |
for (CClashedDependencyDescriptor* clashedDepDesIt = clashedDepDesLinker; clashedDepDesIt; clashedDepDesIt = clashedDepDesIt->getNext()) { |
| 678 |
CDependencyTrackPoint* depTrackPoint = clashedDepDesIt->getDependencyTrackPoint(); |
| 679 |
depAddeds |= depCollection->addDependency(depTrackPoint); |
| 680 |
} |
| 681 |
return depAddeds; |
| 682 |
} else { |
| 683 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext); |
| 684 |
return valueSpaceHandler->addValueSpaceDependencies(indiProcNode,depCollection,calcAlgContext); |
| 685 |
} |
| 686 |
return false; |
| 687 |
} |
| 688 |
|
| 689 |
|
| 690 |
|
| 691 |
|
| 692 |
CIndividualProcessNodeValueSpaceHandler* CDatatypeIndividualProcessNodeHandler::getValueSpaceHandler(CDatatypeValueSpaceType* valueSpaceType, CCalculationAlgorithmContext* calcAlgContext) { |
| 693 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = nullptr; |
| 694 |
valueSpaceHandler = mValueSpaceHandlerArray[valueSpaceType->getValueSpaceTypeIndex()]; |
| 695 |
return valueSpaceHandler; |
| 696 |
} |
| 697 |
|
| 698 |
|
| 699 |
|
| 700 |
cint64 CDatatypeIndividualProcessNodeHandler::getDisjointCount(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 701 |
cint64 disjointCount = 0; |
| 702 |
CDistinctHash* distinctHash = indiProcNode->getDistinctHash(false); |
| 703 |
if (distinctHash) { |
| 704 |
disjointCount = distinctHash->getDistinctCount(); |
| 705 |
} |
| 706 |
return disjointCount; |
| 707 |
} |
| 708 |
|
| 709 |
|
| 710 |
|
| 711 |
bool CDatatypeIndividualProcessNodeHandler::closeValueSpace(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceType* closeValueSpaceType, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) { |
| 712 |
bool valueSpaceClosed = false; |
| 713 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(closeValueSpaceType,calcAlgContext); |
| 714 |
if (valueSpaceHandler) { |
| 715 |
valueSpaceClosed |= valueSpaceHandler->closeValueSpace(indiProcNode,depTrackPoint,calcAlgContext); |
| 716 |
} |
| 717 |
return valueSpaceClosed; |
| 718 |
} |
| 719 |
|
| 720 |
|
| 721 |
|
| 722 |
|
| 723 |
bool CDatatypeIndividualProcessNodeHandler::closeOtherValueSpaces(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceType* exceptionValueSpaceType, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) { |
| 724 |
bool valueSpaceClosed = false; |
| 725 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 726 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 727 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 728 |
if (valueSpaceTypeIt != exceptionValueSpaceType) { |
| 729 |
valueSpaceClosed |= closeValueSpace(indiProcNode,valueSpaceTypeIt,depTrackPoint,calcAlgContext); |
| 730 |
} |
| 731 |
} |
| 732 |
return valueSpaceClosed; |
| 733 |
} |
| 734 |
|
| 735 |
|
| 736 |
|
| 737 |
|
| 738 |
|
| 739 |
|
| 740 |
|
| 741 |
bool CDatatypeIndividualProcessNodeHandler::testAllValueSpacesClashed(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 742 |
bool allClashed = true; |
| 743 |
|
| 744 |
CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology(); |
| 745 |
CDatatypeValueSpaceTypes* valueSpaceTypes = ontology->getDataBoxes()->getDatatypeValueSpaceTypes(); |
| 746 |
|
| 747 |
CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true); |
| 748 |
|
| 749 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypes->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 750 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceTypeIt,calcAlgContext); |
| 751 |
allClashed &= valueSpaceHandler->testValueSpaceClashed(indiProcNode,calcAlgContext); |
| 752 |
} |
| 753 |
|
| 754 |
if (allClashed) { |
| 755 |
|
| 756 |
CClashedDependencyDescriptor* depDesLinker = nullptr; |
| 757 |
for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypes->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) { |
| 758 |
CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt,false); |
| 759 |
if (valueSpaceData) { |
| 760 |
depDesLinker = copyClashedDependencyDescriptors(depDesLinker,valueSpaceData->getClashDependencyDescriptorLinker(),calcAlgContext); |
| 761 |
} |
| 762 |
} |
| 763 |
throwDatatypeValueSpaceExclusionClash(depDesLinker,indiProcNode,calcAlgContext); |
| 764 |
} |
| 765 |
return allClashed; |
| 766 |
} |
| 767 |
|
| 768 |
|
| 769 |
|
| 770 |
|
| 771 |
void CDatatypeIndividualProcessNodeHandler::throwDatatypeValueSpaceExclusionClash(CClashedDependencyDescriptor* depDesLinker, CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) { |
| 772 |
CClashedDatatypeValueSpaceExclusionDescriptor* clashDepLinker = nullptr; |
| 773 |
for (CClashedDependencyDescriptor* copyDepDesLinkerIt = depDesLinker; copyDepDesLinkerIt; copyDepDesLinkerIt = copyDepDesLinkerIt->getNext()) { |
| 774 |
CClashedDatatypeValueSpaceExclusionDescriptor* clashDes = CObjectAllocator<CClashedDatatypeValueSpaceExclusionDescriptor>::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager()); |
| 775 |
clashDes->initClashedDatatypeValueSpaceExclusionDescriptor(copyDepDesLinkerIt->getDependencyTrackPoint(),indiProcNode); |
| 776 |
clashDepLinker = (CClashedDatatypeValueSpaceExclusionDescriptor*)clashDes->append(clashDepLinker); |
| 777 |
} |
| 778 |
throw CCalculationClashProcessingException(clashDepLinker); |
| 779 |
} |
| 780 |
|
| 781 |
|
| 782 |
CClashedDependencyDescriptor* CDatatypeIndividualProcessNodeHandler::createClashedDependencyDescriptor(CClashedDependencyDescriptor* appendDepDesLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) { |
| 783 |
if (depTrackPoint) { |
| 784 |
CClashedDependencyDescriptor* clashDes = CObjectAllocator<CClashedDependencyDescriptor>::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager()); |
| 785 |
clashDes->initClashedDependencyDescriptor(depTrackPoint); |
| 786 |
clashDes->append(appendDepDesLinker); |
| 787 |
return clashDes; |
| 788 |
} else { |
| 789 |
return appendDepDesLinker; |
| 790 |
} |
| 791 |
} |
| 792 |
|
| 793 |
CClashedDependencyDescriptor* CDatatypeIndividualProcessNodeHandler::copyClashedDependencyDescriptors(CClashedDependencyDescriptor* appendDepDesLinker, CClashedDependencyDescriptor* copyDepDesLinker, CCalculationAlgorithmContext* calcAlgContext) { |
| 794 |
CClashedDependencyDescriptor* depDesLinker = appendDepDesLinker; |
| 795 |
for (CClashedDependencyDescriptor* copyDepDesLinkerIt = copyDepDesLinker; copyDepDesLinkerIt; copyDepDesLinkerIt = copyDepDesLinkerIt->getNext()) { |
| 796 |
depDesLinker = createClashedDependencyDescriptor(depDesLinker,copyDepDesLinkerIt->getDependencyTrackPoint(),calcAlgContext); |
| 797 |
} |
| 798 |
return depDesLinker; |
| 799 |
} |
| 800 |
|
| 801 |
|
| 802 |
|
| 803 |
|
| 804 |
|
| 805 |
|
| 806 |
|
| 807 |
|
| 808 |
|
| 809 |
|
| 810 |
|
| 811 |
|
| 812 |
|
| 813 |
CConceptDescriptor* CDatatypeIndividualProcessNodeHandler::triggerValueSpaceConcepts(CIndividualProcessNode* indiProcNode, CConceptDescriptor* appendConceptLinker, cint64& remainingRequiredValuesCount, CDatatypeValueSpaceData* valueSpaceData, CDatatypeValueSpaceType* valueSpaceType, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) { |
| 814 |
CConceptDescriptor* triggerConcepts = nullptr; |
| 815 |
CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext); |
| 816 |
triggerConcepts = valueSpaceHandler->triggerValueSpaceConcepts(indiProcNode,appendConceptLinker,remainingRequiredValuesCount,depCollection,calcAlgContext); |
| 817 |
return triggerConcepts; |
| 818 |
} |
| 819 |
|
| 820 |
|
| 821 |
|
| 822 |
|
| 823 |
}; // end namespace Algorithm |
| 824 |
|
| 825 |
}; // end namespace Kernel |
| 826 |
|
| 827 |
}; // end namespace Reasoner |
| 828 |
|
| 829 |
}; // end namespace Konclude |