/* * 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 "CTaxonomy.h" namespace Konclude { namespace Reasoner { namespace Taxonomy { CTaxonomy::CTaxonomy(CHierarchyNode *topHierarchyNode, CHierarchyNode *bottomHierarchyNode) { topNode = topHierarchyNode; bottomNode = bottomHierarchyNode; topNode->makeChild(bottomNode); nodeContainer.append(topNode); nodeContainer.append(bottomNode); topIsUnsatisfiable = false; foreach (CConcept *con, *topNode->getEquivalentConceptList()) { conNodeHash.insert(con,topNode); } foreach (CConcept *con, *bottomNode->getEquivalentConceptList()) { conNodeHash.insert(con,bottomNode); } taxonomyComplete = false; } CTaxonomy::CTaxonomy(CConcept *topConcept, CConcept *bottomConcept) { topNode = createHierarchyNode(topConcept); bottomNode = createHierarchyNode(bottomConcept); topNode->makeChild(bottomNode); nodeContainer.append(topNode); nodeContainer.append(bottomNode); topIsUnsatisfiable = false; foreach (CConcept *con, *topNode->getEquivalentConceptList()) { conNodeHash.insert(con,topNode); } foreach (CConcept *con, *bottomNode->getEquivalentConceptList()) { conNodeHash.insert(con,bottomNode); } taxonomyComplete = false; } CTaxonomy::~CTaxonomy() { qDeleteAll(nodeContainer); } bool CTaxonomy::isSubsumption(CConcept *subsumerConcept, CConcept *subsumedConcept) { if (topIsUnsatisfiable) { return true; } bool subsumed = false; CHierarchyNode *subsumerNode = conNodeHash.value(subsumerConcept); if (subsumerNode) { CHierarchyNode *subsumedNode = conNodeHash.value(subsumedConcept); if (subsumedNode) { return subsumerNode == subsumedNode || subsumerNode->hasPredecessorNode(subsumedNode); } } return subsumed; } bool CTaxonomy::isSatisfiable(CConcept *concept) { if (topIsUnsatisfiable) { return false; } CHierarchyNode *node = conNodeHash.value(concept); if (node) { if (node == topNode) { return topNode->hasIncompatiblePredecessorNode(bottomNode); } return node != bottomNode; } return false; } bool CTaxonomy::isNotSatisfiable(CConcept *concept) { if (topIsUnsatisfiable) { return true; } CHierarchyNode *node = conNodeHash.value(concept); if (node) { return node == bottomNode; } return false; } bool CTaxonomy::isTopHierarchyNode(CConcept *concept) { if (topIsUnsatisfiable) { return true; } CHierarchyNode *node = conNodeHash.value(concept); if (node) { return node == topNode; } return false; } bool CTaxonomy::isBottomHierarchyNode(CConcept *concept) { if (topIsUnsatisfiable) { return true; } CHierarchyNode *node = conNodeHash.value(concept); if (node) { return node == bottomNode; } return false; } bool CTaxonomy::isEquivalence(CConcept *concept1, CConcept *concept2) { if (topIsUnsatisfiable) { return true; } CHierarchyNode *node1 = conNodeHash.value(concept1); CHierarchyNode *node2 = conNodeHash.value(concept2); if (node1 && node2) { return node1 == node2; } else { return false; } } bool CTaxonomy::isDisjoint(CConcept *disjointConcept1, CConcept *disjointConcept2) { if (topIsUnsatisfiable) { return false; } CHierarchyNode *node1 = conNodeHash.value(disjointConcept1); CHierarchyNode *node2 = conNodeHash.value(disjointConcept2); if (node1 && node2) { if (node1 == node2) { return false; } else { return node1->hasDisjointNode(node2); } } else { return false; } } bool CTaxonomy::isNotDisjoint(CConcept *disjointConcept1, CConcept *disjointConcept2) { if (topIsUnsatisfiable) { return true; } CHierarchyNode *node1 = conNodeHash.value(disjointConcept1); CHierarchyNode *node2 = conNodeHash.value(disjointConcept2); if (node1 && node2) { if (node1 == node2) { return true; } else if (node1->hasPredecessorNode(node2)) { return true; } else if (node2->hasPredecessorNode(node1)) { return true; } } return false; } CHierarchyNode *CTaxonomy::getTopHierarchyNode() { return topNode; } CHierarchyNode *CTaxonomy::getBottomHierarchyNode() { return bottomNode; } CHierarchyNode *CTaxonomy::createHierarchyNode(CConcept *concept) { return new CHierarchyNode(concept); } CHierarchyNode *CTaxonomy::getHierarchyNode(CConcept *concept, bool create) { CHierarchyNode *node = 0; if (concept) { node = conNodeHash.value(concept,0); if (topIsUnsatisfiable) { if (node != bottomNode && (node || create)) { conNodeHash.insert(concept,bottomNode); bottomNode->addEquivalentConcept(concept); } } if (!node && create) { node = createHierarchyNode(concept); conNodeHash.insert(concept,node); nodeContainer.append(node); } } return node; } bool CTaxonomy::hasHierarchyNode(CConcept *concept) { return conNodeHash.contains(concept); } bool CTaxonomy::isNotSubsumption(CConcept *notSubsumerConcept, CConcept *notSubsumedConcept) { if (topIsUnsatisfiable) { return false; } bool notSubsumed = false; CHierarchyNode *notSubsumerNode = conNodeHash.value(notSubsumerConcept); if (notSubsumerNode) { CHierarchyNode *notSubsumedNode = conNodeHash.value(notSubsumedConcept); if (notSubsumedNode) { return notSubsumerNode != notSubsumedNode && notSubsumerNode->hasIncompatiblePredecessorNode(notSubsumedNode); } } return notSubsumed; } QString CTaxonomy::getConceptHierarchyString() { QString string = topNode->getHierarchyConceptsNodeString(0); return string; } bool CTaxonomy::isComplete() { return taxonomyComplete; } CTaxonomy *CTaxonomy::setTaxonomyComplete(bool completed) { taxonomyComplete = completed; return this;; } bool CTaxonomy::isActiveNode(CHierarchyNode *node) { return node->isActive(); } CTaxonomy *CTaxonomy::setActiveNode(CHierarchyNode *node, bool nodeActive) { node->setActive(nodeActive); if (nodeActive) { activeNodeSet.insert(node); } else { activeNodeSet.remove(node); } return this; } CTaxonomy *CTaxonomy::setInactiveNode(CHierarchyNode *node, bool nodeInactive) { node->setInactive(nodeInactive); if (!nodeInactive) { activeNodeSet.insert(node); } else { activeNodeSet.remove(node); } return this; } CHierarchyNode *CTaxonomy::getActiveNode(CHierarchyNode *node) { if (node->isActive()) { return node; } else { CConcept *con = node->getOneEquivalentConcept(); return getHierarchyNode(con,false); } } CTaxonomy *CTaxonomy::updateNodeEquivalences(CHierarchyNode *node) { foreach (CConcept *con, *node->getEquivalentConceptList()) { conNodeHash.insert(con,node); } return this; } QHash* CTaxonomy::getConceptHierarchyNodeHash() { return &conNodeHash; } }; // end namespace Taxonomy }; // end namespace Reasoner }; // end namespace Konclude