/*
* 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 .
*
*/
#ifndef KONCLUDE_REASONER_QUERY_CSTRINGHIERARCHYRESULT_CPP
#define KONCLUDE_REASONER_QUERY_CSTRINGHIERARCHYRESULT_CPP
#include "CStringHierarchyResult.h"
namespace Konclude {
namespace Reasoner {
namespace Query {
template
CStringHierarchyResult::CStringHierarchyResult() {
mBottomString = 0;
mTopString = 0;
}
template
CStringHierarchyResult::CStringHierarchyResult(const QString &bottomHierarchyString, const QString &topHierarchyString) {
mTopString = getStringSynset(topHierarchyString);
mBottomString = getStringSynset(bottomHierarchyString);
}
template
CStringHierarchyResult::CStringHierarchyResult(const QStringList &bottomHierarchyStrings, const QStringList &topHierarchyStrings) {
mTopString = getStringSynset(topHierarchyStrings);
mBottomString = getStringSynset(bottomHierarchyStrings);
}
template
CStringHierarchyResult::CStringHierarchyResult(E *takeBottomStringSynset, E *takeTopStringSynset) {
mTopString = takeTopStringSynset;
mBottomString = takeBottomStringSynset;
foreach (QString stringName, mTopString->getEquivalentStringNameList()) {
mStringStringSynsetHash.insert(stringName,mTopString);
}
mStringSynsetContainer.append(mTopString);
foreach (QString stringName, mBottomString->getEquivalentStringNameList()) {
mStringStringSynsetHash.insert(stringName,mBottomString);
}
mStringSynsetContainer.append(mBottomString);
}
template
CStringHierarchyResult::CStringHierarchyResult(E *takeBottomStringSynset) {
mTopString = nullptr;
mBottomString = takeBottomStringSynset;
foreach (QString stringName, mBottomString->getEquivalentStringNameList()) {
mStringStringSynsetHash.insert(stringName,mBottomString);
}
mStringSynsetContainer.append(mBottomString);
}
template
CStringHierarchyResult::~CStringHierarchyResult() {
qDeleteAll(mStringSynsetContainer);
qDeleteAll(mSubStringRelationContainer);
}
template
E *CStringHierarchyResult::getBottomStringSynset() {
return mBottomString;
}
template
E *CStringHierarchyResult::getTopStringSynset() {
return mTopString;
}
template
E *CStringHierarchyResult::getStringSynset(const QString &stringName, bool create) {
E *stringSynset = mStringStringSynsetHash.value(stringName,0);
if (!stringSynset && create) {
stringSynset = new E(stringName);
mStringStringSynsetHash.insert(stringName,stringSynset);
mStringSynsetContainer.append(stringSynset);
}
return stringSynset;
}
template
E *CStringHierarchyResult::getStringSynset(const QStringList &stringNames, bool create) {
E *stringSynset = 0;
if (!stringNames.isEmpty()) {
stringSynset = mStringStringSynsetHash.value(stringNames.first(),0);
if (!stringSynset && create) {
stringSynset = new E(stringNames);
foreach (QString stringName, stringNames) {
mStringStringSynsetHash.insert(stringName,stringSynset);
}
mStringSynsetContainer.append(stringSynset);
}
}
return stringSynset;
}
template
E *CStringHierarchyResult::setTopStringSynset(E *stringSynset) {
mTopString = stringSynset;
return stringSynset;
}
template
E *CStringHierarchyResult::addStringSynset(E *takeStringSynset) {
foreach (QString stringName, takeStringSynset->getEquivalentStringNameList()) {
mStringStringSynsetHash.insert(stringName,takeStringSynset);
}
mStringSynsetContainer.append(takeStringSynset);
return takeStringSynset;
}
template
R *CStringHierarchyResult::addSubStringRelation(E *superStringSynset, E *anySubStringSynset) {
R *subStringRelation = mStringSynsetSubStringHash.value(superStringSynset,0);
if (!subStringRelation) {
subStringRelation = new R(superStringSynset);
mSubStringRelationContainer.append(subStringRelation);
mStringSynsetSubStringHash.insert(superStringSynset,subStringRelation);
}
if (!subStringRelation->hasSubStringsSynset(anySubStringSynset)) {
subStringRelation->addSubStringsSynset(anySubStringSynset);
}
return subStringRelation;
}
template
R *CStringHierarchyResult::getSubStringRelation(E *superStringSynset, bool create) {
R *subStringRelation = mStringSynsetSubStringHash.value(superStringSynset,0);
if (!subStringRelation && create) {
subStringRelation = new R(superStringSynset);
mSubStringRelationContainer.append(subStringRelation);
mStringSynsetSubStringHash.insert(superStringSynset,subStringRelation);
}
return subStringRelation;
}
template
QString CStringHierarchyResult::getQueryResultString() {
QString string;
return string;
}
template
CTaxonomy *CStringHierarchyResult::fillTaxonomy(CConcreteOntology *ontology, CTaxonomy *taxonomy) {
bool completeMapping = true;
CMAPPINGHASH *stringConceptHash = ontology->getStringMapping()->getClassNameConceptMappingHash(false);
if (stringConceptHash) {
QStringList bottomStringList(mBottomString->getEquivalentStringNameList());
foreach (QString bottomStringString, bottomStringList) {
CConcept *unsatCon = stringConceptHash->value(bottomStringString,0);
if (unsatCon) {
if (!taxonomy->isSatisfiable(unsatCon) && !taxonomy->isNotSatisfiable(unsatCon)) {
taxonomy->setConceptSatisfiable(unsatCon,false);
}
} else {
completeMapping = false;
}
}
QList updateStringSynList;
QSet updateStringSynSet;
updateStringSynList.append(mTopString);
while (!updateStringSynList.isEmpty()) {
E *stringSynset = updateStringSynList.takeFirst();
QStringList stringNameList(stringSynset->getEquivalentStringNameList());
CConcept *firstSatCon = 0;
foreach (QString stringName, stringNameList) {
CConcept *satConcept = stringConceptHash->value(stringName,0);
if (satConcept) {
if (!taxonomy->isSatisfiable(satConcept) && !taxonomy->isNotSatisfiable(satConcept)) {
taxonomy->setConceptSatisfiable(satConcept,true);
}
if (firstSatCon) {
if (!taxonomy->isSubsumption(firstSatCon,satConcept) && !taxonomy->isNotSubsumption(firstSatCon,satConcept)) {
taxonomy->setConceptSubsumption(firstSatCon,satConcept);
}
if (!taxonomy->isSubsumption(satConcept,firstSatCon) && !taxonomy->isNotSubsumption(satConcept,firstSatCon)) {
taxonomy->setConceptSubsumption(satConcept,firstSatCon);
}
}
if (!firstSatCon) {
firstSatCon = satConcept;
}
} else {
completeMapping = false;
}
}
R *subStringRelation = mStringSynsetSubStringHash.value(stringSynset);
if (subStringRelation) {
QSet* subStringSet(subStringRelation->getSubStringsSynsetSet());
foreach (E *subStringSynset, *subStringSet) {
CConcept *con = 0;
foreach (QString substringName, subStringSynset->getEquivalentStringNameList()) {
con = stringConceptHash->value(substringName,0);
if (con) {
if (!taxonomy->isSatisfiable(con) && !taxonomy->isNotSatisfiable(con)) {
taxonomy->setConceptSatisfiable(con,true);
}
break;
}
}
if (con) {
if (!taxonomy->isSubsumption(con,firstSatCon) && !taxonomy->isNotSubsumption(con,firstSatCon)) {
taxonomy->setConceptSubsumption(con,firstSatCon);
}
if (!updateStringSynSet.contains(subStringSynset)) {
updateStringSynSet.insert(subStringSynset);
updateStringSynList.append(subStringSynset);
}
} else {
completeMapping = false;
}
}
}
}
}
return taxonomy;
}
template
void CStringHierarchyResult::compareSubsumersCount(QHash* subsumHash1, QHash* subsumHash2) {
cint64 totalStringDiffCount = 0;
cint64 totalStringAddCount = 0;
cint64 totalStringMissCount = 0;
cint64 totalAddCount = 0;
cint64 totalMissCount = 0;
foreach (const QString& stringName, subsumHash1->uniqueKeys()) {
QList stringSuperSynSets1(subsumHash1->values(stringName));
QList stringSuperSynSets2(subsumHash2->values(stringName));
cint64 missingCount = 0;
cint64 additionalCount = 0;
foreach (const QString& supsumerStringName, stringSuperSynSets1) {
if (!stringSuperSynSets2.contains(supsumerStringName)) {
++missingCount;
}
}
cint64 diffCount = stringSuperSynSets2.count() - stringSuperSynSets1.count();
if (diffCount != 0 || missingCount > 0) {
foreach (const QString& supsumerStringName, stringSuperSynSets2) {
if (!stringSuperSynSets1.contains(supsumerStringName)) {
++additionalCount;
}
}
}
if (additionalCount > 0) {
++totalStringAddCount;
totalAddCount += additionalCount;
}
if (missingCount > 0) {
++totalStringMissCount;
totalMissCount += missingCount;
}
if (additionalCount > 0 || missingCount > 0) {
++totalStringDiffCount;
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("'%1' has %2 additional and %3 missing subsumers.").arg(stringName).arg(additionalCount).arg(missingCount),this);
}
}
if (totalStringDiffCount != 0) {
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("%1 with additional subsumers, %2 with missing subsumers, overall %3 different.").arg(totalStringAddCount).arg(totalStringMissCount).arg(totalStringDiffCount),this);
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Overall %1 additional subsumers, %2 missing subsumers.").arg(totalAddCount).arg(totalMissCount),this);
}
}
template
void CStringHierarchyResult::collectSubsumerStringSynsets(CStringHierarchyResult *stringHierarchy, QHash* subsumHash, QSet< QPair >* subsumSet) {
QSet< QPair >* delSubsumSet = nullptr;
if (!subsumSet) {
delSubsumSet = new QSet< QPair >();
subsumSet = delSubsumSet;
}
QList allStringList;
QSet allStringSet;
QSet currStringSet;
E* topStringSynset = stringHierarchy->getTopStringSynset();
allStringList.append(topStringSynset);
allStringSet.insert(topStringSynset);
currStringSet.insert(topStringSynset);
while (!allStringList.isEmpty()) {
E* stringSynset = allStringList.takeFirst();
R* subStringSynsetRel = stringHierarchy->getSubStringRelation(stringSynset,false);
QList superStringList;
foreach (const QString& stringName1, stringSynset->getEquivalentStringNameList()) {
foreach (const QString& stringName2, stringSynset->getEquivalentStringNameList()) {
QPair selfSubSumPair(stringName1,stringName2);
if (!subsumSet->contains(selfSubSumPair)) {
subsumSet->insert(selfSubSumPair);
subsumHash->insertMulti(stringName1,stringName2);
}
QList tmpSuperStringList(subsumHash->values(stringName2));
foreach (const QString& stringName3, tmpSuperStringList) {
QPair subSumPair(stringName1,stringName3);
if (!subsumSet->contains(subSumPair)) {
subsumSet->insert(subSumPair);
subsumHash->insertMulti(stringName1,stringName3);
}
}
}
if (superStringList.isEmpty()) {
superStringList.append(subsumHash->values(stringName1));
}
}
if (subStringSynsetRel) {
foreach (E* subStringSynset, *subStringSynsetRel->getSubStringsSynsetSet()) {
QList subStringList(subStringSynset->getEquivalentStringNameList());
allStringList.append(subStringSynset);
foreach (const QString& stringName1, subStringList) {
foreach (const QString& stringName2, subStringList) {
QPair selfSubSumPair(stringName1,stringName2);
if (!subsumSet->contains(selfSubSumPair)) {
subsumSet->insert(selfSubSumPair);
subsumHash->insertMulti(stringName1,stringName2);
}
}
}
foreach (const QString& stringName1, subStringList) {
foreach (const QString& stringName2, superStringList) {
QPair subSumPair(stringName1,stringName2);
if (!subsumSet->contains(subSumPair)) {
subsumSet->insert(subSumPair);
subsumHash->insertMulti(stringName1,stringName2);
}
}
}
}
}
}
delete delSubsumSet;
}
template
bool CStringHierarchyResult::isResultEquivalentTo(CQueryResult *otherQueryResult) {
if (!otherQueryResult) {
return false;
}
T *otherStringHierarchy = dynamic_cast(otherQueryResult);
if (!otherStringHierarchy) {
return false;
}
bool wrongResult = false;
if (!mBottomString->isResultEquivalentTo(otherStringHierarchy->getBottomStringSynset())) {
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Bottom synset does not match."),this);
wrongResult = true;
}
if (mTopString && !otherStringHierarchy->getTopStringSynset() || !mTopString && otherStringHierarchy->getTopStringSynset()) {
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Top synset does not match."),this);
return false;
}
if (!mTopString) {
return !wrongResult;
}
if (!mTopString->isResultEquivalentTo(otherStringHierarchy->getTopStringSynset())) {
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Top synset does not match."),this);
return false;
}
#ifndef KONCLUDE_FORCE_ALL_DEBUG_DEACTIVATED
//QHash subsumHash1;
//QHash subsumHash2;
//QSet< QPair > subsumSet1;
//QSet< QPair > subsumSet2;
//collectSubsumerStringSynsets(this,&subsumHash1,&subsumSet1);
//collectSubsumerStringSynsets(otherStringHierarchy,&subsumHash2,&subsumSet2);
//compareSubsumersCount(&subsumHash1,&subsumHash2);
#endif
E* topStringSynset = otherStringHierarchy->getTopStringSynset();
QList testStringList;
QList otherStringList;
QSet testStringSet;
testStringList.append(mTopString);
otherStringList.append(topStringSynset);
testStringSet.insert(mTopString);
while (!testStringList.isEmpty()) {
E *stringSynset = testStringList.takeFirst();
E *otherStringSynset = otherStringList.takeFirst();
R *subStringRelation = getSubStringRelation(stringSynset,false);
R *otherSubStringRelation = otherStringHierarchy->getSubStringRelation(otherStringSynset,false);
if (!subStringRelation && otherSubStringRelation || subStringRelation && !otherSubStringRelation) {
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Sub relations of '%1' do not match.").arg(stringSynset->getEquivalentStringNameList().join(", ")),this);
return false;
}
if (subStringRelation) {
if (subStringRelation->getSubStringsSynsetCount() != otherSubStringRelation->getSubStringsSynsetCount()) {
wrongResult = true;
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Sub relations of '%1' do not match.").arg(stringSynset->getEquivalentStringNameList().join(", ")),this);
}
if (subStringRelation->getSubStringsSynsetCount() < 20) {
QList otherSubStringList(otherSubStringRelation->getSubStringsSynsetList());
foreach (E *stringSynset, subStringRelation->getSubStringsSynsetList()) {
bool contained = false;
E *accSubStringSynset = stringSynset;
for (qint64 cnt = otherSubStringList.count(); cnt > 0; --cnt) {
E *accOtherSubStringSynset = otherSubStringList.first();
if (!accOtherSubStringSynset) {
wrongResult = true;
break;
} else {
contained |= accOtherSubStringSynset->isResultEquivalentTo(stringSynset);
if (contained) {
otherSubStringList.takeFirst();
if (!testStringSet.contains(accSubStringSynset)) {
testStringSet.insert(accSubStringSynset);
testStringList.append(accSubStringSynset);
otherStringList.append(accOtherSubStringSynset);
}
break;
} else {
otherSubStringList.append(otherSubStringList.takeFirst());
}
}
}
if (!contained) {
wrongResult = true;
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Could not find corresponding sub synset '%1' of super synset '%2'.").arg(stringSynset->getEquivalentStringNameList().join(", ")).arg(otherStringSynset->getEquivalentStringNameList().join(", ")),this);
}
}
} else {
QList otherSubStringList(otherSubStringRelation->getSubStringsSynsetList());
QHash otherSubStringHash;
foreach (E* otherStringSynset, otherSubStringList) {
foreach (const QString& stringName ,otherStringSynset->getEquivalentStringNameList()) {
otherSubStringHash.insert(stringName,otherStringSynset);
}
}
foreach (E *stringSynset, subStringRelation->getSubStringsSynsetList()) {
bool contained = false;
E *accSubStringSynset = stringSynset;
E *accOtherSubStringSynset = otherSubStringHash.value(accSubStringSynset->getEquivalentStringNameList().first());
if (!accOtherSubStringSynset || !accOtherSubStringSynset->isResultEquivalentTo(stringSynset)) {
wrongResult = true;
LOG(ERROR,"::Konclude::Reasoner::Query::StringHierarchyResult",logTr("Could not find corresponding sub synset '%1' of super synset '%2'.").arg(stringSynset->getEquivalentStringNameList().join(", ")).arg(otherStringSynset->getEquivalentStringNameList().join(", ")),this);
} else if (accOtherSubStringSynset) {
foreach (const QString& stringName ,accOtherSubStringSynset->getEquivalentStringNameList()) {
otherSubStringHash.insert(stringName,nullptr);
}
contained = true;
}
if (contained) {
if (!testStringSet.contains(accSubStringSynset)) {
testStringSet.insert(accSubStringSynset);
testStringList.append(accSubStringSynset);
otherStringList.append(accOtherSubStringSynset);
}
}
}
}
}
}
return !wrongResult;
}
}; // end namespace Query
}; // end namespace Reasoner
}; // end namespace Konclude
#endif // KONCLUDE_REASONER_QUERY_CSTRINGHIERARCHYRESULT_CPP