/* * 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 "CHierarchyNode.h" namespace Konclude { namespace Reasoner { namespace Taxonomy { CHierarchyNode::CHierarchyNode(CConcept *representiveConcept) { eqConList.append(representiveConcept); eqConCount = 1; active = true; mention = false; #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif } CHierarchyNode::~CHierarchyNode() { } CHierarchyNode *CHierarchyNode::addParentNode(CHierarchyNode *parentNode) { parentNodeSet.insert(parentNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::addChildNode(CHierarchyNode *childNode) { childNodeSet.insert(childNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makeParent(CHierarchyNode *parentNode) { addParentNode(parentNode); parentNode->addChildNode(this); makePredecessor(parentNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makeChild(CHierarchyNode *childNode) { childNodeSet.insert(childNode); childNode->addParentNode(this); makeSuccessor(childNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } bool CHierarchyNode::hasChildNode(CHierarchyNode *node) { return childNodeSet.contains(node); } bool CHierarchyNode::hasParentNode(CHierarchyNode *node) { return parentNodeSet.contains(node); } CHierarchyNode *CHierarchyNode::addEquivalentConcept(CConcept *concept) { eqConList.append(concept); eqConCount++; #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::addPredecessorNode(CHierarchyNode *preNode) { predNodeSet.insert(preNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::addSuccessorNode(CHierarchyNode *succNode) { succNodeSet.insert(succNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makePredecessor(CHierarchyNode *preNode) { predNodeSet.insert(preNode); preNode->addSuccessorNode(this); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makeSuccessor(CHierarchyNode *succNode) { succNodeSet.insert(succNode); succNode->addPredecessorNode(this); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } bool CHierarchyNode::hasSuccessorNode(CHierarchyNode *node) { return succNodeSet.contains(node); } bool CHierarchyNode::hasPredecessorNode(CHierarchyNode *node) { return predNodeSet.contains(node); } CHierarchyNode *CHierarchyNode::removeParent(CHierarchyNode *parentNode) { parentNodeSet.remove(parentNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::removeChild(CHierarchyNode *childNode) { childNodeSet.remove(childNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } cint64 CHierarchyNode::getPredecessorNodeCount() const { return predNodeSet.count(); } QSet *CHierarchyNode::getParentNodeSet() { return &parentNodeSet; } QSet *CHierarchyNode::getChildNodeSet() { return &childNodeSet; } QSet *CHierarchyNode::getPredecessorNodeSet() { return &predNodeSet; } QSet *CHierarchyNode::getSuccessorNodeSet() { return &succNodeSet; } QList *CHierarchyNode::getEquivalentConceptList() { return &eqConList; } CHierarchyNode *CHierarchyNode::removePredecessor(CHierarchyNode *predNode) { predNodeSet.remove(predNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::removeSuccessor(CHierarchyNode *succNode) { succNodeSet.remove(succNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } QList CHierarchyNode::getParentNodeList() { return parentNodeSet.values(); } QList CHierarchyNode::getChildNodeList() { return childNodeSet.values(); } QList CHierarchyNode::getPredecessorNodeList() { return predNodeSet.values(); } QList CHierarchyNode::getSuccessorNodeList() { return succNodeSet.values(); } CHierarchyNode *CHierarchyNode::addIncompatiblePredecessorNode(CHierarchyNode *incompNode) { incompPredNodeSet.insert(incompNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makeIncompatiblePredecessor(CHierarchyNode *incompNode) { addIncompatiblePredecessorNode(incompNode); incompNode->addIncompatibleSuccessorNode(this); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } bool CHierarchyNode::hasIncompatiblePredecessorNode(CHierarchyNode *node) { return incompPredNodeSet.contains(node); } CHierarchyNode *CHierarchyNode::removeIncompatiblePredecessorNode(CHierarchyNode *incompNode) { incompPredNodeSet.remove(incompNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::addIncompatibleSuccessorNode(CHierarchyNode *incompNode) { incompSuccNodeSet.insert(incompNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makeIncompatibleSuccessor(CHierarchyNode *incompNode) { addIncompatibleSuccessorNode(incompNode); incompNode->addIncompatiblePredecessorNode(this); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } bool CHierarchyNode::hasIncompatibleSuccessorNode(CHierarchyNode *node) { return incompSuccNodeSet.contains(node); } CHierarchyNode *CHierarchyNode::removeIncompatibleSuccessorNode(CHierarchyNode *incompNode) { incompSuccNodeSet.remove(incompNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::addDisjointNode(CHierarchyNode *disjNode) { disjointNodeSet.insert(disjNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CHierarchyNode::makeDisjoint(CHierarchyNode *disjNode) { addDisjointNode(disjNode); disjNode->addDisjointNode(this); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } bool CHierarchyNode::hasDisjointNode(CHierarchyNode *node) { return disjointNodeSet.contains(node); } CHierarchyNode *CHierarchyNode::removeDisjointNode(CHierarchyNode *disjNode) { disjointNodeSet.remove(disjNode); #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } QSet *CHierarchyNode::getIncompatibleSuccessorNodeSet() { return &incompSuccNodeSet; } QSet *CHierarchyNode::getIncompatiblePredecessorNodeSet() { return &incompPredNodeSet; } QList CHierarchyNode::getIncompatibleSuccessorNodeList() { return incompSuccNodeSet.values(); } QList CHierarchyNode::getIncompatiblePredecessorNodeList() { return incompPredNodeSet.values(); } QSet *CHierarchyNode::getDisjointNodeSet() { return &disjointNodeSet; } QList CHierarchyNode::getDisjointNodeList() { return disjointNodeSet.values(); } CConcept *CHierarchyNode::getOneEquivalentConcept() { CConcept *concept = 0; if (!eqConList.isEmpty()) { concept = eqConList.first(); } return concept; } bool CHierarchyNode::isActive() { return active; } CHierarchyNode *CHierarchyNode::setActive(bool activeNode) { active = activeNode; return this; } CHierarchyNode *CHierarchyNode::setInactive(bool inactiveNode) { active = !inactiveNode; return this; } bool CHierarchyNode::isNeedExplicitMentioned() { return mention; } CHierarchyNode *CHierarchyNode::setNeedExplicitMentioned(bool needsExplicitMentioned) { mention = needsExplicitMentioned; return this; } QString CHierarchyNode::getEquivalentConceptsNodeString() { QString string; foreach (CConcept *con, eqConList) { QString iriClassNameString = CIRIName::getRecentIRIName(con->getClassNameLinker()); if (!string.isEmpty()) { string += QString(" <=> %1").arg(iriClassNameString); } else { string = iriClassNameString; } } return string; } QString CHierarchyNode::getHierarchyConceptsNodeString(qint64 depth) { QString string(depth,'\t'); string += QString("< ") + getEquivalentConceptsNodeString() + QString(" >\n"); foreach (CHierarchyNode *childNode, getChildNodeList()) { string += childNode->getHierarchyConceptsNodeString(depth+1); } string += QString(depth,'\t')+QString("\n"); return string; } QStringList CHierarchyNode::getEquivalentConceptStringList(bool preferAbbreviatedNames) { QStringList stringList; foreach (CConcept *con, eqConList) { QStringList iriClassNameStringList; if (preferAbbreviatedNames) { iriClassNameStringList.append(CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(con->getClassNameLinker())); } if (!preferAbbreviatedNames || iriClassNameStringList.isEmpty()) { iriClassNameStringList.append(CIRIName::getRecentIRIName(con->getClassNameLinker())); } stringList<getEquivalentConceptsNodeString(); } childNodeStrings.clear(); foreach (CHierarchyNode *node, getChildNodeList()) { childNodeStrings<getEquivalentConceptsNodeString(); } precNodeStrings.clear(); foreach (CHierarchyNode *node, getPredecessorNodeList()) { precNodeStrings<getEquivalentConceptsNodeString(); } succNodeStrings.clear(); foreach (CHierarchyNode *node, getSuccessorNodeList()) { succNodeStrings<getEquivalentConceptsNodeString(); } incPrecNodeStrings.clear(); foreach (CHierarchyNode *node, getIncompatiblePredecessorNodeList()) { incPrecNodeStrings<getEquivalentConceptsNodeString(); } incSuccNodeStrings.clear(); foreach (CHierarchyNode *node, getIncompatibleSuccessorNodeList()) { incSuccNodeStrings<getEquivalentConceptsNodeString(); } disjointNodeStrings.clear(); foreach (CHierarchyNode *node, getDisjointNodeList()) { disjointNodeStrings<getEquivalentConceptsNodeString(); } return this; } #endif }; // end namespace Taxonomy }; // end namespace Reasoner }; // end namespace Konclude