/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "COWLlinkProcessor.h"
namespace Konclude {
namespace Control {
namespace Interface {
namespace OWLlink {
COWLlinkProcessor::COWLlinkProcessor(bool immediatelyStartThread) : CThread("OWLlinkProcessor"), CLogIdentifier("::Konclude::Control::Interface::OWLlink::OWLlinkProcessor",this) {
preSynchronizer = new CPreconditionSynchronizer(this);
reasonerCommander = 0;
mConfLoadOntologiesSAXParsing = true;
mConfLoadOntologiesStreamParsing = true;
defaultCommandDelegater = preSynchronizer;
mConfLogProcessingTimes = false;
mNetworkManager = nullptr;
if (immediatelyStartThread) {
startThread();
}
}
COWLlinkProcessor::~COWLlinkProcessor() {
stopThread();
delete preSynchronizer;
}
COWLlinkProcessor *COWLlinkProcessor::startProcessing() {
postEvent(new CInitializeEvent());
return this;
}
CCommandDelegater *COWLlinkProcessor::delegateCommand(CCommand *command) {
postEvent(new CRealizeCommandEvent(command));
return this;
}
bool COWLlinkProcessor::parseOntology(QIODevice* device, const QString& ontoIRI, const QString& resolvedIRI, CConcreteOntology *ont, COntologyConfigurationExtension *ontConfig, QList& importOntologiesList, QStringList& parserErrorList, CCommandRecordRouter& commandRecordRouter) {
COntologyMultiAutoParsingLoader loader;
bool loaded = loader.parseOntology(device, ontoIRI, resolvedIRI, ont, ontConfig, importOntologiesList, parserErrorList, commandRecordRouter);
return loaded;
}
CQtHttpTransactionManager* COWLlinkProcessor::getNetworkTransactionManager() {
if (!mNetworkManager) {
mNetworkManager = new CQtHttpTransactionManager(30 * 60 * 1000);
}
return mNetworkManager;
}
bool COWLlinkProcessor::createDownloadParseCommands(const QString& knowledgeBaseNameString, CCommand* parentCommand, CKnowledgeBaseRevisionCommandProvider* kbProviderCommand, const QMap& ontoIRIMapping, const QStringList& ontoIRIStringList, CCommandRecordRouter& commandRecordRouter) {
QList loadDataList;
QList preconditionsList;
cint64 downloadRequiredCount = 0;
foreach (const QString& ontoIRIString, ontoIRIStringList) {
QString resolvedString = ontoIRIString;
for (QMap::const_iterator resolveIRIIt = ontoIRIMapping.constBegin(), resolveIRIItEnd = ontoIRIMapping.constEnd(); resolveIRIIt != resolveIRIItEnd; ++resolveIRIIt) {
QString identifyIRI(resolveIRIIt.key());
QString resolvingIRI(resolveIRIIt.value());
if (resolvedString.startsWith(identifyIRI)) {
resolvedString = resolvedString.mid(identifyIRI.length());
resolvedString = resolvingIRI + resolvedString;
}
}
if (resolvedString != ontoIRIString) {
CUnspecifiedMessageInformationRecord::makeRecord(QString("Redirecting '%1' to '%2'.").arg(ontoIRIString).arg(resolvedString),&commandRecordRouter);
}
if (resolvedString.startsWith("http:") || resolvedString.startsWith("https:") || resolvedString.startsWith("ftp:")) {
QBuffer* tmpBuffer = new QBuffer();
CLoadKnowledgeBaseFinishDownloadCommand* finishDownloadCommand = new CLoadKnowledgeBaseFinishDownloadCommand(resolvedString,tmpBuffer,preSynchronizer);
parentCommand->makeToSubCommand(finishDownloadCommand);
CLoadKnowledgeBaseStartDownloadCommand* startDownloadCommand = new CLoadKnowledgeBaseStartDownloadCommand(resolvedString,finishDownloadCommand);
parentCommand->makeToSubCommand(startDownloadCommand);
preSynchronizer->delegateCommand(startDownloadCommand);
preconditionsList.append(startDownloadCommand);
preconditionsList.append(finishDownloadCommand);
++downloadRequiredCount;
CLoadKnowledgeBaseData* loadData = new CLoadKnowledgeBaseData(tmpBuffer,ontoIRIString,resolvedString);
loadDataList.append(loadData);
} else {
QString iriFileString = resolvedString;
if (iriFileString.startsWith("file:")) {
iriFileString.replace("file:","");
}
while (!QFile::exists(iriFileString) && iriFileString.startsWith("/")) {
iriFileString = iriFileString.remove(0,1);
}
if (!QFile::exists(iriFileString)) {
CUnspecifiedMessageErrorRecord::makeRecord(QString("File '%1' not found.").arg(resolvedString),&commandRecordRouter);
} else {
QFile* file = new QFile(iriFileString);
CLoadKnowledgeBaseData* loadData = new CLoadKnowledgeBaseData(file,ontoIRIString,resolvedString);
loadDataList.append(loadData);
}
}
}
CChooseParseInstallKnowledgeBaseOWLAutoOntologyCommand* chPaInKBOntComm = new CChooseParseInstallKnowledgeBaseOWLAutoOntologyCommand(knowledgeBaseNameString,loadDataList,ontoIRIMapping,kbProviderCommand);
parentCommand->makeToSubCommand(chPaInKBOntComm);
for (QList::const_iterator it = preconditionsList.constBegin(), itEnd = preconditionsList.constEnd(); it != itEnd; ++it) {
CCommand* preconditionCommand = *it;
chPaInKBOntComm->addCommandPrecondition(new CCommandProcessedPrecondition(preconditionCommand));
}
if (kbProviderCommand->getCommand() != parentCommand) {
chPaInKBOntComm->addCommandPrecondition(new CCommandProcessedPrecondition(kbProviderCommand->getCommand()));
}
preSynchronizer->delegateCommand(chPaInKBOntComm);
return true;
}
bool COWLlinkProcessor::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (!CThread::processCustomsEvents(type,event)) {
if (type == EVENTREALIZECOMMAND) {
CRealizeCommandEvent *commandEvent = (CRealizeCommandEvent *)event;
if (commandEvent) {
CCommand *command = commandEvent->getCommand();
if (command) {
if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CTellKnowledgeBaseOWL2XMLNodeCommand *tellKBC = (CTellKnowledgeBaseOWL2XMLNodeCommand *)command;
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(tellKBC->getKnowledgeBaseName());
tellKBC->makeToSubCommand(crKBRevUpC);
preSynchronizer->delegateCommand(crKBRevUpC);
CParseOWL2XMLOntologyCommand *pOWLOntC = new CParseOWL2XMLOntologyCommand(tellKBC->getOWL2Node(),crKBRevUpC);
tellKBC->makeToSubCommand(pOWLOntC);
preSynchronizer->delegateCommand(pOWLOntC);
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(tellKBC->getKnowledgeBaseName(),pOWLOntC);
inKBRevUpC->addCommandPrecondition(new CCommandProcessedPrecondition(pOWLOntC));
tellKBC->makeToSubCommand(inKBRevUpC);
preSynchronizer->delegateCommand(inKBRevUpC);
CPrepareKnowledgeBaseForRevisionCommand* prepareKBC = new CPrepareKnowledgeBaseForRevisionCommand(crKBRevUpC);
tellKBC->makeToSubCommand(prepareKBC);
prepareKBC->addCommandPrecondition(new CCommandProcessedPrecondition(inKBRevUpC));
preSynchronizer->delegateCommand(prepareKBC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CLoadKnowledgeBaseKRSSTestConceptCommand *loadKBC = (CLoadKnowledgeBaseKRSSTestConceptCommand *)command;
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(loadKBC->getKnowledgeBaseName());
loadKBC->makeToSubCommand(crKBRevUpC);
preSynchronizer->delegateCommand(crKBRevUpC);
CReadTextCommand *readTextC = new CReadTextCommand(loadKBC->getLoadIRIString());
loadKBC->makeToSubCommand(readTextC);
preSynchronizer->delegateCommand(readTextC);
CParseKRSSTestConceptOntologyCommand *pOWLOntC = new CParseKRSSTestConceptOntologyCommand(readTextC,crKBRevUpC,loadKBC->getTestConceptNameString());
loadKBC->makeToSubCommand(pOWLOntC);
preSynchronizer->delegateCommand(pOWLOntC);
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(loadKBC->getKnowledgeBaseName(),pOWLOntC);
inKBRevUpC->addCommandPrecondition(new CCommandProcessedPrecondition(pOWLOntC));
loadKBC->makeToSubCommand(inKBRevUpC);
preSynchronizer->delegateCommand(inKBRevUpC);
CPrepareKnowledgeBaseForRevisionCommand* prepareKBC = new CPrepareKnowledgeBaseForRevisionCommand(crKBRevUpC);
loadKBC->makeToSubCommand(prepareKBC);
prepareKBC->addCommandPrecondition(new CCommandProcessedPrecondition(inKBRevUpC));
preSynchronizer->delegateCommand(prepareKBC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CPrepareKnowledgeBaseForRevisionCommand *prepareKBC = (CPrepareKnowledgeBaseForRevisionCommand *)command;
COntologyRevision* ontoRev = prepareKBC->getOntologyRevision();
bool preparingOntology = false;
if (ontoRev) {
CConfigurationBase* config = ontoRev->getOntologyConfiguration();
COntologyProcessingStepVector* ontProStepVec = COntologyProcessingStepVector::getProcessingStepVectorInstance();
bool build = CConfigDataReader::readConfigBoolean(config,"Konclude.Ontology.Revision.BuildAfterModification");
if (build) {
prepareKBC->addOntologyProcessingStepRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSBUILD), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
bool preprocess = CConfigDataReader::readConfigBoolean(config,"Konclude.Ontology.Revision.PreprocessAfterModification");
if (preprocess) {
prepareKBC->addOntologyProcessingStepRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSPREPROCESS), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
bool consistency = CConfigDataReader::readConfigBoolean(config,"Konclude.Ontology.Revision.ConsistencyPrecomputationAfterModification");
if (consistency) {
prepareKBC->addOntologyProcessingStepRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSCONSISTENCY), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
bool cycles = CConfigDataReader::readConfigBoolean(config,"Konclude.Ontology.Revision.CyclesPrecomputationAfterModification");
if (cycles) {
prepareKBC->addOntologyProcessingStepRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSPRECOMPUTECYCLES), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
bool classify = CConfigDataReader::readConfigBoolean(config,"Konclude.Ontology.Revision.ClassifyAfterModification");
if (classify) {
prepareKBC->addOntologyProcessingStepRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSCLASSCLASSIFY), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
if (!prepareKBC->getOntologyProcessingRequirementList()->isEmpty() && reasonerCommander) {
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
preparingOntology = true;
reasonerCommander->realizeCommand(command);
}
}
if (!preparingOntology) {
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
}
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CLoadKnowledgeBaseOWLFunctionalOntologyCommand *loadKBOWLXMLOnto = (CLoadKnowledgeBaseOWLFunctionalOntologyCommand *)command;
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(loadKBOWLXMLOnto->getKnowledgeBaseName());
loadKBOWLXMLOnto->makeToSubCommand(crKBRevUpC);
preSynchronizer->delegateCommand(crKBRevUpC);
CCommand* lastWaitCommand = crKBRevUpC;
CKnowledgeBaseRevisionCommandProvider *ontologyRevisionProviderCommand = nullptr;
QStringList ontoIRIs(loadKBOWLXMLOnto->getLoadIRIStrings());
foreach (QString ontoIRI, ontoIRIs) {
CStreamParseOWL2FunctionalOntologyCommand *pOWLOntC = new CStreamParseOWL2FunctionalOntologyCommand(ontoIRI,crKBRevUpC);
if (lastWaitCommand) {
pOWLOntC->addCommandPrecondition(new CCommandProcessedPrecondition(lastWaitCommand));
}
loadKBOWLXMLOnto->makeToSubCommand(pOWLOntC);
preSynchronizer->delegateCommand(pOWLOntC);
ontologyRevisionProviderCommand = pOWLOntC;
lastWaitCommand = pOWLOntC;
}
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(loadKBOWLXMLOnto->getKnowledgeBaseName(),ontologyRevisionProviderCommand);
inKBRevUpC->addCommandPrecondition(new CCommandProcessedPrecondition(lastWaitCommand));
loadKBOWLXMLOnto->makeToSubCommand(inKBRevUpC);
preSynchronizer->delegateCommand(inKBRevUpC);
CPrepareKnowledgeBaseForRevisionCommand* prepareKBC = new CPrepareKnowledgeBaseForRevisionCommand(ontologyRevisionProviderCommand);
loadKBOWLXMLOnto->makeToSubCommand(prepareKBC);
prepareKBC->addCommandPrecondition(new CCommandProcessedPrecondition(inKBRevUpC));
preSynchronizer->delegateCommand(prepareKBC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CLoadKnowledgeBaseOWLXMLOntologyCommand *loadKBOWLXMLOnto = (CLoadKnowledgeBaseOWLXMLOntologyCommand *)command;
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(loadKBOWLXMLOnto->getKnowledgeBaseName());
loadKBOWLXMLOnto->makeToSubCommand(crKBRevUpC);
preSynchronizer->delegateCommand(crKBRevUpC);
QStringList ontoIRIs(loadKBOWLXMLOnto->getLoadIRIStrings());
CChooseParseInstallKnowledgeBaseOWLXMLOntologyCommand* chPaInKBOntComm = new CChooseParseInstallKnowledgeBaseOWLXMLOntologyCommand(loadKBOWLXMLOnto->getKnowledgeBaseName(),ontoIRIs,crKBRevUpC);
loadKBOWLXMLOnto->makeToSubCommand(chPaInKBOntComm);
preSynchronizer->delegateCommand(chPaInKBOntComm);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(), getLogDomain(), command);
CConnectKnowledgeBaseExternalTriplesDSNCommand *cKBETDSNC = (CConnectKnowledgeBaseExternalTriplesDSNCommand *)command;
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(cKBETDSNC->getKnowledgeBaseName());
cKBETDSNC->makeToSubCommand(crKBRevUpC);
preSynchronizer->delegateCommand(crKBRevUpC);
CParseInstallKnowledgeBaseExternalTriplesDSNConnectionCommand* paInKBExTrDSNCoComm = new CParseInstallKnowledgeBaseExternalTriplesDSNConnectionCommand(cKBETDSNC->getKnowledgeBaseName(), cKBETDSNC->getTriplesDBName(), cKBETDSNC->getConfigDSNString(), crKBRevUpC);
cKBETDSNC->makeToSubCommand(paInKBExTrDSNCoComm);
preSynchronizer->delegateCommand(paInKBExTrDSNCoComm);
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(paInKBExTrDSNCoComm->getKnowledgeBaseName(), crKBRevUpC);
inKBRevUpC->addCommandPrecondition(new CCommandProcessedPrecondition(paInKBExTrDSNCoComm));
cKBETDSNC->makeToSubCommand(inKBRevUpC);
preSynchronizer->delegateCommand(inKBRevUpC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(), getLogDomain(), command);
CParseInstallKnowledgeBaseExternalTriplesDSNConnectionCommand* pIKBETDSNCComm = (CParseInstallKnowledgeBaseExternalTriplesDSNConnectionCommand *)command;
CConfigData* data = nullptr;
COntologyRevision* ontoRev = pIKBETDSNCComm->getOntologyRevision();
if (ontoRev) {
COntologyConfigurationExtension* ontoConfExt = ontoRev->getOntologyConfiguration();
CConcreteOntology* ont = ontoRev->getOntology();
#ifdef KONCLUDE_REDLAND_INTEGRATION
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ont);
builder->initializeBuilding();
CRDFRedlandExternalTriplesDSNConnectingParser* parser = new CRDFRedlandExternalTriplesDSNConnectingParser(builder, ontoConfExt);
bool connectionSuccessfullyEstablished = parser->connectExternalTriples(pIKBETDSNCComm->getTriplesDBName(), pIKBETDSNCComm->getConfigDSNString());
if (!connectionSuccessfullyEstablished) {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Failed to establish DSN connection to external triples for knowledge base '%1'.").arg(pIKBETDSNCComm->getKnowledgeBaseName()), &commandRecordRouter);
}
CConcreteOntologyRedlandTriplesDataExpressionMapper* triplesMapper = new CConcreteOntologyRedlandTriplesDataExpressionMapper(builder);
triplesMapper->mapTriples(ont, ont->getOntologyTriplesData());
if (connectionSuccessfullyEstablished) {
builder->completeBuilding();
}
delete parser;
#else
CUnspecifiedMessageErrorRecord::makeRecord(QString("Cannot establish DSN connection for knowledge base '%1' without Redland libraries.").arg(pIKBETDSNCComm->getKnowledgeBaseName()), &commandRecordRouter);
#endif // !KONCLUDE_REDLAND_INTEGRATION
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Ontology revision not available.", &commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CChooseParseInstallKnowledgeBaseOWLXMLOntologyCommand* chPaInKBOntComm = (CChooseParseInstallKnowledgeBaseOWLXMLOntologyCommand *)command;
CConfigData* data = nullptr;
COntologyRevision* ontoRev = chPaInKBOntComm->getOntologyRevision();
if (ontoRev) {
COntologyConfigurationExtension* ontoConfExt = chPaInKBOntComm->getOntologyRevision()->getOntologyConfiguration();
bool confLoadOntologiesStreamParsing = mConfLoadOntologiesStreamParsing;
bool confLoadOntologiesSAXParsing = mConfLoadOntologiesSAXParsing;
data = ontoConfExt->getRelatedConfigChange("Konclude.OWLlink.StreamBasedLoadOntologiesParsing");
if (data) {
confLoadOntologiesStreamParsing = data->getBoolean();
}
data = ontoConfExt->getRelatedConfigChange("Konclude.OWLlink.SAXBasedLoadOntologiesParsing");
if (data) {
confLoadOntologiesSAXParsing = data->getBoolean();
}
QStringList ontoIRIs(chPaInKBOntComm->getLoadIRIStrings());
CCommand* lastWaitCommand = nullptr;
CKnowledgeBaseRevisionCommandProvider *ontologyRevisionProviderCommand = nullptr;
foreach (QString ontoIRI, ontoIRIs) {
if (confLoadOntologiesStreamParsing) {
CStreamParseOWL2XMLOntologyCommand *pOWLOntC = new CStreamParseOWL2XMLOntologyCommand(ontoIRI,chPaInKBOntComm);
if (lastWaitCommand) {
pOWLOntC->addCommandPrecondition(new CCommandProcessedPrecondition(lastWaitCommand));
}
chPaInKBOntComm->makeToSubCommand(pOWLOntC);
preSynchronizer->delegateCommand(pOWLOntC);
ontologyRevisionProviderCommand = pOWLOntC;
lastWaitCommand = pOWLOntC;
} else if (confLoadOntologiesSAXParsing) {
CSAXParseOWL2XMLOntologyCommand *pOWLOntC = new CSAXParseOWL2XMLOntologyCommand(ontoIRI,chPaInKBOntComm);
if (lastWaitCommand) {
pOWLOntC->addCommandPrecondition(new CCommandProcessedPrecondition(lastWaitCommand));
}
chPaInKBOntComm->makeToSubCommand(pOWLOntC);
preSynchronizer->delegateCommand(pOWLOntC);
ontologyRevisionProviderCommand = pOWLOntC;
lastWaitCommand = pOWLOntC;
} else {
CReadXMLCommand *readXMLC = new CReadXMLCommand(ontoIRI);
chPaInKBOntComm->makeToSubCommand(readXMLC);
preSynchronizer->delegateCommand(readXMLC);
CParseOWL2XMLOntologyCommand *pOWLOntC = new CParseOWL2XMLOntologyCommand(readXMLC,chPaInKBOntComm);
if (lastWaitCommand) {
pOWLOntC->addCommandPrecondition(new CCommandProcessedPrecondition(lastWaitCommand));
}
chPaInKBOntComm->makeToSubCommand(pOWLOntC);
preSynchronizer->delegateCommand(pOWLOntC);
ontologyRevisionProviderCommand = pOWLOntC;
lastWaitCommand = pOWLOntC;
}
}
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(chPaInKBOntComm->getKnowledgeBaseName(),ontologyRevisionProviderCommand);
inKBRevUpC->addCommandPrecondition(new CCommandProcessedPrecondition(lastWaitCommand));
chPaInKBOntComm->makeToSubCommand(inKBRevUpC);
preSynchronizer->delegateCommand(inKBRevUpC);
CPrepareKnowledgeBaseForRevisionCommand* prepareKBC = new CPrepareKnowledgeBaseForRevisionCommand(ontologyRevisionProviderCommand);
chPaInKBOntComm->makeToSubCommand(prepareKBC);
prepareKBC->addCommandPrecondition(new CCommandProcessedPrecondition(inKBRevUpC));
preSynchronizer->delegateCommand(prepareKBC);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Ontology revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CLoadKnowledgeBaseStartDownloadCommand* loadKBStartDownload = (CLoadKnowledgeBaseStartDownloadCommand *)command;
CLoadKnowledgeBaseFinishDownloadCommand* finishCommand = loadKBStartDownload->getFinishCommand();
QByteArray* destinationDataArray = new QByteArray();
CQtHttpTransactionManager* transMan = getNetworkTransactionManager();
CHttpRequest* request = transMan->createRequest(loadKBStartDownload->getDownloadIRIString());
CHttpResponse* response = transMan->getResponse(request);
transMan->callbackResponseData(response,destinationDataArray,finishCommand);
finishCommand->setTemporaryDataPointer(destinationDataArray);
finishCommand->setResponse(response);
LOG(INFO,getLogDomain(),logTr("Downloading '%1'.").arg(loadKBStartDownload->getDownloadIRIString()),this);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CLoadKnowledgeBaseFinishDownloadCommand* loadKBFinishDownload = (CLoadKnowledgeBaseFinishDownloadCommand *)command;
CQtHttpTransactionManager* transMan = getNetworkTransactionManager();
CHttpResponse* response = loadKBFinishDownload->getResponse();
QString iriString = loadKBFinishDownload->getDownloadString();
QByteArray* dataArray = loadKBFinishDownload->getTemporaryDataPointer(true);
if (!transMan->hasFinishedSucecssfully(response)) {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Download of '%1' has failed.").arg(iriString),&commandRecordRouter);
} else {
cint64 downloadSize = dataArray->count();
QString unitString = "Bytes";
if (downloadSize > 10000) {
downloadSize /= 1024;
unitString = "KBytes";
}
if (downloadSize > 10000) {
downloadSize /= 1024;
unitString = "MBytes";
}
LOG(INFO,getLogDomain(),logTr("Successfully downloaded '%1', received %2 %3.").arg(iriString).arg(downloadSize).arg(unitString),this);
//CUnspecifiedMessageInformationRecord::makeRecord(QString("Successfully downloaded '%1', received %2 MBytes.").arg(iriString).arg(downloadSize),&commandRecordRouter);
QIODevice* writeDevice = loadKBFinishDownload->getWriteIODevice();
if (writeDevice) {
if (writeDevice->open(QIODevice::WriteOnly)) {
writeDevice->write(*dataArray);
writeDevice->close();
}
}
}
delete dataArray;
transMan->releaseResponse(response);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CLoadKnowledgeBaseOWLAutoOntologyCommand *loadKBOWLAutoOnto = (CLoadKnowledgeBaseOWLAutoOntologyCommand *)command;
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(loadKBOWLAutoOnto->getKnowledgeBaseName());
loadKBOWLAutoOnto->makeToSubCommand(crKBRevUpC);
preSynchronizer->delegateCommand(crKBRevUpC);
QMap ontoIRIMapping = loadKBOWLAutoOnto->getOntologieIRIMappings();
QStringList ontoIRIStringList(loadKBOWLAutoOnto->getLoadIRIStrings());
createDownloadParseCommands(loadKBOWLAutoOnto->getKnowledgeBaseName(),loadKBOWLAutoOnto,crKBRevUpC,ontoIRIMapping,ontoIRIStringList,commandRecordRouter);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CImportKnowledgeBaseOWLAutoOntologyCommand *importKBOWLAutoOnto = (CImportKnowledgeBaseOWLAutoOntologyCommand *)command;
QMap ontoIRIMapping = importKBOWLAutoOnto->getOntologieIRIMappings();
QStringList ontoIRIStringList(importKBOWLAutoOnto->getLoadIRIStrings());
createDownloadParseCommands(importKBOWLAutoOnto->getKnowledgeBaseName(),importKBOWLAutoOnto,importKBOWLAutoOnto,ontoIRIMapping,ontoIRIStringList,commandRecordRouter);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CChooseParseInstallKnowledgeBaseOWLAutoOntologyCommand* chPaInKBOntComm = (CChooseParseInstallKnowledgeBaseOWLAutoOntologyCommand *)command;
CConfigData* data = nullptr;
COntologyRevision* ontoRev = chPaInKBOntComm->getOntologyRevision();
if (ontoRev) {
COntologyConfigurationExtension* ontoConfExt = chPaInKBOntComm->getOntologyRevision()->getOntologyConfiguration();
COntologyConfigurationExtension *ontConfig = ontoRev->getOntologyConfiguration();
CConcreteOntology* ont = ontoRev->getOntology();
QList importOntologiesList;
QList loadDataList(chPaInKBOntComm->getLoadDataList());
bool allParsingSucceeded = true;
for (QList::const_iterator loadDataIt = loadDataList.constBegin(), loadDataItEnd = loadDataList.constEnd(); loadDataIt != loadDataItEnd; ++loadDataIt) {
CLoadKnowledgeBaseData* loadData = *loadDataIt;
QIODevice* device = loadData->getLoadDevice();
QString ontoIRI = loadData->getOriginalDataName();
QString resolvedIRI = loadData->getResolvedDataName();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
QStringList parserErrorList;
bool parsingSucceeded = parseOntology(device, ontoIRI, resolvedIRI, ont, ontConfig, importOntologiesList, parserErrorList, commandRecordRouter);
if (!parsingSucceeded) {
allParsingSucceeded = false;
parserErrorList.append(QString("All parsers failed for '%1'.").arg(resolvedIRI));
for (QStringList::const_iterator errorIt = parserErrorList.constBegin(), errorItEnd = parserErrorList.constEnd(); errorIt != errorItEnd; ++errorIt) {
CUnspecifiedMessageErrorRecord::makeRecord(*errorIt,&commandRecordRouter);
}
} else {
ont->getLoadData()->addLoadedOntologyIRI(ontoIRI, resolvedIRI);
}
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
QString ontologieCountString = "Ontology";
if (loadDataList.count() > 1) {
ontologieCountString = "Ontologies";
}
LOG(INFO,getLogDomain(),logTr("%1 parsed in %2 ms.").arg(ontologieCountString).arg(parsingMilliSeconds),this);
}
}
if (importOntologiesList.isEmpty()) {
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(chPaInKBOntComm->getKnowledgeBaseName(),chPaInKBOntComm);
chPaInKBOntComm->makeToSubCommand(inKBRevUpC);
preSynchronizer->delegateCommand(inKBRevUpC);
CPrepareKnowledgeBaseForRevisionCommand* prepareKBC = new CPrepareKnowledgeBaseForRevisionCommand(chPaInKBOntComm);
chPaInKBOntComm->makeToSubCommand(prepareKBC);
prepareKBC->addCommandPrecondition(new CCommandProcessedPrecondition(inKBRevUpC));
preSynchronizer->delegateCommand(prepareKBC);
} else {
if (importOntologiesList.count() > 1) {
LOG(INFO,getLogDomain(),logTr("Scheduling the import of %1 ontologies.").arg(importOntologiesList.count()),this);
} else {
LOG(INFO,getLogDomain(),logTr("Scheduling the import of '%1'.").arg(importOntologiesList.first()),this);
}
CImportKnowledgeBaseOWLAutoOntologyCommand* importKBsCommand = new CImportKnowledgeBaseOWLAutoOntologyCommand(chPaInKBOntComm->getKnowledgeBaseName(),importOntologiesList,chPaInKBOntComm->getOntologieIRIMappings(),chPaInKBOntComm);
chPaInKBOntComm->makeToSubCommand(importKBsCommand);
preSynchronizer->delegateCommand(importKBsCommand);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Ontology revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CSaveOWL2XMLExtractedKnowledgeBaseCommand *saveKBC = (CSaveOWL2XMLExtractedKnowledgeBaseCommand *)command;
CGetCurrentKnowledgeBaseRevisionCommand *gcKBRevUpC = new CGetCurrentKnowledgeBaseRevisionCommand(saveKBC->getKnowledgeBaseName());
saveKBC->makeToSubCommand(gcKBRevUpC);
preSynchronizer->delegateCommand(gcKBRevUpC);
COntologyOWL2QtXMLRenderer* renderer = new COntologyOWL2QtXMLRenderer();
CExtractToldExpressionsOntologyCommand *extTEOC = new CExtractToldExpressionsOntologyCommand(renderer,gcKBRevUpC,saveKBC->getExtractEntitiyList());
saveKBC->makeToSubCommand(extTEOC);
preSynchronizer->delegateCommand(extTEOC);
CWriteOWL2XMLOntologyCommand *writeOntC = new CWriteOWL2XMLOntologyCommand(renderer,saveKBC->getSaveIRIString());
writeOntC->addCommandPrecondition(new CCommandProcessedPrecondition(extTEOC));
saveKBC->makeToSubCommand(writeOntC);
preSynchronizer->delegateCommand(writeOntC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(command->getRecorder(),getLogDomain(),command);
CSaveOWLlinkOWL2XMLSatisfiableTestExtractedKnowledgeBaseCommand *saveKBC = (CSaveOWLlinkOWL2XMLSatisfiableTestExtractedKnowledgeBaseCommand *)command;
CGetCurrentKnowledgeBaseRevisionCommand *gcKBRevUpC = new CGetCurrentKnowledgeBaseRevisionCommand(saveKBC->getKnowledgeBaseName());
saveKBC->makeToSubCommand(gcKBRevUpC);
preSynchronizer->delegateCommand(gcKBRevUpC);
COntologyOWL2QtXMLRenderer* renderer = new COntologyOWL2QtXMLRenderer();
CExtractToldExpressionsOntologyCommand *extTEOC = new CExtractToldExpressionsOntologyCommand(renderer,gcKBRevUpC,saveKBC->getExtractEntitiyList());
saveKBC->makeToSubCommand(extTEOC);
preSynchronizer->delegateCommand(extTEOC);
CWriteOWLlinkOWL2XMLSatisfiableTestCommand *writeOntC = new CWriteOWLlinkOWL2XMLSatisfiableTestCommand(renderer,saveKBC->getSaveIRIString(),saveKBC->getExtractEntitiyList(),saveKBC->getTestKBName());
writeOntC->addCommandPrecondition(new CCommandProcessedPrecondition(extTEOC));
saveKBC->makeToSubCommand(writeOntC);
preSynchronizer->delegateCommand(writeOntC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
COntologyExtractionManager exMan;
exMan.realizeCommand(command);
} else if (dynamic_cast(command)) {
CRenderWriteManager writeMan;
writeMan.realizeCommand(command);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CReadTextCommand* readTextC = (CReadTextCommand *)command;
QString iriString = readTextC->getIRIString();
QFile file(iriString);
if (file.open(QIODevice::ReadOnly)) {
CUnspecifiedMessageInformationRecord::makeRecord(QString("Read file '%1'.").arg(iriString),&commandRecordRouter);
readTextC->setReadText(file.readAll());
file.close();
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("File '%1' not found.").arg(iriString),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CReadXMLCommand* readXMLC = (CReadXMLCommand *)command;
QString iriString = readXMLC->getIRIString();
if (iriString.startsWith("file:")) {
iriString.replace("file:","");
}
while (!QFile::exists(iriString) && iriString.startsWith("/")) {
iriString = iriString.remove(0,1);
}
QFile file(iriString);
if (file.open(QIODevice::ReadOnly)) {
CUnspecifiedMessageInformationRecord::makeRecord(QString("Read file '%1'.").arg(iriString),&commandRecordRouter);
QDomDocument document;
QString errorMessage;
int errorLine = 0, errorColumn = 0;
if (document.setContent(file.readAll(),true,&errorMessage,&errorLine,&errorColumn)) {
readXMLC->setReadXMLNode(document.documentElement());
}
file.close();
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("File '%1' not found.").arg(iriString),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseKRSSTestConceptOntologyCommand *krssTCOntC = (CParseKRSSTestConceptOntologyCommand *)command;
COntologyRevision *ontRev = krssTCOntC->getOntologyRevision();
if (ontRev) {
CConcreteOntology *ont = ontRev->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ont);
CKRSSOntologyParser *krssParser = new CKRSSOntologyParser(builder,krssTCOntC->getTestConceptNameString(),&commandRecordRouter);
QString krssText = krssTCOntC->getOntologyKRSSText();
builder->initializeBuilding();
krssParser->parseOntologyText(krssText);
builder->completeBuilding();
delete builder;
delete krssParser;
//COntologyConfigDependedPreProcesser *ontConDepPreProcessor = new COntologyConfigDependedPreProcesser(commandRecordRouter);
//ontConDepPreProcessor->preprocess(ont,ontConfig);
//delete ontConDepPreProcessor;
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO,getLogDomain(),logTr("Ontology parsed in %1 ms.").arg(parsingMilliSeconds),this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseSPARQLQueryCommand *pSPARQLQueryC = (CParseSPARQLQueryCommand*)command;
COntologyRevision *ontRev = pSPARQLQueryC->getOntologyRevision();
if (ontRev) {
CConcreteOntology* onto = ontRev->getOntology();
CConcreteOntology* baseOnt = ontRev->getPreviousOntologyRevision()->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
bool confRedlandRasqalSPARQLQueryProcessing = CConfigDataReader::readConfigBoolean(ontConfig, "Konclude.Answering.RedlandRasqalSPARQLQueryProcessing", true);
QStringList queryStringList = pSPARQLQueryC->getSPARQLQueryTextList();
QList queryList;
#ifdef KONCLUDE_REDLAND_INTEGRATION
if (confRedlandRasqalSPARQLQueryProcessing) {
QString queryName = QString("%1-Rasqal-Query-Nr-%2").arg(mQueryPrefix).arg(++mQueryNumber);
CSPARQLRedlandRasqalQueryParser* sparqlQueryParser = new CSPARQLRedlandRasqalQueryParser(baseOnt, onto, ontConfig);
sparqlQueryParser->parseQueryTextList(queryStringList, queryName);
CQuery* query = sparqlQueryParser->getQuery();
if (query) {
queryList.append(query);
}
delete sparqlQueryParser;
} else {
#endif
CConcreteOntologyUpdateSeparateHashingCollectorBuilder *builder = new CConcreteOntologyUpdateSeparateHashingCollectorBuilder(onto);
CConcreteOntologyQueryExtendedBuilder* queryBuilderGen = new CConcreteOntologyQueryExtendedBuilder(baseOnt, onto, ontConfig, builder);
CSPARQLQueryParser* sparqlQueryParser = sparqlQueryParser = new CSPARQLSimpleQueryParser(queryBuilderGen, builder, onto);
builder->initializeBuilding();
sparqlQueryParser->parseQueryTextList(queryStringList);
builder->completeBuilding();
queryList = queryBuilderGen->generateQuerys();
delete builder;
delete queryBuilderGen;
delete sparqlQueryParser;
#ifdef KONCLUDE_REDLAND_INTEGRATION
}
#endif
if (queryList.isEmpty()) {
LOG(WARN, getLogDomain(), logTr("SPARQL query not found or not parsable from request."), this);
}
pSPARQLQueryC->setQueryList(queryList);
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO, getLogDomain(), logTr("SPARQL Query parsed in %1 ms.").arg(parsingMilliSeconds), this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."), &commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CGetQueryDependentKnowledgeBaseRevisionUpdatesCommand *gQDKBRUC = (CGetQueryDependentKnowledgeBaseRevisionUpdatesCommand*)command;
QList queryList = gQDKBRUC->getQueryList();
for (CQuery* query : queryList) {
#ifdef KONCLUDE_REDLAND_INTEGRATION
CRedlandRasqalBGPsCompositionQuery* rrcq = dynamic_cast(query);
if (rrcq) {
QList kbProviderList;
for (QString kbName : *rrcq->getDependentKnowledgeBaseNames()) {
CCreateKnowledgeBaseRevisionUpdateCommand* revUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(kbName, false, false, gQDKBRUC);
kbProviderList.append(revUpC);
preSynchronizer->delegateCommand(revUpC);
rrcq->setDependentKnowledgeBaseRevision(kbName, nullptr, nullptr);
}
CInstallQueryDependentKnowledgeBaseRevisionUpdatesCommand* insKBRUC = new CInstallQueryDependentKnowledgeBaseRevisionUpdatesCommand(kbProviderList, query, gQDKBRUC);
preSynchronizer->delegateCommand(insKBRUC);
}
#endif // KONCLUDE_REDLAND_INTEGRATION
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CInstallQueryDependentKnowledgeBaseRevisionUpdatesCommand *iQDKBRUC = (CInstallQueryDependentKnowledgeBaseRevisionUpdatesCommand*)command;
CQuery* query = iQDKBRUC->getQuery();
#ifdef KONCLUDE_REDLAND_INTEGRATION
CRedlandRasqalBGPsCompositionQuery* rrcq = dynamic_cast(query);
if (rrcq) {
QList* kbRCPList = iQDKBRUC->getDependentKnowledgeBasesProviderCommandList();
for (CKnowledgeBaseRevisionCommandProvider* kbRCP : *kbRCPList) {
COntologyRevision* ontRev = kbRCP->getOntologyRevision();
if (ontRev) {
CConcreteOntology* onto = ontRev->getOntology();
CConcreteOntology* baseOnt = ontRev->getPreviousOntologyRevision()->getOntology();
rrcq->setDependentKnowledgeBaseRevision(ontRev->getOntology()->getOntologyName(), baseOnt, onto);
}
}
}
#endif // KONCLUDE_REDLAND_INTEGRATION
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseProcessSPARQLUpdateTextCommand *pSPARQLUpdateC = (CParseProcessSPARQLUpdateTextCommand*)command;
COntologyRevision *ontRev = pSPARQLUpdateC->getOntologyRevision();
if (ontRev) {
CConcreteOntology* onto = ontRev->getOntology();
CConcreteOntology* baseOnt = ontRev->getPreviousOntologyRevision()->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(onto);
CSPARQLSimpleUpdateParser* sparqlUpdateParser = new CSPARQLSimpleUpdateParser(builder, onto);
builder->initializeBuilding();
if (pSPARQLUpdateC->isUpdateTextSplitted()) {
QStringList updateStringList = pSPARQLUpdateC->getSPARQLUpdateTextList();
sparqlUpdateParser->parseUpdateTextList(updateStringList);
} else {
QString updateString = pSPARQLUpdateC->getSPARQLUpdateText();
sparqlUpdateParser->parseUpdateText(updateString);
}
builder->completeBuilding();
delete builder;
delete sparqlUpdateParser;
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO, getLogDomain(), logTr("SPARQL Update parsed in %1 ms.").arg(parsingMilliSeconds), this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."), &commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseProcessSPARQLManageTextCommand *pSPARQLUpdateC = (CParseProcessSPARQLManageTextCommand*)command;
CSPARQLSimpleManagementParser managementParser(preSynchronizer, pSPARQLUpdateC->getKnowlegeBaseString(), pSPARQLUpdateC);
managementParser.parseUpdateTextList(pSPARQLUpdateC->getSPARQLUpdateTextList());
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CCalculateQueriesCommand *calcQueriesC = (CCalculateQueriesCommand*)command;
for (CQuery* query : calcQueriesC->getQueryList()) {
if (query) {
CCalculateQueryCommand* calcQueryC = new CCalculateQueryCommand(query, calcQueriesC);
preSynchronizer->delegateCommand(calcQueryC);
}
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseProcessSPARQLTextCommand *pSPARQLQueryC = (CParseProcessSPARQLTextCommand *)command;
CConfiguration* configuration = getConfiguration();
bool ignoreFromClause = CConfigDataReader::readConfigBoolean(configuration, "Konclude.SPARQL.AlwaysResolveToDefault");
bool waitForQueriesForNextUpdates = CConfigDataReader::readConfigBoolean(configuration, "Konclude.SPARQL.WaitQueryCalculationBeforeContinuingUpdateProcessing");
CSPARQLKnowledgeBaseSplittingOperationParser* sparqlSplittingParser = new CSPARQLKnowledgeBaseSplittingOperationParser();
const QString& queryString = pSPARQLQueryC->getSPARQLQueryText();
sparqlSplittingParser->parseQueryText(queryString);
bool foundSparqlOperation = false;
for (QString kbString : sparqlSplittingParser->getKnowlegdeBaseList()) {
QList queryStringList = sparqlSplittingParser->getKnowlegdeBaseSPARQLOperationList(kbString);
if (ignoreFromClause || kbString.trimmed().isEmpty()) {
kbString = CConfigDataReader::readConfigString(configuration, "Konclude.SPARQL.DefaultResolvingOntology");
}
CCreateKnowledgeBaseRevisionUpdateCommand* lastGetCurrKBRevC = nullptr;
CParseSPARQLQueryCommand* lastSparqlQC = nullptr;
CCalculateQueriesCommand* lastCalcQC = nullptr;
CCommand* lastNonQueryC = nullptr;
QList commandList;
while (!queryStringList.isEmpty()) {
CSPARQLKnowledgeBaseSplittingOperationData* splitKBOperationData(queryStringList.takeLast());
QStringList textList = splitKBOperationData->getOperationPartStringList();
CSPARQLKnowledgeBaseSplittingOperationData::SPARQL_COMMAND_TYPE operationType = splitKBOperationData->getOperationType();
if (operationType == CSPARQLKnowledgeBaseSplittingOperationData::SPARQL_QUERY) {
foundSparqlOperation = true;
if (!lastGetCurrKBRevC) {
lastGetCurrKBRevC = new CCreateKnowledgeBaseRevisionUpdateCommand(kbString, pSPARQLQueryC);
if (lastNonQueryC) {
lastGetCurrKBRevC->addCommandPrecondition(new CCommandProcessedPrecondition(lastNonQueryC));
}
lastNonQueryC = lastGetCurrKBRevC;
commandList.append(lastGetCurrKBRevC);
lastNonQueryC = lastGetCurrKBRevC;
}
if (!lastSparqlQC) {
lastSparqlQC = new CParseSPARQLQueryCommand(textList, lastGetCurrKBRevC, pSPARQLQueryC);
commandList.append(lastSparqlQC);
CGetQueryDependentKnowledgeBaseRevisionUpdatesCommand* getDepKBRevUpdateC = new CGetQueryDependentKnowledgeBaseRevisionUpdatesCommand(lastSparqlQC, pSPARQLQueryC);
commandList.append(getDepKBRevUpdateC);
lastNonQueryC = getDepKBRevUpdateC;
CCalculateQueriesCommand* calcQueriesC = new CCalculateQueriesCommand(getDepKBRevUpdateC, pSPARQLQueryC);
commandList.append(calcQueriesC);
lastCalcQC = calcQueriesC;
if (waitForQueriesForNextUpdates) {
// may be necessary for avoiding concurrent access to redland rdf nodes/triples (if persistence is enabled/used)
lastNonQueryC = calcQueriesC;
}
lastSparqlQC = nullptr;
}
} else if (operationType == CSPARQLKnowledgeBaseSplittingOperationData::SPARQL_UPDATE_MANAGE) {
foundSparqlOperation = true;
lastGetCurrKBRevC = nullptr;
// some SPARQL update commands may have dependencies to several graphs/knowledge bases, e.g., COPY, i.e., we need a more sophisticated mechanism at some point
CParseProcessSPARQLManageTextCommand* ppSPARQLUTC = new CParseProcessSPARQLManageTextCommand(textList, kbString, pSPARQLQueryC);
commandList.append(ppSPARQLUTC);
if (lastNonQueryC) {
ppSPARQLUTC->addCommandPrecondition(new CCommandProcessedPrecondition(lastNonQueryC));
}
lastNonQueryC = ppSPARQLUTC;
} else if (operationType == CSPARQLKnowledgeBaseSplittingOperationData::SPARQL_UPDATE_MODIFY) {
foundSparqlOperation = true;
lastGetCurrKBRevC = nullptr;
lastSparqlQC = nullptr;
CCreateKnowledgeBaseRevisionUpdateCommand* getCurrKBRevC = new CCreateKnowledgeBaseRevisionUpdateCommand(kbString, true, pSPARQLQueryC);
if (lastNonQueryC) {
getCurrKBRevC->addCommandPrecondition(new CCommandProcessedPrecondition(lastNonQueryC));
}
commandList.append(getCurrKBRevC);
CParseProcessSPARQLUpdateTextCommand* ppSPARQLUTC = new CParseProcessSPARQLUpdateTextCommand(textList, getCurrKBRevC, pSPARQLQueryC);
commandList.append(ppSPARQLUTC);
CInstallKnowledgeBaseRevisionUpdateCommand *inKBRevUpC = new CInstallKnowledgeBaseRevisionUpdateCommand(kbString, ppSPARQLUTC, pSPARQLQueryC);
inKBRevUpC->addCommandPrecondition(new CCommandProcessedPrecondition(ppSPARQLUTC));
commandList.append(inKBRevUpC);
lastNonQueryC = inKBRevUpC;
}
}
for (CCommand* command : commandList) {
preSynchronizer->delegateCommand(command);
}
}
delete sparqlSplittingParser;
if (!foundSparqlOperation) {
LOG(WARN, getLogDomain(), logTr("No SPARQL command found in request."), this);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseOWL2XMLOntologyCommand *pOWLOntC = (CParseOWL2XMLOntologyCommand *)command;
COntologyRevision *ontRev = pOWLOntC->getOntologyRevision();
if (ontRev) {
CConcreteOntology *ont = ontRev->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ont);
COWL2QtXMLOntologyParser *owl2Parser = new COWL2QtXMLOntologyParser(builder,&commandRecordRouter);
QDomElement domEl = pOWLOntC->getOntologyNode();
builder->initializeBuilding();
owl2Parser->parseOntologyNode(&domEl);
builder->completeBuilding();
delete builder;
delete owl2Parser;
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO,getLogDomain(),logTr("Ontology parsed in %1 ms.").arg(parsingMilliSeconds),this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CSAXParseOWL2XMLOntologyCommand *pOWLOntC = (CSAXParseOWL2XMLOntologyCommand *)command;
QString iriString = pOWLOntC->getSourceString();
if (iriString.startsWith("file:")) {
iriString.replace("file:","");
}
while (!QFile::exists(iriString) && iriString.startsWith("/")) {
iriString = iriString.remove(0,1);
}
COntologyRevision *ontRev = pOWLOntC->getOntologyRevision();
if (ontRev) {
CConcreteOntology *ont = ontRev->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ont);
COWL2QtXMLOntologySAXParser *owl2Parser = new COWL2QtXMLOntologySAXParser(builder);
builder->initializeBuilding();
LOG(INFO,getLogDomain(),logTr("Starting SAX-based ontology parsing for '%1'.").arg(iriString),this);
owl2Parser->parseOntology(iriString);
LOG(INFO,getLogDomain(),logTr("Finished SAX-based ontology parsing for '%1'.").arg(iriString),this);
builder->completeBuilding();
delete builder;
delete owl2Parser;
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO,getLogDomain(),logTr("Ontology parsed in %1 ms.").arg(parsingMilliSeconds),this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CStreamParseOWL2XMLOntologyCommand *pOWLOntC = (CStreamParseOWL2XMLOntologyCommand *)command;
QString iriString = pOWLOntC->getSourceString();
if (iriString.startsWith("file:")) {
iriString.replace("file:","");
}
while (!QFile::exists(iriString) && iriString.startsWith("/")) {
iriString = iriString.remove(0,1);
}
COntologyRevision *ontRev = pOWLOntC->getOntologyRevision();
if (ontRev) {
CConcreteOntology *ont = ontRev->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ont);
bool enforceUTF8ConvertingParsing = CConfigDataReader::readConfigBoolean(ontConfig,"Konclude.Parser.UTF8CompatibilityEnforcedXMLStreamParsing");
COWL2QtXMLOntologyStreamParser *owl2Parser = nullptr;
if (enforceUTF8ConvertingParsing) {
owl2Parser = new COWL2QtXMLOntologyStableStreamParser(builder);
} else {
owl2Parser = new COWL2QtXMLOntologyStreamParser(builder);
}
builder->initializeBuilding();
LOG(INFO,getLogDomain(),logTr("Starting stream-based OWL2/XML ontology parsing for '%1'.").arg(iriString),this);
if (owl2Parser->parseOntology(iriString)) {
LOG(INFO,getLogDomain(),logTr("Finished stream-based OWL2/XML ontology parsing for '%1'.").arg(iriString),this);
builder->completeBuilding();
} else {
if (owl2Parser->hasError()) {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Stream-based OWL2/XML ontology parsing error: '%1'.").arg(owl2Parser->getErrorString()),&commandRecordRouter);
}
CUnspecifiedMessageErrorRecord::makeRecord(QString("Stream-based OWL2/XML ontology parsing for '%1' failed.").arg(iriString),&commandRecordRouter);
}
delete builder;
delete owl2Parser;
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO,getLogDomain(),logTr("Ontology parsed in %1 ms.").arg(parsingMilliSeconds),this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CStreamParseOWL2FunctionalOntologyCommand *pOWLOntC = (CStreamParseOWL2FunctionalOntologyCommand *)command;
QString iriString = pOWLOntC->getSourceString();
if (iriString.startsWith("file:")) {
iriString.replace("file:","");
}
while (!QFile::exists(iriString) && iriString.startsWith("/")) {
iriString = iriString.remove(0,1);
}
COntologyRevision *ontRev = pOWLOntC->getOntologyRevision();
if (ontRev) {
CConcreteOntology *ont = ontRev->getOntology();
QTime parsingTime;
if (mConfLogProcessingTimes) {
parsingTime.start();
}
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntologyUpdateCollectorBuilder *builder = new CConcreteOntologyUpdateCollectorBuilder(ont);
COWL2FunctionalJAVACCOntologyStreamParser *owl2Parser = new COWL2FunctionalJAVACCOntologyStreamParser(builder);
builder->initializeBuilding();
LOG(INFO,getLogDomain(),logTr("Starting stream-based OWL2/Functional ontology parsing for '%1'.").arg(iriString),this);
if (owl2Parser->parseOntology(iriString)) {
LOG(INFO,getLogDomain(),logTr("Finished stream-based OWL2/Functional ontology parsing for '%1'.").arg(iriString),this);
builder->completeBuilding();
} else {
if (owl2Parser->hasError()) {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Stream-based OWL2/Functional ontology parsing error: '%1'.").arg(owl2Parser->getErrorString()),&commandRecordRouter);
}
CUnspecifiedMessageErrorRecord::makeRecord(QString("Stream-based OWL2/Functional ontology parsing for '%1' failed.").arg(iriString),&commandRecordRouter);
}
delete builder;
delete owl2Parser;
if (mConfLogProcessingTimes) {
cint64 parsingMilliSeconds = parsingTime.elapsed();
LOG(INFO,getLogDomain(),logTr("Ontology parsed in %1 ms.").arg(parsingMilliSeconds),this);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Knowledge base revision not available."),&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CProcessQueryOWL2XMLNodeCommand *pqOWLC = (CProcessQueryOWL2XMLNodeCommand *)command;
CBuildQueryCommand *buildQC = pqOWLC->getBuildQueryCommand();
CKnowledgeBaseRevisionCommandProvider* cKBRevCP = nullptr;
bool complexQuery = pqOWLC->isComplexQuery();
if (complexQuery) {
CCreateKnowledgeBaseRevisionUpdateCommand *crKBRevUpC = new CCreateKnowledgeBaseRevisionUpdateCommand(pqOWLC->getKnowledgeBaseName());
buildQC->makeToSubCommand(crKBRevUpC);
cKBRevCP = crKBRevUpC;
} else {
CGetCurrentKnowledgeBaseRevisionCommand *crKBRevGet = new CGetCurrentKnowledgeBaseRevisionCommand(pqOWLC->getKnowledgeBaseName());
buildQC->makeToSubCommand(crKBRevGet);
cKBRevCP = crKBRevGet;
}
CParseOWL2XMLQueryCommand *pOWLQC = new CParseOWL2XMLQueryCommand(pqOWLC->getQueryNode(),cKBRevCP);
buildQC->makeToSubCommand(pOWLQC);
pOWLQC->setQueryComplexity(complexQuery);
CPrepareKnowledgeBaseForQueryCommand* prepKBForQueryC = new CPrepareKnowledgeBaseForQueryCommand(cKBRevCP,pOWLQC);
buildQC->makeToSubCommand(prepKBForQueryC);
prepKBForQueryC->addCommandPrecondition(new CCommandProcessedPrecondition(pOWLQC));
CGenerateQueryCommand* genQC = new CGenerateQueryCommand(pOWLQC);
buildQC->makeToSubCommand(genQC);
buildQC->setQueryCommandProvider(genQC);
genQC->addCommandPrecondition(new CCommandProcessedPrecondition(prepKBForQueryC));
CCalculateQueryCommand *calcQC = pqOWLC->getCalculateQueryCommand();
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command, this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CPrepareKnowledgeBaseForQueryCommand *pKBFQC = (CPrepareKnowledgeBaseForQueryCommand *)command;
CQueryGenerator* queryGenerator = pKBFQC->getQueryGenerator();
if (queryGenerator->requiresPreprocessedOntology()) {
CPreprocessKnowledgeBaseRequirementsForQueryCommand* prepKBForQueryC = new CPreprocessKnowledgeBaseRequirementsForQueryCommand(pKBFQC->getOntologyRevisionProvider());
pKBFQC->makeToSubCommand(prepKBForQueryC);
preSynchronizer->delegateCommand(prepKBForQueryC);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CProcessClassNameSatisfiableQueryCommand *pqOWLC = (CProcessClassNameSatisfiableQueryCommand *)command;
CBuildQueryCommand *buildQC = pqOWLC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,pqOWLC);
pqOWLC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = pqOWLC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,pqOWLC);
pqOWLC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *crKBRevGet = new CGetCurrentKnowledgeBaseRevisionCommand(pqOWLC->getKnowledgeBaseName());
buildQC->makeToSubCommand(crKBRevGet);
CPreprocessKnowledgeBaseRequirementsForQueryCommand* prepKBForQueryC = new CPreprocessKnowledgeBaseRequirementsForQueryCommand(crKBRevGet);
buildQC->makeToSubCommand(prepKBForQueryC);
prepKBForQueryC->addCommandPrecondition(new CCommandProcessedPrecondition(crKBRevGet));
CConstructClassSatisfiableQueryCommand *pOWLQC = new CConstructClassSatisfiableQueryCommand(pqOWLC->getClassName(),crKBRevGet);
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
pOWLQC->addCommandPrecondition(new CCommandProcessedPrecondition(prepKBForQueryC));
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CLinker *subComIt = command->getSubCommandLinker();
while (subComIt) {
CCommand *supCommand = subComIt->getData();
preSynchronizer->delegateCommand(supCommand);
subComIt = subComIt->getNext();
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CParseTestsuiteXMLNodeCommand *parseTestsuiteComm = (CParseTestsuiteXMLNodeCommand *)command;
CXMLTestsuiteCommandParser *testsuiteParser = new CXMLTestsuiteCommandParser();
testsuiteParser->realizeCommand(parseTestsuiteComm,preSynchronizer);
delete testsuiteParser;
} else if (dynamic_cast(command)) {
CTestTestsuiteCommand *testTestsuiteComm = (CTestTestsuiteCommand *)command;
CConfiguration *config = getConfiguration();
CReasonerTestsuiteTester *testsuiteTester = new CReasonerTestsuiteTester(config);
testsuiteTester->realizeTestCommand(testTestsuiteComm);
delete testsuiteTester;
} else if (dynamic_cast(command)) {
CEvaluateTestsuiteCommand* evalTestsuiteComm = (CEvaluateTestsuiteCommand*)command;
CConfiguration *config = getConfiguration();
CReasonerEvaluationManagerThread* evalManager = new CReasonerEvaluationManagerThread(config);;
evalManager->realizeEvaluationCommand(evalTestsuiteComm);
evalManager->waitSynchronization();
delete evalManager;
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CWriteFunctionalSubClassHierarchyQueryCommand *wFSCHC = (CWriteFunctionalSubClassHierarchyQueryCommand *)command;
CBuildQueryCommand *buildQC = wFSCHC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,wFSCHC);
wFSCHC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = wFSCHC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,wFSCHC);
wFSCHC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(wFSCHC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructWriteFunctionalSubClassHirarchyQueryCommand *pOWLQC = new CConstructWriteFunctionalSubClassHirarchyQueryCommand(getCKBRC,wFSCHC->getOutputFileString());
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CWriteCustomQueryCommand *wCQC = (CWriteCustomQueryCommand *)command;
CBuildQueryCommand *buildQC = wCQC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,wCQC);
wCQC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = wCQC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,wCQC);
wCQC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(wCQC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructWriteCustomQueryCommand *pOWLQC = new CConstructWriteCustomQueryCommand(getCKBRC,wCQC->getWriteQueryType(),wCQC->getWriteQuerySerializer(),wCQC->getEntityRestrictionString());
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CClassifyQueryCommand* cqC = (CClassifyQueryCommand*)command;
CBuildQueryCommand *buildQC = cqC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,cqC);
cqC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = cqC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,cqC);
cqC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(cqC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructClassifyQueryCommand *pOWLQC = new CConstructClassifyQueryCommand(getCKBRC);
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CRealizeQueryCommand* rqC = (CRealizeQueryCommand*)command;
CBuildQueryCommand *buildQC = rqC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,rqC);
rqC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = rqC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,rqC);
rqC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(rqC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructRealizeQueryCommand *pOWLQC = new CConstructRealizeQueryCommand(getCKBRC);
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CGetKnowledgeBaseEntitiesCommand* gKBEC = (CGetKnowledgeBaseEntitiesCommand*)command;
if (!gKBEC->getExtractedEntityContainer()) {
gKBEC->setExtractedEntityContainer(new CExtractedKnowledgeBaseEntitiesContainer());
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(gKBEC->getKnowledgeBaseName());
gKBEC->makeToSubCommand(getCKBRC);
CPrepareKnowledgeBaseCommand* prepKBC = new CPrepareKnowledgeBaseCommand(getCKBRC);
prepKBC->addCommandPrecondition(new CCommandProcessedPrecondition(getCKBRC));
gKBEC->makeToSubCommand(prepKBC);
COntologyProcessingStepVector* ontProStepVec = COntologyProcessingStepVector::getProcessingStepVectorInstance();
prepKBC->addRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSACTIVECOUNT), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
preSynchronizer->delegateCommand(prepKBC);
CExtractKnowledgeBaseEntitiesCommand *eKBEC = new CExtractKnowledgeBaseEntitiesCommand(gKBEC->getExtractedEntityContainer(),gKBEC->getEntityExtractionSpecification(),getCKBRC);
eKBEC->addCommandPrecondition(new CCommandProcessedPrecondition(prepKBC));
gKBEC->makeToSubCommand(eKBEC);
preSynchronizer->delegateCommand(getCKBRC);
preSynchronizer->delegateCommand(eKBEC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CGetKnowledgeBaseLanguageCommand* gKBLC = (CGetKnowledgeBaseLanguageCommand*)command;
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(gKBLC->getKnowledgeBaseName());
gKBLC->makeToSubCommand(getCKBRC);
CPrepareKnowledgeBaseCommand* prepKBC = new CPrepareKnowledgeBaseCommand(getCKBRC);
prepKBC->addCommandPrecondition(new CCommandProcessedPrecondition(getCKBRC));
gKBLC->makeToSubCommand(prepKBC);
COntologyProcessingStepVector* ontProStepVec = COntologyProcessingStepVector::getProcessingStepVectorInstance();
prepKBC->addRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSPREPROCESS), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
preSynchronizer->delegateCommand(prepKBC);
CExtractKnowledgeBaseLanguageCommand *eKBEC = new CExtractKnowledgeBaseLanguageCommand(gKBLC->getLanguageStringPointer(),getCKBRC);
eKBEC->addCommandPrecondition(new CCommandProcessedPrecondition(prepKBC));
gKBLC->makeToSubCommand(eKBEC);
preSynchronizer->delegateCommand(getCKBRC);
preSynchronizer->delegateCommand(eKBEC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CGetSubClassHierarchyQueryOWL2XMLNodeCommand *gSCHOWLC = (CGetSubClassHierarchyQueryOWL2XMLNodeCommand *)command;
CBuildQueryCommand *buildQC = gSCHOWLC->getBuildQueryCommand();
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(gSCHOWLC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructSubClassHirarchyQueryCommand *pOWLQC = new CConstructSubClassHirarchyQueryCommand(getCKBRC,gSCHOWLC->getQueryNode());
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
CCalculateQueryCommand *calcQC = gSCHOWLC->getCalculateQueryCommand();
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CIsConsistentQueryCommand* iCQC = (CIsConsistentQueryCommand*)command;
CBuildQueryCommand *buildQC = iCQC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,iCQC);
iCQC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = iCQC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,iCQC);
iCQC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(iCQC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructIsConsistentQueryCommand *pOWLQC = new CConstructIsConsistentQueryCommand(getCKBRC);
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CIsTriviallyConsistentQueryCommand* iCQC = (CIsTriviallyConsistentQueryCommand*)command;
CBuildQueryCommand *buildQC = iCQC->getBuildQueryCommand();
if (!buildQC) {
buildQC = new CBuildQueryCommand(0,iCQC);
iCQC->setBuildQueryCommand(buildQC);
}
CCalculateQueryCommand *calcQC = iCQC->getCalculateQueryCommand();
if (!calcQC) {
calcQC = new CCalculateQueryCommand(buildQC,iCQC);
iCQC->setCalculateQueryCommand(calcQC);
}
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(iCQC->getKnowledgeBaseName());
buildQC->makeToSubCommand(getCKBRC);
CConstructIsTriviallyConsistentQueryCommand *pOWLQC = new CConstructIsTriviallyConsistentQueryCommand(getCKBRC);
buildQC->makeToSubCommand(pOWLQC);
buildQC->setQueryCommandProvider(pOWLQC);
preSynchronizer->delegateCommand(buildQC);
preSynchronizer->delegateCommand(calcQC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CKnowledgeBaseProcessCommand* kbPC = (CKnowledgeBaseProcessCommand *)command;
CGetCurrentKnowledgeBaseRevisionCommand *getCKBRC = new CGetCurrentKnowledgeBaseRevisionCommand(kbPC->getKnowledgeBaseName());
kbPC->makeToSubCommand(getCKBRC);
CPrepareKnowledgeBaseCommand* prepKBC = new CPrepareKnowledgeBaseCommand(getCKBRC);
prepKBC->addCommandPrecondition(new CCommandProcessedPrecondition(getCKBRC));
kbPC->makeToSubCommand(prepKBC);
COntologyProcessingStepVector* ontProStepVec = COntologyProcessingStepVector::getProcessingStepVectorInstance();
prepKBC->addRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSPREPROCESS), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
if (dynamic_cast(kbPC) != nullptr) {
prepKBC->addRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSCLASSCLASSIFY), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
if (dynamic_cast(kbPC) != nullptr) {
prepKBC->addRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSCONCEPTREALIZE), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
prepKBC->addRequirement( new COntologyProcessingStepRequirement(ontProStepVec->getProcessingStep(COntologyProcessingStep::OPSSAMEINDIVIDUALSREALIZE), COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, 0, COntologyProcessingStatus::PSSUCESSFULL, 0) );
}
preSynchronizer->delegateCommand(getCKBRC);
preSynchronizer->delegateCommand(prepKBC);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructSubClassHirarchyQueryCommand *cSCHQC = (CConstructSubClassHirarchyQueryCommand *)command;
COntologyRevision *ontRev = cSCHQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
COWLlinkQueryExtensionParser quExtParser;
CSubClassHierarchyQuery *query = new CSubClassHierarchyQuery(ontRev->getOntology(),nullptr,ontConfig);
if (CConfigDataReader::readConfigBoolean(ontConfig,"Konclude.Query.Statistics.CollectStatistics",false)) {
query->setQueryStatistics(new CQueryStatisticsCollectionStrings());
}
cSCHQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CExtractKnowledgeBaseEntitiesCommand* eKBEC = (CExtractKnowledgeBaseEntitiesCommand*)command;
COntologyRevision *ontRev = eKBEC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntology* onto = ontRev->getOntology();
CKnowledgeBaseEntitiesExtractionSpecification* extractSpec = eKBEC->getEntitiesExtractionSpecification();
CExtractedKnowledgeBaseEntitiesContainer* extractionContainer = eKBEC->getExtractionContainer();
CActiveEntityCountVector* activeEntityVector = onto->getDataBoxes()->getExpressionDataBoxMapping()->getActiveEntityVector();
if (activeEntityVector) {
CActiveEntityIterator activeEntityIterator(activeEntityVector->getActiveEntityIterator());
while (activeEntityIterator.hasNextActiveEntity()) {
CExpressionEntity* entity = activeEntityIterator.getNextActiveEntity();
if (extractSpec->hasPartialEntityExtractionFlags(CKnowledgeBaseEntitiesExtractionSpecification::EXTRACTCLASSENTITIES)) {
CClassExpression* classEntity = dynamic_cast(entity);
if (classEntity) {
extractionContainer->addExtractedEntity(classEntity->getName());
}
}
if (extractSpec->hasPartialEntityExtractionFlags(CKnowledgeBaseEntitiesExtractionSpecification::EXTRACTOBJECTPROPERTYENTITIES)) {
CObjectPropertyExpression* propertyEntity = dynamic_cast(entity);
if (propertyEntity) {
extractionContainer->addExtractedEntity(propertyEntity->getName());
}
}
if (extractSpec->hasPartialEntityExtractionFlags(CKnowledgeBaseEntitiesExtractionSpecification::EXTRACTINDIVIDUALSENTITIES)) {
CNamedIndividualExpression* individualEntity = dynamic_cast(entity);
if (individualEntity) {
extractionContainer->addExtractedEntity(individualEntity->getName());
}
}
}
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CExtractKnowledgeBaseLanguageCommand* eKBLC = (CExtractKnowledgeBaseLanguageCommand*)command;
COntologyRevision *ontRev = eKBLC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CConcreteOntology* onto = ontRev->getOntology();
if (onto) {
eKBLC->setKBLanguageString(onto->getStructureSummary()->getExpressivenessString());
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructIsConsistentQueryCommand *cICQC = (CConstructIsConsistentQueryCommand *)command;
COntologyRevision *ontRev = cICQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CIsConsistentQuery *query = new CIsConsistentQuery(ontRev->getOntology(),ontConfig);
if (CConfigDataReader::readConfigBoolean(ontConfig,"Konclude.Query.Statistics.CollectStatistics",false)) {
query->setQueryStatistics(new CQueryStatisticsCollectionStrings());
}
cICQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructIsTriviallyConsistentQueryCommand *cITCQC = (CConstructIsTriviallyConsistentQueryCommand *)command;
COntologyRevision *ontRev = cITCQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CIsTriviallyConsistentQuery *query = new CIsTriviallyConsistentQuery(ontRev->getOntology(),ontConfig);
if (CConfigDataReader::readConfigBoolean(ontConfig,"Konclude.Query.Statistics.CollectStatistics",false)) {
query->setQueryStatistics(new CQueryStatisticsCollectionStrings());
}
cITCQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructClassSatisfiableQueryCommand *cCSQC = (CConstructClassSatisfiableQueryCommand *)command;
COntologyRevision *ontRev = cCSQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CIsClassSatisfiableQuery *query = new CIsClassSatisfiableQuery(cCSQC->getClassName());
CCalculationConfigurationExtension *calcConfig = new CCalculationConfigurationExtension(ontConfig,0);
CConcept* concept = ontRev->getOntology()->getStringMapping()->getClassNameConceptMappingHash()->value(cCSQC->getClassName(),nullptr);
if (concept) {
CSatisfiableCalculationJobGenerator* satCalcJobGenerator = new CSatisfiableCalculationJobGenerator(ontRev->getOntology());
CSatisfiableCalculationJob* satCalcJob = satCalcJobGenerator->getSatisfiableCalculationJob(concept,false);
delete satCalcJobGenerator;
//CQueryStatisticsCollectionStrings* queryStats = nullptr;
//if (true) {
// queryStats = new CQueryStatisticsCollectionStrings();
// satCalcJob->setCalclulationStatisticsCollector(queryStats->createCalculationStatisticsCollection());
//}
//query->setQueryStatistics(queryStats);
satCalcJob->setCalculationConfiguration(calcConfig);
query->setCalculationConfiguration(calcConfig);
query->addTestSatisfiableCalculationJob(satCalcJob,true);
cCSQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord(QString("Concept '%1' cannot be resolved in ontology '%2'.").arg(cCSQC->getClassName()).arg(ontRev->getOntology()->getOntologyName()),&commandRecordRouter);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructWriteFunctionalSubClassHirarchyQueryCommand *cWFSCHQC = (CConstructWriteFunctionalSubClassHirarchyQueryCommand *)command;
COntologyRevision *ontRev = cWFSCHQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CWriteOREFunctionalClassSubsumptionsHierarchyQuery *query = new CWriteOREFunctionalClassSubsumptionsHierarchyQuery(ontRev->getOntology(),ontConfig,cWFSCHQC->getOutputFileName());
cWFSCHQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructWriteCustomQueryCommand *cWCQC = (CConstructWriteCustomQueryCommand *)command;
COntologyRevision *ontRev = cWCQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CWriteQuery::WRITEQUERYTYPE queryType = cWCQC->getWriteQueryType();
CWriteQuerySerializer* serializer = cWCQC->getWriteQuerySerializer();
const QString& entityRestrictionString = cWCQC->getEntityRestrictionString();
if (queryType == CWriteQuery::WRITESUBCLASSHIERARCHY) {
CWriteSerializerClassSubsumptionsHierarchyQuery *query = new CWriteSerializerClassSubsumptionsHierarchyQuery(ontRev->getOntology(),ontConfig,serializer,entityRestrictionString);
cWCQC->setQuery(query);
} else if (queryType == CWriteQuery::WRITESUBOBJECTPROPERTYHIERARCHY) {
CWriteSerializerPropertySubsumptionsHierarchyQuery *query = new CWriteSerializerPropertySubsumptionsHierarchyQuery(ontRev->getOntology(),ontConfig,serializer,false,entityRestrictionString);
cWCQC->setQuery(query);
} else if (queryType == CWriteQuery::WRITESUBDATAPROPERTYHIERARCHY) {
CWriteSerializerPropertySubsumptionsHierarchyQuery *query = new CWriteSerializerPropertySubsumptionsHierarchyQuery(ontRev->getOntology(),ontConfig,serializer,true,entityRestrictionString);
cWCQC->setQuery(query);
} else if (queryType == CWriteQuery::WRITEINDIVIDUALFLATTENEDTYPES) {
CWriteSerializerIndividualFlattenedTypesQuery *query = new CWriteSerializerIndividualFlattenedTypesQuery(ontRev->getOntology(),ontConfig,serializer,entityRestrictionString);
cWCQC->setQuery(query);
}
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructClassifyQueryCommand *cCQC = (CConstructClassifyQueryCommand*)command;
COntologyRevision *ontRev = cCQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CClassifyQuery *query = new CClassifyQuery(ontRev->getOntology(),ontConfig);
if (CConfigDataReader::readConfigBoolean(ontConfig,"Konclude.Query.Statistics.CollectStatistics",false)) {
query->setQueryStatistics(new CQueryStatisticsCollectionStrings());
}
cCQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CConstructRealizeQueryCommand *cRQC = (CConstructRealizeQueryCommand*)command;
COntologyRevision *ontRev = cRQC->getOntologyRevision();
if (ontRev) {
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CRealizeQuery *query = new CRealizeQuery(ontRev->getOntology(),ontConfig);
if (CConfigDataReader::readConfigBoolean(ontConfig,"Konclude.Query.Statistics.CollectStatistics",false)) {
query->setQueryStatistics(new CQueryStatisticsCollectionStrings());
}
cRQC->setQuery(query);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CGenerateQueryCommand* gQC = (CGenerateQueryCommand *)command;
CQueryBuilderGenerator* queryGenerator = gQC->getQueryGenerator();
QList queryList;
if (queryGenerator) {
queryList = queryGenerator->generateQuerys();
} else {
CUnspecifiedMessageErrorRecord::makeRecord("No query generated.",&commandRecordRouter);
}
CQuery *query = 0;
if (queryList.count() > 0) {
query = queryList.first();
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Query couldn't be parsed.",&commandRecordRouter);
}
gQC->setQuery(query);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else if (dynamic_cast(command)) {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CParseOWL2XMLQueryCommand *pOWLQC = (CParseOWL2XMLQueryCommand *)command;
QDomElement queryNode = pOWLQC->getQueryNode();
COntologyRevision *ontRev = pOWLQC->getOntologyRevision();
if (ontRev) {
bool complex = pOWLQC->isComplexQuery();
CConcreteOntology* onto = ontRev->getOntology();
COntologyConfigurationExtension *ontConfig = ontRev->getOntologyConfiguration();
CQueryBuilderGenerator* queryBuilderGen = nullptr;
QList queryList;
if (complex) {
CConcreteOntology* baseOnto = ontRev->getPreviousOntologyRevision()->getOntology();
COWLlinkQueryParser *queryParser = nullptr;
CConcreteOntologyUpdateSeparateHashingCollectorBuilder *ontoBuilder = new CConcreteOntologyUpdateSeparateHashingCollectorBuilder(onto);
queryBuilderGen = new CConcreteOntologyQueryExtendedBuilder(baseOnto,onto,ontConfig,ontoBuilder);
COWL2QtXMLOntologyParser *owl2Parser = new COWL2QtXMLOntologyParser(ontoBuilder,&commandRecordRouter);
queryParser = new COWLlinkQtXMLComplexQueryParser(queryBuilderGen,owl2Parser);
ontoBuilder->initializeBuilding();
queryParser->parseQueryNode(&queryNode);
ontoBuilder->completeBuilding();
//COntologyConfigDependedPreProcesser *ontConDepPreProcessor = new COntologyConfigDependedPreProcesser(commandRecordRouter);
//ontConDepPreProcessor->preprocess(onto,ontConfig);
//delete ontConDepPreProcessor;
delete ontoBuilder;
delete queryParser;
} else {
COWLlinkQueryParser *queryParser = nullptr;
queryBuilderGen = new CConcreteOntologyQuerySimpleBuilder(onto,ontConfig);
queryParser = new COWLlinkQtXMLSimpleQueryParser(queryBuilderGen,onto);
queryParser->parseQueryNode(&queryNode);
delete queryParser;
}
pOWLQC->setQueryGenerator(queryBuilderGen);
} else {
CUnspecifiedMessageErrorRecord::makeRecord("Knowledge base revision not available.",&commandRecordRouter);
}
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
} else {
if (reasonerCommander) {
reasonerCommander->realizeCommand(command);
} else {
CCommandRecordRouter commandRecordRouter(command,this);
CStartProcessCommandRecord::makeRecord(&commandRecordRouter);
CUnspecifiedMessageErrorRecord::makeRecord("Reasoner Commander missing.",&commandRecordRouter);
CStopProcessCommandRecord::makeRecord(&commandRecordRouter);
CFinishProcessCommandRecord::makeRecord(&commandRecordRouter);
LOG(ERROR,getLogDomain(),logTr("Reasoner Commander missing."),this);
}
}
}
}
return true;
} else if (type == EVENTINITIALIZE) {
initializeOWLlinkContent();
return true;
} else if (type == EVENTCOMMANDPROCESSEDCALLBACK) {
CCommandProcessedCallbackEvent *commProCallbackEvent = (CCommandProcessedCallbackEvent *)event;
concludeOWLlinkContent();
return true;
}
} else {
return true;
}
return false;
}
}; // end namespace OWLlink
}; // end namespace Interface
}; // end namespace Control
}; // end namespace Konclude