Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CIndividualProcessNodeValueSpaceHandler.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 "CIndividualProcessNodeValueSpaceHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32
33 CIndividualProcessNodeValueSpaceHandler::CIndividualProcessNodeValueSpaceHandler(CDatatypeValueSpaceType* valueSpaceType) {
34 mValueSpaceType = valueSpaceType;
35 }
36
37
38
39
40 bool CIndividualProcessNodeValueSpaceHandler::triggerDataLiteralConcept(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, bool otherValueSpacesClosed, bool* directlyTriggeredFlag, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
41 return false;
42 }
43
44 bool CIndividualProcessNodeValueSpaceHandler::triggerDatatypeConcept(CIndividualProcessNode* indiProcNode, CDatatype* datatype, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, bool otherValueSpacesClosed, bool* directlyTriggeredFlag, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
45 return false;
46 }
47
48 bool CIndividualProcessNodeValueSpaceHandler::triggerDataRestrictionConcept(CIndividualProcessNode* indiProcNode, CConcept* dataRestricionConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, bool otherValueSpacesClosed, bool* directlyTriggeredFlag, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
49 return false;
50 }
51
52
53 bool CIndividualProcessNodeValueSpaceHandler::addDataLiteral(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
54 return false;
55 }
56
57
58 bool CIndividualProcessNodeValueSpaceHandler::addDataRestriction(CIndividualProcessNode* indiProcNode, CConcept* dataRestricionConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
59 return false;
60 }
61
62
63
64 bool CIndividualProcessNodeValueSpaceHandler::closeValueSpace(CIndividualProcessNode* indiProcNode, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
65 bool valueSpaceClosed = false;
66 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
67 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(mValueSpaceType,false);
68 if (!valueSpaceData || !valueSpaceData->isValueSpaceClashed()) {
69 valueSpaceData = datatypesSpaceValue->getValueSpace(mValueSpaceType,true);
70 valueSpaceData->getClashDependencyTrackPointCollection()->addDependency(depTrackPoint);
71 valueSpaceData->setValueSpaceClashed(true);
72 valueSpaceClosed = true;
73
74 datatypesSpaceValue->setValueSapceModified(valueSpaceData);
75 }
76 return valueSpaceClosed;
77 }
78
79
80
81
82
83
84 bool CIndividualProcessNodeValueSpaceHandler::testValueSpaceClashed(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
85 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
86
87 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
88 CDatatypeValueSpaceUnknownType* unknownValueSpaceType = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceUnkownType();
89
90 CDatatypeUnknownValueSpaceData* unknownValueSpaceData = datatypesSpaceValue->getUnknownValueSpace(unknownValueSpaceType,false);
91 if (unknownValueSpaceData) {
92 if (unknownValueSpaceData->isValueSpaceClashed()) {
93 return true;
94 }
95 }
96 return false;
97 }
98
99
100 CClashedDependencyDescriptor* CIndividualProcessNodeValueSpaceHandler::createClashedDependencyDescriptor(CClashedDependencyDescriptor* appendDepDesLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext, cint64 testAlreadyContainedCount) {
101 if (depTrackPoint) {
102 CClashedDependencyDescriptor* testDepDesLinker = appendDepDesLinker;
103 for (cint64 i = testAlreadyContainedCount; i > 0 && testDepDesLinker; --i) {
104 if (testDepDesLinker->getDependencyTrackPoint() == depTrackPoint) {
105 return appendDepDesLinker;
106 }
107 testDepDesLinker = testDepDesLinker->getNext();
108 }
109 CClashedDependencyDescriptor* clashDes = CObjectAllocator<CClashedDependencyDescriptor>::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
110 clashDes->initClashedDependencyDescriptor(depTrackPoint);
111 clashDes->append(appendDepDesLinker);
112 return clashDes;
113 } else {
114 return appendDepDesLinker;
115 }
116 }
117
118
119 CClashedDependencyDescriptor* CIndividualProcessNodeValueSpaceHandler::copyClashedDependencyDescriptors(CClashedDependencyDescriptor* appendDepDesLinker, CClashedDependencyDescriptor* copyDepDesLinker, CCalculationAlgorithmContext* calcAlgContext) {
120 CClashedDependencyDescriptor* depDesLinker = appendDepDesLinker;
121 for (CClashedDependencyDescriptor* copyDepDesLinkerIt = copyDepDesLinker; copyDepDesLinkerIt; copyDepDesLinkerIt = copyDepDesLinkerIt->getNext()) {
122 depDesLinker = createClashedDependencyDescriptor(depDesLinker,copyDepDesLinkerIt->getDependencyTrackPoint(),calcAlgContext);
123 }
124 return depDesLinker;
125 }
126
127
128
129
130
131
132 CConceptDescriptor* CIndividualProcessNodeValueSpaceHandler::addConceptLinker(CConceptDescriptor* appendConceptLinker, CConcept* concept, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
133 if (concept) {
134 CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
135 newConceptLinker->initConceptDescriptor(concept,false,depTrackPoint);
136 newConceptLinker->append(appendConceptLinker);
137 return newConceptLinker;
138 } else {
139 return appendConceptLinker;
140 }
141 }
142
143
144
145 CConceptDescriptor* CIndividualProcessNodeValueSpaceHandler::addConceptLinker(CIndividualProcessNode* indiProcNode, CConceptDescriptor* appendConceptLinker, CDatatypeValueSpaceConceptTriggerLinker* triggeringConceptLinker, CDependencyTrackPoint* depTrackPoint, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
146 CConceptDescriptor* conceptTriggerLinker = appendConceptLinker;
147 for (CDatatypeValueSpaceConceptTriggerLinker* triggeringConceptLinkerIt = triggeringConceptLinker; triggeringConceptLinkerIt; triggeringConceptLinkerIt = triggeringConceptLinkerIt->getNext()) {
148 CConcept* triggerConcept = triggeringConceptLinkerIt->getTriggerConcept();
149 if (!hasConceptTriggered(indiProcNode,triggerConcept,calcAlgContext)) {
150 conceptTriggerLinker = addConceptLinker(conceptTriggerLinker,triggerConcept,depTrackPoint,calcAlgContext);
151 }
152 }
153 return conceptTriggerLinker;
154 }
155
156
157
158 CConceptDescriptor* CIndividualProcessNodeValueSpaceHandler::addConceptLinkerCollectionDependency(CIndividualProcessNode* indiProcNode, CConceptDescriptor* appendConceptLinker, CDatatypeValueSpaceConceptTriggerLinker* triggeringConceptLinker, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
159 CConceptDescriptor* conceptTriggerLinker = appendConceptLinker;
160 for (CDatatypeValueSpaceConceptTriggerLinker* triggeringConceptLinkerIt = triggeringConceptLinker; triggeringConceptLinkerIt; triggeringConceptLinkerIt = triggeringConceptLinkerIt->getNext()) {
161 CConcept* triggerConcept = triggeringConceptLinkerIt->getTriggerConcept();
162 if (!hasConceptTriggered(indiProcNode,triggerConcept,calcAlgContext)) {
163 CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr;
164 if (depCollection) {
165 datatypeTriggerDepTrackPoint = depCollection->getDatatypeTriggerDependencyTrackPoint();
166 }
167 conceptTriggerLinker = addConceptLinker(conceptTriggerLinker,triggerConcept,datatypeTriggerDepTrackPoint,calcAlgContext);
168 }
169 }
170 return conceptTriggerLinker;
171 }
172
173
174
175 bool CIndividualProcessNodeValueSpaceHandler::hasConceptTriggered(CIndividualProcessNode* indiProcNode, CConcept* concept, CCalculationAlgorithmContext* calcAlgContext) {
176 CReapplyConceptLabelSet* conSet = indiProcNode->getReapplyConceptLabelSet(false);
177 if (conSet) {
178 if (conSet->hasConcept(concept,false)) {
179 return true;
180 }
181 }
182 return false;
183 }
184
185
186
187 CConceptDescriptor* CIndividualProcessNodeValueSpaceHandler::triggerValueSpaceConcepts(CIndividualProcessNode* indiProcNode, CConceptDescriptor* appendConceptLinker, cint64& remainingRequiredValuesCount, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
188 return appendConceptLinker;
189 }
190
191
192 bool CIndividualProcessNodeValueSpaceHandler::addValueSpaceDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
193 return false;
194 }
195
196
197 bool CIndividualProcessNodeValueSpaceHandler::countPossibleValueSpaceValues(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceValuesCounter* valueCounter, CCalculationAlgorithmContext* calcAlgContext) {
198 return false;
199 }
200
201
202
203 bool CIndividualProcessNodeValueSpaceHandler::getNextPossibleDataValue(CIndividualProcessNode* indiProcNode, CDataLiteralValue*& nextValue, CDataLiteralValue* lastValue, CDatatypeValueTestingCollection* valueTestingCollection, CCalculationAlgorithmContext* calcAlgContext) {
204 return false;
205 }
206
207
208 }; // end namespace Algorithm
209
210 }; // end namespace Kernel
211
212 }; // end namespace Reasoner
213
214 }; // end namespace Konclude