Debian Codegraph @

Source/Reasoner/Revision/CSPOntologyRevisionManager.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 "CSPOntologyRevisionManager.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Revision {
29
30
31 CSPOntologyRevisionManager::CSPOntologyRevisionManager(COntologyRevisionPersistencer* persistencer) : CLogIdentifier("::Konclude::Reasoner::Revision::SPOntologyRevisionManager",this) {
32 classificationMan = 0;
33 nextOntologyID = 0;
34 nextRevisionPathID = 0;
35 nextUnamedOntologyNumber = 0;
36 confProvider = 0;
37 mBaseOnto = nullptr;
38
39 mLastOntologyRevisionUpdateKBNameOrNewAnonymous = QString("http://Konclude.com/Ontologies/$LastCreatedKnowledgeBaseIfAvailableAndCreateNewAnonymousKnowledgeBaseOtherwise");
40 mLastOntologyRevisionUpdateKBName = QString("http://Konclude.com/Ontologies/?LastRevisionUpdateKnowledgeBase");
41 mLastOntologyCreatedKBName = QString("http://Konclude.com/Ontologies/?LastCreatedKnowledgeBase");
42 mFirstOntologyRevisionUpdateKBName = QString("http://Konclude.com/Ontologies/$FirstRevisionUpdateKnowledgeBase");
43 mFirstOntologyCreatedKBName = QString("http://Konclude.com/Ontologies/$FirstCreatedKnowledgeBase");
44
45 mHasFirstCreatedOntology = false;
46 mHasFirstOntologyRevisionUpdate = false;
47
48 mOntoRevPersistencer = persistencer;
49 ontologyCount = 0;
50 }
51
52
53 CSPOntologyRevisionManager::~CSPOntologyRevisionManager() {
54 qDeleteAll(onRevContainer);
55 }
56
57
58 COntologyRevisionManager *CSPOntologyRevisionManager::initializeManager(CConfigurationProvider *configurationProvider) {
59 confProvider = configurationProvider;
60 classificationMan = CConfigManagerReader::readClassificationManagerConfig(confProvider);
61 return this;
62 }
63
64
65 qint64 CSPOntologyRevisionManager::getOntologyCount() {
66 return ontologyCount;
67 }
68
69
70
71 CConcreteOntology* CSPOntologyRevisionManager::getBasementOntology(CCommandRecordRouter& commandRecordRouter) {
72 CConcreteOntology* usedBasementOntology = nullptr;
73
74 if (mBaseOnto) {
75 QString resolveBasementKBNameString = CConfigDataReader::readConfigString(confProvider,"Konclude.Ontology.Revision.BasementResolveKBName");
76 if (!resolveBasementKBNameString.isEmpty()) {
77 qint64 revPath = nameIDHash.value(resolveBasementKBNameString);
78 COntologyRevision *currOntologyRev = revisionHash.value(revPath,0);
79 if (currOntologyRev) {
80 usedBasementOntology = currOntologyRev->getOntology();
81 }
82 }
83 }
84
85 if (!usedBasementOntology) {
86 if (!mBaseOnto) {
87 CUnspecifiedMessageInformationRecord::makeRecord("Creating ontology basement.",&commandRecordRouter);
88 mBaseOnto = new CConcreteOntology(confProvider->getCurrentConfiguration());
89 CConcreteOntologyBasementBuilder* basementOntoBuilder = new CConcreteOntologyBasementBuilder(mBaseOnto);
90 basementOntoBuilder->initializeBuilding();
91 basementOntoBuilder->buildOntologyBasement();
92 basementOntoBuilder->completeBuilding();
93 delete basementOntoBuilder;
94 COntologyConfigDependedPreProcesser* preProcessor = new COntologyConfigDependedPreProcesser(commandRecordRouter);
95 preProcessor->preprocess(mBaseOnto,confProvider->getCurrentConfiguration());
96 delete preProcessor;
97 CUnspecifiedMessageInformationRecord::makeRecord("Ontology basement created.",&commandRecordRouter);
98 }
99 usedBasementOntology = mBaseOnto;
100 }
101 return usedBasementOntology;
102 }
103
104
105
106 COntologyRevision* CSPOntologyRevisionManager::createNewOntologyRevisionFromBasementOntology(const QString& ontologyName, CCommandRecordRouter& commandRecordRouter) {
107 qint64 ontologyID = nextOntologyID++;
108 qint64 revPath = nextRevisionPathID++;
109
110 COntologyConfigurationExtension *ontConfig = new COntologyConfigurationExtension(confProvider->getCurrentConfiguration(), 0);
111 CConcreteOntology* baseOnto = getBasementOntology(commandRecordRouter);
112 CConcreteOntology *ont = new CConcreteOntology(baseOnto, ontConfig);
113 ont->setOntologyID(ontologyID);
114 ont->setOntologyName(ontologyName);
115
116
117
118 COntologyRevision *onRev = new COntologyRevision(ont, 0, ontConfig);
119 onRev->setOntologyRevisionPath(revPath);
120 onRev->setOntologyRevisionDepth(0);
121
122 onRevContainer.insert(onRev);
123
124 revisionHash.insert(revPath, onRev);
125 nameIDHash.insert(ontologyName, revPath);
126
127 if (!mHasFirstCreatedOntology) {
128 nameIDHash.insert(mFirstOntologyCreatedKBName, revPath);
129 mHasFirstCreatedOntology = true;
130 }
131 nameIDHash.insert(mLastOntologyRevisionUpdateKBName, revPath);
132 nameIDHash.insert(mLastOntologyRevisionUpdateKBNameOrNewAnonymous, revPath);
133 nameIDHash.insert(mLastOntologyCreatedKBName, revPath);
134
135
136 if (mOntoRevPersistencer && mOntoRevPersistencer->hasNewOntologyRevision(ontologyName, onRev)) {
137 LOGINFO(getLogDomain(), QString("Trying to load persisted version of KnowledgeBase '%1'.").arg(ontologyName), this);
138 if (!mOntoRevPersistencer->loadLatestOntologyRevision(ontologyName, onRev)) {
139 LOGWARN(getLogDomain(), QString("Failed to load persisted version of KnowledgeBase '%1'.").arg(ontologyName), this);
140 }
141 else {
142 LOGINFO(getLogDomain(), QString("Successfully loaded newly persisted version of KnowledgeBase '%1'.").arg(ontologyName), this);
143 }
144 }
145
146 ontologyCount++;
147 return onRev;
148 }
149
150
151
152 CCommandDelegater *CSPOntologyRevisionManager::delegateCommand(CCommand *command) {
153 if (dynamic_cast<CCreateKnowledgeBaseCommand *>(command)) {
154 CCreateKnowledgeBaseCommand *cKBC = dynamic_cast<CCreateKnowledgeBaseCommand *>(command);
155
156 CCommandRecordRouter commandRecordRouter(command,this);
157
158 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
159
160 QString kbName = cKBC->getKnowledgeBaseName();
161 kbName = createNewOntology(kbName, cKBC->getPrefixList(), commandRecordRouter);
162 cKBC->setKnowledgeBaseName(kbName);
163
164
165 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
166 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
167
168 } else if (dynamic_cast<CCreateKnowledgeBaseRevisionUpdateCommand *>(command)) {
169 CCreateKnowledgeBaseRevisionUpdateCommand *cKBRevUpC = (CCreateKnowledgeBaseRevisionUpdateCommand *)command;
170 CCommandRecordRouter commandRecordRouter(command,this);
171 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
172
173 QString kbName = cKBRevUpC->getKnowledgeBaseName();
174 bool forceCreation = cKBRevUpC->requireCreateIfNotExist();
175 bool reportError = cKBRevUpC->reportErrorCreateIfNotExist();
176
177 COntologyRevision* nextOntologyRev = createNewOntologyRevision(kbName, forceCreation, reportError, commandRecordRouter);
178 cKBRevUpC->setOntologyRevision(nextOntologyRev);
179
180 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
181 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
182
183 } else if (dynamic_cast<CReleaseKnowledgeBaseCommand *>(command)) {
184 CReleaseKnowledgeBaseCommand *rKBRevUpC = (CReleaseKnowledgeBaseCommand *)command;
185 CCommandRecordRouter commandRecordRouter(command,this);
186 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
187
188 QString kbName = rKBRevUpC->getKnowledgeBaseName();
189 if (!checkHasOntology(kbName)) {
190 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' does not exist.").arg(kbName),&commandRecordRouter);
191 } else {
192 if (nameIDHash.contains(kbName)) {
193 nameIDHash.remove(kbName);
194 }
195 if (mOntoRevPersistencer) {
196 mOntoRevPersistencer->deletePersistedOntology(kbName);
197 }
198 }
199 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
200 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
201
202 } else if (dynamic_cast<CGetKnowledgeBaseConfigCommand *>(command)) {
203 CGetKnowledgeBaseConfigCommand *getConfigComm = (CGetKnowledgeBaseConfigCommand *)command;
204 CCommandRecordRouter commandRecordRouter(command,this);
205 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
206
207 QString kbName = getConfigComm->getKnowlegeBaseString();
208 if (!checkHasOntology(kbName)) {
209 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' does not exist.").arg(kbName),&commandRecordRouter);
210 } else {
211 if (!nameIDHash.contains(kbName)) {
212 createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
213 }
214
215 qint64 revPath = nameIDHash.value(kbName);
216 COntologyRevision *currOntologyRev = revisionHash.value(revPath,0);
217 if (currOntologyRev) {
218 COntologyConfigurationExtension *config = currOntologyRev->getOntologyConfiguration();
219 CConfigData *configData = config->getRelatedConfigChange(getConfigComm->getConfigNameString());
220 getConfigComm->setConfigData(configData);
221 } else {
222 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' could not be resolved.").arg(kbName),&commandRecordRouter);
223 }
224 }
225 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
226 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
227
228 } else if (dynamic_cast<CGetKnowledgeBaseSettingsCommand *>(command)) {
229 CGetKnowledgeBaseSettingsCommand *getConfigComm = (CGetKnowledgeBaseSettingsCommand *)command;
230 CCommandRecordRouter commandRecordRouter(command,this);
231 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
232
233 QString kbName = getConfigComm->getKnowlegeBaseString();
234 if (!checkHasOntology(kbName)) {
235 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' doesn't exist.").arg(kbName),&commandRecordRouter);
236 } else {
237 if (!nameIDHash.contains(kbName)) {
238 createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
239 }
240
241
242 qint64 revPath = nameIDHash.value(kbName);
243 COntologyRevision *currOntologyRev = revisionHash.value(revPath,0);
244 if (currOntologyRev) {
245 COntologyConfigurationExtension *config = currOntologyRev->getOntologyConfiguration();
246 getConfigComm->setConfiguration(config);
247 } else {
248 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' could not be resolved.").arg(kbName),&commandRecordRouter);
249 }
250 }
251 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
252 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
253
254 } else if (dynamic_cast<CSetKnowledgeBaseConfigCommand *>(command)) {
255 CSetKnowledgeBaseConfigCommand *setConfigComm = (CSetKnowledgeBaseConfigCommand *)command;
256 CCommandRecordRouter commandRecordRouter(command,this);
257 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
258
259 QString kbName = setConfigComm->getKnowlegeBaseString();
260 if (!checkHasOntology(kbName)) {
261 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' doesn't exist.").arg(kbName),&commandRecordRouter);
262 } else {
263 if (!nameIDHash.contains(kbName)) {
264 createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
265 }
266
267 qint64 revPath = nameIDHash.value(kbName);
268 COntologyRevision *currOntologyRev = revisionHash.value(revPath,0);
269 if (currOntologyRev) {
270 COntologyConfigurationExtension *config = currOntologyRev->getOntologyConfiguration();
271 if (!config->isConfigLevelLocked(setConfigComm->getConfigNameString())) {
272 CCreateKnowledgeBaseRevisionUpdateCommand *createUpdateRevComm = new CCreateKnowledgeBaseRevisionUpdateCommand(setConfigComm->getKnowlegeBaseString(),setConfigComm);
273 delegateCommand(createUpdateRevComm);
274 COntologyRevision *ontoRev = createUpdateRevComm->getOntologyRevision();
275 if (ontoRev) {
276 COntologyConfigurationExtension *config = ontoRev->getOntologyConfiguration();
277 CConfigData *configData = config->createAndSetConfig(setConfigComm->getConfigNameString());
278 if (configData) {
279 if (configData->supportsStringConvertion()) {
280 configData->readFromString(setConfigComm->getConfigValueString());
281 } else {
282 CUnspecifiedMessageErrorRecord::makeRecord(QString("Value for configuration property '%1' could not read from string.").arg(setConfigComm->getConfigNameString()),&commandRecordRouter);
283 }
284 } else {
285 CUnspecifiedMessageErrorRecord::makeRecord(QString("Configuration property '%1' not available.").arg(setConfigComm->getConfigNameString()),&commandRecordRouter);
286 }
287 } else {
288 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' could not be resolved.").arg(setConfigComm->getKnowlegeBaseString()),&commandRecordRouter);
289 }
290 CInstallKnowledgeBaseRevisionUpdateCommand *installRevUpdateComm = new CInstallKnowledgeBaseRevisionUpdateCommand(setConfigComm->getKnowlegeBaseString(),createUpdateRevComm,setConfigComm);
291 delegateCommand(installRevUpdateComm);
292 } else {
293 CUnspecifiedMessageErrorRecord::makeRecord(QString("Configuration property '%1' is locked.").arg(setConfigComm->getConfigNameString()),&commandRecordRouter);
294 }
295 } else {
296 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' could not be resolved.").arg(kbName),&commandRecordRouter);
297 }
298 }
299
300 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
301 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
302
303 } else if (dynamic_cast<CInstallKnowledgeBaseRevisionUpdateCommand *>(command)) {
304 CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = (CInstallKnowledgeBaseRevisionUpdateCommand *)command;
305 CCommandRecordRouter commandRecordRouter(command,this);
306 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
307
308 QString kbName = inKBRevUpC->getKnowledgeBaseName();
309 COntologyRevision *nextOntRev = inKBRevUpC->getOntologyRevision();
310
311 if (!nextOntRev) {
312 CUnspecifiedMessageErrorRecord::makeRecord(QString("New KnowledgeBase '%1' revision not available.").arg(kbName),&commandRecordRouter);
313 } else {
314
315 qint64 nextRevPath = nextOntRev->getOntologyRevisionPath();
316 qint64 nextRevDepth = nextOntRev->getOntologyRevisionDepth();
317
318 if (!checkHasOntology(kbName)) {
319 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' doesn't exist.").arg(kbName),&commandRecordRouter);
320 } else {
321
322 if (!nameIDHash.contains(kbName)) {
323 createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
324 }
325
326 qint64 revPath = nameIDHash.value(kbName);
327 COntologyRevision *ontologyRev = revisionHash.value(revPath,0);
328 if (ontologyRev) {
329 kbName = ontologyRev->getOntology()->getOntologyName();
330 qint64 revDepth = ontologyRev->getOntologyRevisionDepth();
331 if (nextRevDepth > revDepth+1) {
332
333 COntologyRevision* prevOntRev = nextOntRev->getPreviousOntologyRevision();
334 CConcreteOntology* prevOnt = prevOntRev->getOntology();
335
336 CConcreteOntology* currOnt = ontologyRev->getOntology();
337 CConcreteOntology* nextOnt = nextOntRev->getOntology();
338
339 //CConcreteOntologyMergingBuilder mergingBuilder(currOnt,nextOnt,prevOnt);
340 //mergingBuilder.initializeBuilding();
341 //mergingBuilder.mergingBuilding();
342 //mergingBuilder.completeBuilding();
343
344 CConcreteOntologyMergingRebuildingBuilder mergingRebuildingBuilder(nextOnt);
345 mergingRebuildingBuilder.initializeBuilding();
346 mergingRebuildingBuilder.mergeOntology(currOnt, prevOnt);
347 mergingRebuildingBuilder.completeBuilding();
348
349 // install new knowledge base revision
350 revisionHash.insert(revPath,nextOntRev);
351 onRevContainer.insert(nextOntRev);
352 CUnspecifiedMessageInformationRecord::makeRecord(QString("Merging KnowledgeBase '%1' because of concurrent modification.").arg(kbName),&commandRecordRouter);
353 } else {
354 // install new knowledge base revision
355 revisionHash.insert(revPath,nextOntRev);
356 onRevContainer.insert(nextOntRev);
357 }
358 if (!mHasFirstOntologyRevisionUpdate) {
359 mHasFirstOntologyRevisionUpdate = true;
360 nameIDHash.insert(mFirstOntologyCreatedKBName, revPath);
361 }
362 nameIDHash.insert(mLastOntologyRevisionUpdateKBName, revPath);
363 nameIDHash.insert(mLastOntologyRevisionUpdateKBNameOrNewAnonymous, revPath);
364
365 if (mOntoRevPersistencer) {
366 int remainingPersistingTryCount = 3;
367 while (!mOntoRevPersistencer->persistOntologyRevision(nextOntRev, ontologyRev) && remainingPersistingTryCount-- > 0) {
368 LOGINFO(getLogDomain(),QString("Persisting of KnowledgeBase '%1' failed, probably due concurrently persisting another version.").arg(kbName),this);
369 if (mOntoRevPersistencer->hasNewOntologyRevision(kbName,ontologyRev)) {
370 if (!mOntoRevPersistencer->loadLatestOntologyRevision(kbName,nextOntRev)) {
371 LOGERROR(getLogDomain(),QString("Loading of newly persisted KnowledgeBase '%1' failed.").arg(kbName),this);
372 remainingPersistingTryCount = 0;
373 } else {
374 LOGINFO(getLogDomain(),QString("Successfully loaded newly persisted version of KnowledgeBase '%1'.").arg(kbName),this);
375 }
376 } else {
377 LOGWARN(getLogDomain(),QString("No new version of KnowledgeBase '%1' has been persisted, repeating persisting attempt.").arg(kbName),this);
378 }
379 }
380 }
381
382
383 } else {
384 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' could not be resolved.").arg(kbName),&commandRecordRouter);
385 }
386 }
387
388 }
389
390 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
391 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
392
393 } else if (dynamic_cast<CGetCurrentKnowledgeBaseRevisionCommand *>(command)) {
394 CGetCurrentKnowledgeBaseRevisionCommand *gCurrKBRevUpC = (CGetCurrentKnowledgeBaseRevisionCommand *)command;
395 CCommandRecordRouter commandRecordRouter(command,this);
396 CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
397
398 QString kbName = gCurrKBRevUpC->getKnowledgeBaseName();
399 if (!checkHasOntology(kbName)) {
400 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' doesn't exist.").arg(kbName),&commandRecordRouter);
401 } else {
402
403 if (!nameIDHash.contains(kbName)) {
404 createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
405 }
406
407 qint64 revPath = nameIDHash.value(kbName);
408 COntologyRevision *currOntologyRev = revisionHash.value(revPath,0);
409
410
411 if (mOntoRevPersistencer && mOntoRevPersistencer->hasNewOntologyRevision(kbName,currOntologyRev)) {
412
413 qint64 ontologyID = nextOntologyID++;
414
415 CConcreteOntology *currOnt = currOntologyRev->getOntology();
416 COntologyConfigurationExtension *currOntConfig = currOntologyRev->getOntologyConfiguration();
417 COntologyConfigurationExtension *nextOntConfig = new COntologyConfigurationExtension(currOntConfig,currOntConfig->getAdditionalConfigurationList(),currOntConfig->getConfigurationID()+1);
418
419 CConcreteOntology *nextOnto = new CConcreteOntology(currOnt,nextOntConfig);
420 nextOnto->setOntologyName(currOnt->getOntologyName());
421 nextOnto->setOntologyID(ontologyID);
422
423 COntologyRevision *nextOntologyRev = new COntologyRevision(nextOnto,currOntologyRev,nextOntConfig);
424 nextOntologyRev->setOntologyRevisionDepth(currOntologyRev->getOntologyRevisionDepth()+1);
425
426
427 LOGINFO(getLogDomain(),QString("Trying to load newly persisted version of KnowledgeBase '%1'.").arg(kbName),this);
428 if (!mOntoRevPersistencer->loadLatestOntologyRevision(kbName,nextOntologyRev)) {
429 LOGERROR(getLogDomain(),QString("Failed to load newly persisted version of KnowledgeBase '%1'.").arg(kbName),this);
430 delete nextOntologyRev;
431 } else {
432 LOGINFO(getLogDomain(),QString("Successfully loaded newly persisted version of KnowledgeBase '%1'.").arg(kbName),this);
433 revisionHash.insert(revPath,nextOntologyRev);
434 onRevContainer.insert(nextOntologyRev);
435 currOntologyRev = nextOntologyRev;
436 }
437 }
438
439
440 if (currOntologyRev) {
441 gCurrKBRevUpC->setOntologyRevision(currOntologyRev);
442 } else {
443 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' couldn't be resolved.").arg(kbName),&commandRecordRouter);
444 }
445 }
446
447 CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
448 CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
449
450 }
451
452 return this;
453 }
454
455
456
457 COntologyRevision* CSPOntologyRevisionManager::createNewOntologyRevision(const QString& ontologyName, bool forceCreation, bool reportError, CCommandRecordRouter& commandRecordRouter) {
458 QString kbName = ontologyName;
459
460 bool kbExist = checkHasOntology(kbName);
461
462 bool createdKBForLastOntologyRevisionUpdateKBNameOrNewAnonymous = false;
463 if (!kbExist && mLastOntologyRevisionUpdateKBNameOrNewAnonymous == kbName) {
464 kbName = createNewOntology("", nullptr, commandRecordRouter);
465 createdKBForLastOntologyRevisionUpdateKBNameOrNewAnonymous = true;
466 kbExist = checkHasOntology(kbName);
467 }
468
469 if (!kbExist && !forceCreation) {
470 if (reportError) {
471 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' does not exist.").arg(kbName), &commandRecordRouter);
472 }
473 } else {
474
475 if (!nameIDHash.contains(kbName)) {
476 createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
477 }
478
479 qint64 revPath = nameIDHash.value(kbName);
480 COntologyRevision *currOntologyRev = revisionHash.value(revPath, nullptr);
481 if (currOntologyRev) {
482
483 qint64 ontologyID = nextOntologyID++;
484
485 CConcreteOntology *currOnt = currOntologyRev->getOntology();
486 COntologyConfigurationExtension *currOntConfig = currOntologyRev->getOntologyConfiguration();
487 COntologyConfigurationExtension *nextOntConfig = new COntologyConfigurationExtension(currOntConfig, currOntConfig->getAdditionalConfigurationList(), currOntConfig->getConfigurationID() + 1);
488
489 CConcreteOntology *ont = new CConcreteOntology(currOnt, nextOntConfig);
490 kbName = currOnt->getOntologyName();
491 ont->setOntologyName(currOnt->getOntologyName());
492 ont->setOntologyID(ontologyID);
493
494 COntologyRevision *nextOntologyRev = new COntologyRevision(ont, currOntologyRev, nextOntConfig);
495 nextOntologyRev->setOntologyRevisionDepth(currOntologyRev->getOntologyRevisionDepth() + 1);
496
497
498 if (mOntoRevPersistencer && mOntoRevPersistencer->hasNewOntologyRevision(kbName, currOntologyRev)) {
499 LOGINFO(getLogDomain(), QString("Trying to load newly persisted version of KnowledgeBase '%1'.").arg(kbName), this);
500 if (!mOntoRevPersistencer->loadLatestOntologyRevision(kbName, nextOntologyRev)) {
501 LOGERROR(getLogDomain(), QString("Failed to load newly persisted version of KnowledgeBase '%1'.").arg(kbName), this);
502 }
503 else {
504 LOGINFO(getLogDomain(), QString("Successfully loaded newly persisted version of KnowledgeBase '%1'.").arg(kbName), this);
505 }
506 }
507
508 if (createdKBForLastOntologyRevisionUpdateKBNameOrNewAnonymous) {
509 nameIDHash.insert(mLastOntologyRevisionUpdateKBNameOrNewAnonymous, revPath);
510 }
511
512
513 return nextOntologyRev;
514 } else {
515 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' could not be resolved.").arg(kbName), &commandRecordRouter);
516 }
517 }
518
519 return nullptr;
520 }
521
522
523 bool CSPOntologyRevisionManager::checkHasOntology(const QString& ontologyName) {
524 QString kbName = ontologyName;
525 if (nameIDHash.contains(kbName)) {
526 return true;
527 } else if (mOntoRevPersistencer && mOntoRevPersistencer->hasOntologyPersisted(kbName)) {
528 return true;
529 }
530 return false;
531 }
532
533
534
535 QString CSPOntologyRevisionManager::createNewOntology(const QString& ontologyName, QList<CNamePrefix*>* prefixList, CCommandRecordRouter& commandRecordRouter) {
536 QString kbName = ontologyName;
537 if (kbName.isEmpty()) {
538 QString unKBName = QString("http://Konclude.com/Ontologies/UnnamedOntologies/%1/%2/").arg(nextUnamedOntologyNumber++).arg(QUuid::createUuid().toString().replace("{", "").replace("}", ""));
539 while (nameIDHash.contains(unKBName)) {
540 unKBName = QString("http://Konclude.com/Ontologies/UnnamedOntologies/%1/%2/").arg(nextUnamedOntologyNumber++).arg(QUuid::createUuid().toString().replace("{", "").replace("}", ""));
541 }
542 kbName = unKBName;
543 }
544 if (nameIDHash.contains(kbName)) {
545 // ontology already exists
546 CUnspecifiedMessageErrorRecord::makeRecord(QString("KnowledgeBase '%1' already exists.").arg(kbName), &commandRecordRouter);
547 } else {
548
549 COntologyRevision* ontRev = createNewOntologyRevisionFromBasementOntology(kbName, commandRecordRouter);
550
551 if (prefixList) {
552 COntologyStringMapping* ontoStrings = ontRev->getOntology()->getStringMapping();
553 CMAPPINGHASH<QString, CNamePrefix*>* abbreviatedNamePrefixMapHash = ontoStrings->getAbbreviatedNamePrefixHash(true);
554 CMAPPINGHASH<QString, CNamePrefix*>* namePrefixMapHash = ontoStrings->getNamePrefixHash(true);
555 foreach(CNamePrefix* prefix, *prefixList) {
556 CNamePrefix* newPrefix = new CNamePrefix(prefix->getAbbreviatedPrefixString(), prefix->getPrefixString());
557 abbreviatedNamePrefixMapHash->insert(newPrefix->getAbbreviatedPrefixString(), newPrefix);
558 namePrefixMapHash->insert(newPrefix->getPrefixString(), newPrefix);
559 }
560 }
561 }
562
563 return kbName;
564 }
565
566
567 }; // end namespace Revision
568
569 }; // end namespace Reasoner
570
571 }; // end namespace Konclude
572