/* * 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 "CWriteIndividualFlattenedTypesQuery.h" namespace Konclude { namespace Reasoner { namespace Query { CWriteIndividualFlattenedTypesQuery::CWriteIndividualFlattenedTypesQuery(CConcreteOntology* ontology, CConfigurationBase *configuration, const QString& outputFileString, const QString& individualNameString, const QString &subClassHierarchyQueryName) : CRealizationPremisingQuery(ontology,configuration) { mQueryName = subClassHierarchyQueryName; mIndividualNameString = individualNameString; if (mIndividualNameString.isEmpty()) { mQueryString = QString("Write Individual Types"); } else { mQueryString = QString("Write Individual Types for '%1'").arg(mIndividualNameString); } mUseAbbreviatedIRIs = CConfigDataReader::readConfigBoolean(configuration,"Konclude.CLI.Output.AbbreviatedIRIs",false); mWriteDeclarations = CConfigDataReader::readConfigBoolean(configuration,"Konclude.CLI.Output.WriteDeclarations",false); mWriteOnlyDirectTypes = CConfigDataReader::readConfigBoolean(configuration,"Konclude.CLI.Output.WriteOnlyDirectTypes",false); mWriteSubClassOfInconsistency = CConfigDataReader::readConfigBoolean(configuration, "Konclude.CLI.Output.WriteReducedInconsistency", false); mWriteAnonymousIndividuals = CConfigDataReader::readConfigBoolean(configuration, "Konclude.CLI.Output.WriteAnonymousIndividualResults", false); mRealizationCalcError = false; mQueryConstructError = false; mBottomClassNameString = QString("http://www.w3.org/2002/07/owl#Nothing"); mTopClassNameString = QString("http://www.w3.org/2002/07/owl#Thing"); mOutputFileNameString = outputFileString; mQueryAnswered = false; mRequiresSameIndividualRealisation = true; mRequiresConceptRealisation = true; } CQueryResult *CWriteIndividualFlattenedTypesQuery::getQueryResult() { return nullptr; } CQuery* CWriteIndividualFlattenedTypesQuery::addQueryError(CQueryError* queryError) { if (CQueryInconsitentOntologyError::hasInconsistentOntologyError(queryError)) { // write inconsistency if (!writeInconsistentIndividualTypes()) { addQueryError(new CQueryUnspecifiedStringError(QString("Could not write individual types to file '%1'.").arg(mOutputFileNameString))); } } CQuery::addQueryError(queryError); return this; } bool CWriteIndividualFlattenedTypesQuery::visitIndividuals(function visitFunc) { CBOXSET* activeIndiSet = mOntology->getABox()->getActiveIndividualSet(); CIndividualVector* indiVec = mOntology->getABox()->getIndividualVector(false); cint64 indiCount = 0; if (indiVec) { indiCount = indiVec->getItemCount(); } bool visited = false; bool continueVisiting = true; cint64 maxTriplesIndexedIndiId = 0; cint64 maxABoxIndiId = 0; COntologyTriplesAssertionsAccessor* triplesAccessor = mOntology->getOntologyTriplesData()->getTripleAssertionAccessor(); if (triplesAccessor) { maxTriplesIndexedIndiId = mOntology->getOntologyTriplesData()->getTripleAssertionAccessor()->getMaxIndexedIndividualId(); } if (indiVec) { cint64 indiCount = indiVec->getItemCount(); for (cint64 idx = 0; idx < indiCount && continueVisiting; ++idx) { CIndividual* indi = indiVec->getData(idx); if (indi && activeIndiSet->contains(indi)) { visited = true; continueVisiting = visitFunc(CIndividualReference(indi)); } else if (idx <= maxTriplesIndexedIndiId) { visited = true; continueVisiting = visitFunc(CIndividualReference(idx)); } maxABoxIndiId = qMax(idx, maxABoxIndiId); } } return visited; } bool CWriteIndividualFlattenedTypesQuery::writeInconsistentIndividualTypes() { if (startWritingOutput()) { writeOntologyStart(); CConcept* bottomConcept = mOntology->getTBox()->getBottomConcept(); QString bottomClassName = CIRIName::getRecentIRIName(bottomConcept->getClassNameLinker()); if (mUseAbbreviatedIRIs) { bottomClassName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(bottomConcept->getClassNameLinker()); } if (mWriteDeclarations) { writeClassDeclaration(bottomClassName); } if (mWriteSubClassOfInconsistency) { CConcept* topConcept = mOntology->getTBox()->getTopConcept(); QString topClassName = CIRIName::getRecentIRIName(topConcept->getClassNameLinker()); if (mUseAbbreviatedIRIs) { topClassName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(topConcept->getClassNameLinker()); } if (mWriteDeclarations) { writeClassDeclaration(topClassName); } writeSubClassRelation(topClassName,bottomClassName); } else { if (mIndividualNameString.isEmpty()) { QStringList incClassNameList; visitIndividuals([&](const CIndividualReference& indiRef)->bool { bool anonymous = mOntology->getIndividualNameResolver()->isAnonymous(indiRef); if (mWriteAnonymousIndividuals || !anonymous) { QString individualName = mOntology->getIndividualNameResolver()->getIndividualName(indiRef, mUseAbbreviatedIRIs); if (mWriteDeclarations) { writeIndividualDeclaration(individualName, anonymous); } writeIndividualType(individualName, anonymous, bottomClassName); } return true; }); } else { if (mWriteDeclarations) { writeNamedIndividualDeclaration(mIndividualNameString); } writeIndividualType(mIndividualNameString, false, bottomClassName); } } writeOntologyEnd(); return endWritingOutput(); } return false; } bool CWriteIndividualFlattenedTypesQuery::visitConcept(CConcept* concept, CConceptRealization* conRealization) { QString conceptString; if (mUseAbbreviatedIRIs) { conceptString = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(concept->getClassNameLinker()); } if (conceptString.isEmpty()) { conceptString = CIRIName::getRecentIRIName(concept->getClassNameLinker()); } if (!conceptString.isEmpty()) { if (mWriteDeclarations && !mDeclaratedConceptSet.contains(concept)) { mDeclaratedConceptSet.insert(concept); writeClassDeclaration(conceptString); } writeIndividualType(mCurrentIndividualName, mCurrentIndividualAnonymous, conceptString); } return true; } CQueryResult *CWriteIndividualFlattenedTypesQuery::constructResult(CRealization* realization) { mQueryAnswered = true; if (!writeIndividualTypesResult(realization)) { addQueryError(new CQueryUnspecifiedStringError(QString("Could not write individual types to file '%1'.").arg(mOutputFileNameString))); } return nullptr; } bool CWriteIndividualFlattenedTypesQuery::writeIndividualTypesResult(CRealization* realization) { if (startWritingOutput()) { CConceptRealization* conRealization = realization->getConceptRealization(); writeOntologyStart(); visitIndividuals([&](const CIndividualReference& indiRef)->bool { bool anonymous = mOntology->getIndividualNameResolver()->isAnonymous(indiRef); if (mWriteAnonymousIndividuals || !anonymous) { mCurrentIndividualName = mOntology->getIndividualNameResolver()->getIndividualName(indiRef, mUseAbbreviatedIRIs); mCurrentIndividualAnonymous = anonymous; if (mWriteDeclarations) { writeIndividualDeclaration(mCurrentIndividualName, anonymous); } conRealization->visitTypes(indiRef, mWriteOnlyDirectTypes, this); } return true; }); writeOntologyEnd(); return endWritingOutput(); } return false; } CWriteQuery::WRITEQUERYTYPE CWriteIndividualFlattenedTypesQuery::getWriteQueryType() { return CWriteQuery::WRITEINDIVIDUALFLATTENEDTYPES; } QString CWriteIndividualFlattenedTypesQuery::getQueryName() { return mQueryName; } QString CWriteIndividualFlattenedTypesQuery::getQueryString() { return mQueryString; } bool CWriteIndividualFlattenedTypesQuery::hasAnswer() { return mQueryAnswered; } QString CWriteIndividualFlattenedTypesQuery::getAnswerString() { if (mIndividualNameString.isEmpty()) { return QString("Individual Types written to file '%1'").arg(mOutputFileNameString); mQueryString = QString("Write Individual Types"); } else { return QString("Individual Types for '%1' written to file '%2'").arg(mIndividualNameString).arg(mOutputFileNameString); } } bool CWriteIndividualFlattenedTypesQuery::hasError() { return mRealizationCalcError || mQueryConstructError || CQuery::hasError(); } }; // end namespace Query }; // end namespace Reasoner }; // end namespace Konclude