Debian Codegraph @

Source/Reasoner/Query/CDeterministicNondeterministicIndividualsQuery.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 "CDeterministicNondeterministicIndividualsQuery.h"
22
23
24 #include "Reasoner/Kernel/Task/CConsistenceTaskData.h"
25 #include "Reasoner/Kernel/Task/CSatisfiableCalculationTask.h"
26
27
28 namespace Konclude {
29
30 namespace Reasoner {
31
32 using namespace Kernel::Task;
33
34 namespace Query {
35
36
37 CDeterministicNondeterministicIndividualsQuery::CDeterministicNondeterministicIndividualsQuery(CConcreteOntology* ontology, CConfigurationBase* configuration, const QSet<CIndividual*>& individualSet, const QString& queryName)
38 : CRealizationPremisingQuery(ontology,configuration) {
39 mQueryName = queryName;
40 mResult = nullptr;
41
42 mUseAbbreviatedIRIs = CConfigDataReader::readConfigBoolean(configuration,"Konclude.OWLlink.AbbreviatedIRIs",false);
43
44 mConsistencyCalcError = false;
45 mQueryConstructError = false;
46
47 mCalcConfig = configuration;
48
49 mIndividualSet = individualSet;
50 mDeterministicIndividuals = false;
51
52 mRequiresConceptRealisation = true;
53 mRequiresSameIndividualRealisation = true;
54 }
55
56 CDeterministicNondeterministicIndividualsQuery::~CDeterministicNondeterministicIndividualsQuery() {
57 if (mResult) {
58 delete mResult;
59 }
60 delete mCalcConfig;
61 }
62
63
64 CQueryResult* CDeterministicNondeterministicIndividualsQuery::getQueryResult() {
65 return mResult;
66 }
67
68
69 CQueryResult *CDeterministicNondeterministicIndividualsQuery::constructResult(CRealization* realization) {
70 return constructIndividualsResult(realization);
71 }
72
73
74
75 bool CDeterministicNondeterministicIndividualsQuery::addIndividualResultData(CIndividual* indi, CIndividualProcessNodeVector* indiNodeVec, QSet<QPair<CIndividual*,CConcept*> >* possAssSet) {
76 cint64 indiID = -indi->getIndividualID();
77 CBOXSET<CConcept*>* eqNonCanSet = mOntology->getTBox()->getEquivalentConceptNonCandidateSet(false);
78
79 CIndividualProcessNode* baseIndiNode = indiNodeVec->getData(indiID);
80 CIndividualProcessNode* indiNode = baseIndiNode;
81 if (indiNode && indiNode->getNominalIndividual()) {
82 cint64 mergedIndiID = indiID;
83 bool nonDeterministicMerged = false;
84 while (mergedIndiID != indiNode->getMergedIntoIndividualNodeID()) {
85 mergedIndiID = indiNode->getMergedIntoIndividualNodeID();
86 CDependencyTrackPoint* mergedDepTrackPoint = indiNode->getMergedDependencyTrackPoint();
87 if (!mergedDepTrackPoint || mergedDepTrackPoint->getBranchingTag() > 0) {
88 nonDeterministicMerged = true;
89 }
90 indiNode = indiNodeVec->getData(mergedIndiID);
91 }
92
93 CReapplyConceptLabelSet* conLabelSet = indiNode->getReapplyConceptLabelSet(false);
94 if (conLabelSet) {
95
96
97 for (CConceptDescriptor* conDesIt = conLabelSet->getAddingSortedConceptDescriptionLinker(); conDesIt; conDesIt = conDesIt->getNext()) {
98 CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint();
99 CConcept* concept = conDesIt->getConcept();
100 bool conNegation = conDesIt->isNegated();
101 if (nonDeterministicMerged || !depTrackPoint || depTrackPoint->getBranchingTag() > 0) {
102 if (!conNegation && concept && concept->hasClassName()) {
103 possAssSet->insert( QPair<CIndividual*,CConcept*>(indi,concept) );
104 }
105 }
106 if (concept->getOperatorCode() == CCEQCAND) {
107 CConcept* eqConcept = concept->getOperandList()->getData();
108 bool negation = false;
109 if (!conLabelSet->containsConcept(eqConcept,negation)) {
110 possAssSet->insert( QPair<CIndividual*,CConcept*>(indi,eqConcept) );
111 }
112 }
113 }
114
115 if (eqNonCanSet) {
116 for (CBOXSET<CConcept*>::const_iterator it = eqNonCanSet->constBegin(), itEnd = eqNonCanSet->constEnd(); it != itEnd; ++it) {
117 CConcept* eqConcept(*it);
118 bool negation = false;
119 if (!conLabelSet->containsConcept(eqConcept,negation)) {
120 possAssSet->insert( QPair<CIndividual*,CConcept*>(indi,eqConcept) );
121 }
122 }
123 }
124 }
125 return true;
126 }
127 return false;
128 }
129
130
131 CIndividualsResult *CDeterministicNondeterministicIndividualsQuery::constructIndividualsResult(CRealization* realization) {
132 if (mResult) {
133 delete mResult;
134 mResult = 0;
135 }
136 CConsistence* consistence = mOntology->getConsistence();
137 if (consistence && realization) {
138 mResult = new CIndividualsResult();
139
140 CConceptRealization* conRealisation = realization->getConceptRealization();
141 CPossibleAssertionsCollectionSet* possAssCollSet = conRealisation->getPossibleAssertionCollectionSet();
142
143 QSet< QPair<CIndividual*,CConcept*> > possAssSet;
144 QSet< QPair<CIndividual*,CConcept*> > knownAssSet;
145
146 CIndividualVector* indiVec = mOntology->getABox()->getIndividualVector();
147 cint64 indiCount = indiVec->getItemCount();
148
149 CConsistenceTaskData* consTaskData = (CConsistenceTaskData*)consistence->getConsistenceModelData();
150 if (consTaskData) {
151 CSatisfiableCalculationTask* detTask = consTaskData->getDeterministicSatisfiableTask();
152 CSatisfiableCalculationTask* nonDetTask = consTaskData->getCompletionGraphCachedSatisfiableTask();
153 if (detTask != nonDetTask) {
154 CProcessingDataBox* dataBox = nonDetTask->getProcessingDataBox();
155 if (dataBox) {
156 CIndividualProcessNodeVector* indiNodeVec = dataBox->getIndividualProcessNodeVector();
157 cint64 indiNodeCount = indiNodeVec->getItemCount();
158
159 if (mIndividualSet.isEmpty()) {
160
161 if (possAssCollSet) {
162 for (CPossibleAssertionsCollectionSet::const_iterator it = possAssCollSet->constBegin(), itEnd = possAssCollSet->constEnd(); it != itEnd; ++it) {
163 const QPair<CIndividual*,CConcept*>& possAssPair(*it);
164 possAssSet.insert( QPair<CIndividual*,CConcept*>(possAssPair.first,possAssPair.second) );
165 }
166 }
167
168 for (cint64 indiID = 0; indiID < indiCount; ++indiID) {
169 CIndividual* individual = indiVec->getData(indiID);
170 if (individual) {
171 addIndividualResultData(individual,indiNodeVec,&possAssSet);
172 CIndividualConceptAssertionSetCollector indiConAssColl(individual,&knownAssSet);
173 conRealisation->visitAllTypes(individual,&indiConAssColl);
174 }
175 }
176
177 } else {
178 if (possAssCollSet) {
179 for (CPossibleAssertionsCollectionSet::const_iterator it = possAssCollSet->constBegin(), itEnd = possAssCollSet->constEnd(); it != itEnd; ++it) {
180 const QPair<CIndividual*,CConcept*>& possAssPair(*it);
181 CIndividual* individual(possAssPair.first);
182 if (mIndividualSet.contains(individual)) {
183 possAssSet.insert( QPair<CIndividual*,CConcept*>(possAssPair.first,possAssPair.second) );
184 }
185 }
186 }
187
188
189 for (QSet<CIndividual*>::const_iterator it = mIndividualSet.constBegin(), itEnd = mIndividualSet.constEnd(); it != itEnd; ++it) {
190 CIndividual* individual(*it);
191 addIndividualResultData(individual,indiNodeVec,&possAssSet);
192 CIndividualConceptAssertionSetCollector indiConAssColl(individual,&knownAssSet);
193 conRealisation->visitAllTypes(individual,&indiConAssColl);
194 }
195
196 }
197 }
198 }
199 }
200
201 QSet<CIndividual*> nonDetIndiSet;
202 for (QSet< QPair<CIndividual*,CConcept*> >::const_iterator it = possAssSet.constBegin(), itEnd = possAssSet.constEnd(); it != itEnd; ++it) {
203 const QPair<CIndividual*,CConcept*>& indiConPair(*it);
204 if (!knownAssSet.contains(indiConPair)) {
205 CIndividual* indi = indiConPair.first;
206 nonDetIndiSet.insert(indi);
207 }
208 }
209
210 if (mIndividualSet.isEmpty()) {
211 for (cint64 indiID = 0; indiID < indiCount; ++indiID) {
212 CIndividual* individual = indiVec->getData(indiID);
213 if (individual) {
214 bool addIndiToResult = false;
215 if (mDeterministicIndividuals && !nonDetIndiSet.contains(individual)) {
216 addIndiToResult = true;
217 } else if (!mDeterministicIndividuals && nonDetIndiSet.contains(individual)) {
218 addIndiToResult = true;
219 }
220 if (addIndiToResult) {
221 QString indiName;
222 if (mUseAbbreviatedIRIs) {
223 indiName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(individual->getIndividualNameLinker());
224 } else {
225 indiName = CIRIName::getRecentIRIName(individual->getIndividualNameLinker());
226 }
227 mResult->addIndividual(indiName);
228 }
229 }
230 }
231 } else {
232 for (QSet<CIndividual*>::const_iterator it = mIndividualSet.constBegin(), itEnd = mIndividualSet.constEnd(); it != itEnd; ++it) {
233 CIndividual* individual(*it);
234 bool addIndiToResult = false;
235 if (mDeterministicIndividuals && !nonDetIndiSet.contains(individual)) {
236 addIndiToResult = true;
237 } else if (!mDeterministicIndividuals && nonDetIndiSet.contains(individual)) {
238 addIndiToResult = true;
239 }
240 if (addIndiToResult) {
241 QString indiName;
242 if (mUseAbbreviatedIRIs) {
243 indiName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(individual->getIndividualNameLinker());
244 } else {
245 indiName = CIRIName::getRecentIRIName(individual->getIndividualNameLinker());
246 }
247 mResult->addIndividual(indiName);
248 }
249 }
250 }
251
252 }
253 return mResult;
254 }
255
256
257 QString CDeterministicNondeterministicIndividualsQuery::getQueryName() {
258 return mQueryName;
259 }
260
261 QString CDeterministicNondeterministicIndividualsQuery::getQueryString() {
262 return mQueryString;
263 }
264
265 bool CDeterministicNondeterministicIndividualsQuery::hasAnswer() {
266 return mResult != 0;
267 }
268
269 QString CDeterministicNondeterministicIndividualsQuery::getAnswerString() {
270 if (!mResult) {
271 return QString("Unknown Individuals");
272 } else {
273 return mResult->getQueryResultString();
274 }
275 }
276
277 bool CDeterministicNondeterministicIndividualsQuery::hasError() {
278 return mConsistencyCalcError || mQueryConstructError || CQuery::hasError();
279 }
280
281
282 }; // end namespace Query
283
284 }; // end namespace Reasoner
285
286 }; // end namespace Konclude