/* * 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 "CRole.h" namespace Konclude { namespace Reasoner { namespace Ontology { CRole::CRole() { initRole(); } CRole *CRole::initRole() { superRoles = 0; indirectSuperRoles = 0; mComplexity = false; mFunctional = false; mInvFunctional = false; mTransetive = false; mAsymmetric = false; mSymmetric = false; mReflexive = false; mIrreflexive = false; mDataRole = false; rangeLinker = 0; domainLinker = 0; tax = 0; mInverseEquivalentRoles = 0; mDisjointRoles = 0; mRoleChainSubSharingLinker = nullptr; mRoleChainSuperSharingLinker = nullptr; mInverseRole = nullptr; mRoleData = nullptr; return this; } CRole *CRole::init(qint64 roleTag) { initRole(); mTag = roleTag; return this; } CRole *CRole::init(CRole *role) { mNameLinker = role->getPropertyNameLinker(); mTag = role->mTag; mDataRole = role->mDataRole; superRoles = 0; indirectSuperRoles = 0; rangeLinker = 0; domainLinker = 0; tax = 0; mInverseEquivalentRoles = 0; mDisjointRoles = 0; mInverseRole = nullptr; mComplexity = role->mComplexity; mFunctional = role->mFunctional; mInvFunctional = role->mInvFunctional; mTransetive = role->mTransetive; mAsymmetric = role->mAsymmetric; mSymmetric = role->mSymmetric; mReflexive = role->mReflexive; mIrreflexive = role->mIrreflexive; mRoleChainSubSharingLinker = role->mRoleChainSubSharingLinker; mRoleChainSuperSharingLinker = role->mRoleChainSuperSharingLinker; return this; } CRole *CRole::initRoleCopy(CRole *role, CMemoryAllocationManager* memMan) { mNameLinker = role->getPropertyNameLinker(); mTag = role->mTag; mDataRole = role->mDataRole; superRoles = 0; indirectSuperRoles = 0; rangeLinker = 0; domainLinker = 0; tax = 0; mInverseEquivalentRoles = 0; mDisjointRoles = 0; mComplexity = role->mComplexity; mFunctional = role->mFunctional; mInvFunctional = role->mInvFunctional; mTransetive = role->mTransetive; mAsymmetric = role->mAsymmetric; mSymmetric = role->mSymmetric; mReflexive = role->mReflexive; mIrreflexive = role->mIrreflexive; mRoleChainSubSharingLinker = role->mRoleChainSubSharingLinker; mRoleChainSuperSharingLinker = role->mRoleChainSuperSharingLinker; mInverseRole = role->mInverseRole; CSortedNegLinker *superRoleIt = role->superRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); bool negated = superRoleIt->isNegated(); CSortedNegLinker *superRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(memMan); superRoleLinker->init(superRole,negated); addSuperRoleLinker(superRoleLinker); superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } CSortedNegLinker *inverseRolesIt = role->getInverseRoleList(); while (inverseRolesIt) { CSortedNegLinker *invRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(memMan); invRoleLinker->init(inverseRolesIt->getData(),inverseRolesIt->isNegated()); addInverseRoleLinker(invRoleLinker); inverseRolesIt = (CSortedNegLinker *)inverseRolesIt->getNext(); } CSortedNegLinker *disjointRolesIt = role->getDisjointRoleList(); while (disjointRolesIt) { CSortedNegLinker *disRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(memMan); disRoleLinker->init(disjointRolesIt->getData(),disjointRolesIt->isNegated()); addDisjointRoleLinker(disRoleLinker); disjointRolesIt = (CSortedNegLinker *)disjointRolesIt->getNext(); } CSortedNegLinker *rangeLinkerIt = role->getRangeConceptList(); while (rangeLinkerIt) { CSortedNegLinker *rangeConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(memMan); rangeConLinker->init(rangeLinkerIt->getData(),rangeLinkerIt->isNegated()); addRangeConceptLinker(rangeConLinker); rangeLinkerIt = (CSortedNegLinker *)rangeLinkerIt->getNext(); } CSortedNegLinker *domainLinkerIt = role->getDomainConceptList(); while (domainLinkerIt) { CSortedNegLinker *domainConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(memMan); domainConLinker->init(domainLinkerIt->getData(),domainLinkerIt->isNegated()); addDomainConceptLinker(domainConLinker); domainLinkerIt = (CSortedNegLinker *)domainLinkerIt->getNext(); } return this; } bool CRole::isDataRole() { return mDataRole; } bool CRole::isObjectRole() { return !isDataRole(); } CRole* CRole::setDataRole(bool dataRole) { mDataRole = dataRole; return this; } CRole* CRole::setObjectRole(bool objectRole) { setDataRole(!objectRole); return this; } CRole* CRole::getInverseRole() { return mInverseRole; } CRole* CRole::setInverseRole(CRole* inverseRole) { mInverseRole = inverseRole; return this; } bool CRole::hasInverseRoles() { if (mInverseRole) { return true; } CSortedNegLinker* inverseEquivalentRolesIt = mInverseEquivalentRoles; while (inverseEquivalentRolesIt) { if (inverseEquivalentRolesIt->isNegated()) { return true; } inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext(); } return false; } CRole *CRole::addInverseRoleLinker(CSortedNegLinker *inverseRole) { if (mInverseEquivalentRoles) { mInverseEquivalentRoles = mInverseEquivalentRoles->insertSortedNextSorted(inverseRole); } else { mInverseEquivalentRoles = inverseRole; } return this; } CSortedNegLinker *CRole::getInverseRoleList() { return mInverseEquivalentRoles; } CRole *CRole::setInverseEquivalentRoleList(CSortedNegLinker *invEqRoleList) { mInverseEquivalentRoles = invEqRoleList; return this; } CSortedNegLinker *CRole::getInverseEquivalentRoleList() { return mInverseEquivalentRoles; } bool CRole::hasEquivalentRoles() { CSortedNegLinker* inverseEquivalentRolesIt = mInverseEquivalentRoles; while (inverseEquivalentRolesIt) { if (!inverseEquivalentRolesIt->isNegated()) { return true; } inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext(); } return false; } CRole *CRole::addEquivalentRoleLinker(CSortedNegLinker *equivalentRole) { if (mInverseEquivalentRoles) { mInverseEquivalentRoles = mInverseEquivalentRoles->insertSortedNextSorted(equivalentRole); } else { mInverseEquivalentRoles = equivalentRole; } return this; } bool CRole::hasEquivalentRole(CRole* role) { CSortedNegLinker* inverseEquivalentRolesIt = mInverseEquivalentRoles; while (inverseEquivalentRolesIt) { if (!inverseEquivalentRolesIt->isNegated() && inverseEquivalentRolesIt->getData() == role) { return true; } inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext(); } return false; } bool CRole::hasInverseRole(CRole* role) { if (mInverseRole == role) { return true; } CSortedNegLinker* inverseEquivalentRolesIt = mInverseEquivalentRoles; while (inverseEquivalentRolesIt) { if (inverseEquivalentRolesIt->isNegated() && inverseEquivalentRolesIt->getData() == role) { return true; } inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext(); } return false; } bool CRole::hasDisjointRole(CRole* role) { CSortedNegLinker* disjointRolesIt = mDisjointRoles; while (disjointRolesIt) { if (disjointRolesIt->getData() == role) { return true; } disjointRolesIt = disjointRolesIt->getNext(); } return false; } CRole *CRole::setDisjointRoleList(CSortedNegLinker *disRoleList) { mDisjointRoles = disRoleList; return this; } bool CRole::hasDisjointRoles() { return mDisjointRoles != nullptr; } CRole *CRole::addDisjointRoleLinker(CSortedNegLinker *disjointRole) { if (mDisjointRoles) { mDisjointRoles = mDisjointRoles->insertSortedNextSorted(disjointRole); } else { mDisjointRoles = disjointRole; } return this; } CSortedNegLinker *CRole::getDisjointRoleList() { return mDisjointRoles; } CSortedNegLinker *CRole::getEquivalentRoleList() { return mInverseEquivalentRoles; } CRole *CRole::setRoleTag(qint64 roleTag) { mTag = roleTag; return this; } qint64 CRole::getRoleTag() const { return mTag; } CRole *CRole::setTerminology(CTerminology *ontology) { tax = ontology; return this; } CTerminology *CRole::getTerminology() { return tax; } qint64 CRole::getTerminologyTag() const { if (tax) { return tax->getTerminologyID(); } else { return 0; } } CRole *CRole::setRoleComplexity(bool complexRole) { mComplexity = complexRole; return this; } bool CRole::isComplexRole() { return mComplexity; } bool CRole::isSimpleRole() { return !mComplexity; } bool CRole::getRoleComplexity() { return mComplexity; } CRole *CRole::setFunctional(bool functional) { mFunctional = functional; return this; } bool CRole::isFunctional() { return mFunctional; } bool CRole::getFunctional() { return mFunctional; } CRole *CRole::setInverseFunctional(bool invFunctional) { mInvFunctional = invFunctional; return this; } bool CRole::isInverseFunctional() { return mInvFunctional; } bool CRole::getInverseFunctional() { return mInvFunctional; } CRole *CRole::setTransitive(bool transetive) { mTransetive = transetive; return this; } bool CRole::isTransitive() { return mTransetive; } bool CRole::getTransitive() { return isTransitive(); } bool CRole::hasRoleData() { return mRoleData != nullptr; } CRoleData* CRole::getRoleData() { return mRoleData; } CRole* CRole::setRoleData(CRoleData* roleData) { mRoleData = roleData; return this; } CRole *CRole::setAsymmetric(bool asymmetric) { mAsymmetric = asymmetric; return this; } bool CRole::isAsymmetric() { return mAsymmetric; } bool CRole::getAsymmetric() { return mAsymmetric; } CRole *CRole::setSymmetric(bool symmetric) { mSymmetric = symmetric; return this; } bool CRole::isSymmetric() { return mSymmetric; } bool CRole::getSymmetric() { return mSymmetric; } CRole *CRole::setReflexive(bool reflexive) { mReflexive = reflexive; return this; } bool CRole::isReflexive() { return mReflexive; } bool CRole::getReflexive() { return mReflexive; } CRole *CRole::setIrreflexive(bool irreflexive) { mIrreflexive = irreflexive; return this; } bool CRole::isIrreflexive() { return mIrreflexive; } bool CRole::getIrreflexive() { return mIrreflexive; } CSortedNegLinker *CRole::getRangeConceptList() { return rangeLinker; } CSortedNegLinker *CRole::getRelativeRangeConceptList(bool roleInversed) { if (roleInversed) { return domainLinker; } else { return rangeLinker; } } CSortedNegLinker *CRole::getDomainRangeConceptList(bool roleInversed) { if (roleInversed) { return rangeLinker; } else { return domainLinker; } } bool CRole::hasRangeConceptTag(qint64 rangeConceptTag) { CSortedNegLinker *rangeConIt = rangeLinker; while (rangeConIt) { qint64 rangeConTag = rangeConIt->getData()->getConceptTag(); if (rangeConTag == rangeConceptTag) { return true; } else if (rangeConTag > rangeConceptTag) { return false; } rangeConIt = (CSortedNegLinker *)rangeConIt->getNext(); } return false; } bool CRole::hasRangeConcept(CConcept* concept) { CSortedNegLinker *rangeConIt = rangeLinker; while (rangeConIt) { CConcept* rangeConcept = rangeConIt->getData(); if (rangeConcept == concept) { return true; } rangeConIt = (CSortedNegLinker *)rangeConIt->getNext(); } return false; } bool CRole::hasDomainConcept(CConcept* concept) { CSortedNegLinker *domainConIt = domainLinker; while (domainConIt) { CConcept* domainConcept = domainConIt->getData(); if (domainConcept == concept) { return true; } domainConIt = (CSortedNegLinker *)domainConIt->getNext(); } return false; } bool CRole::hasDomainConceptTag(qint64 domainConceptTag) { CSortedNegLinker *domainConIt = domainLinker; while (domainConIt) { qint64 domainConTag = domainConIt->getData()->getConceptTag(); if (domainConTag == domainConceptTag) { return true; } else if (domainConTag > domainConceptTag) { return false; } domainConIt = (CSortedNegLinker *)domainConIt->getNext(); } return false; } bool CRole::hasDomainOrRangeConceptTag(qint64 conceptTag) { return hasRangeConceptTag(conceptTag) || hasDomainConceptTag(conceptTag); } CRole *CRole::setRangeConceptList(CSortedNegLinker *rangeConceptList) { rangeLinker = rangeConceptList; return this; } CRole *CRole::addRangeConceptLinker(CSortedNegLinker *rangeConceptLinker) { if (rangeLinker) { rangeLinker = rangeLinker->insertSortedNextSorted(rangeConceptLinker); } else { rangeLinker = rangeConceptLinker; } return this; } CSortedNegLinker *CRole::getDomainConceptList() { return domainLinker; } CRole *CRole::setDomainConceptList(CSortedNegLinker *domainConceptList) { domainLinker = domainConceptList; return this; } CRole *CRole::addDomainConceptLinker(CSortedNegLinker *domainConceptLinker) { if (domainLinker) { domainLinker = domainLinker->insertSortedNextSorted(domainConceptLinker); } else { domainLinker = domainConceptLinker; } return this; } CRole *CRole::setSuperRoleList(CSortedNegLinker *superRoleList) { superRoles = superRoleList; return this; } CRole *CRole::addSuperRoleLinker(CSortedNegLinker *superRoleLinker) { if (superRoles) { superRoles = superRoles->insertSortedNextSorted(superRoleLinker); } else { superRoles = superRoleLinker; } return this; } CSortedNegLinker *CRole::getSuperRoleList() { return superRoles; } bool CRole::hasSuperRole(CRole* role) { CSortedNegLinker *superRoleIt = superRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); if (superRole == role) { return true; } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } return false; } bool CRole::hasSuperRoleTag(qint64 tag) { CSortedNegLinker *superRoleIt = superRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); qint64 superRoleTag = superRole->getRoleTag(); if (tag == superRoleTag) { return true; } else if (superRoleTag > tag) { return false; } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } return false; } bool CRole::hasSuperRoleTag(qint64 tag, bool negated) { CSortedNegLinker *superRoleIt = superRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); qint64 superRoleTag = superRole->getRoleTag(); if (tag == superRoleTag && superRoleIt->isNegated() == negated) { return true; } else if (superRoleTag > tag) { return false; } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } return false; } CRole *CRole::setIndirectSuperRoleLinker(CSortedNegLinker *subRoleList) { indirectSuperRoles = subRoleList; return this; } CRole *CRole::addIndirectSuperRoleLinker(CSortedNegLinker *subRoleLinker) { if (indirectSuperRoles) { indirectSuperRoles = indirectSuperRoles->insertSortedNextSorted(subRoleLinker); } else { indirectSuperRoles = subRoleLinker; } return this; } CSortedNegLinker *CRole::getIndirectSuperRoleList() { return indirectSuperRoles; } bool CRole::hasIndirectSuperRole(CRole* role) { CSortedNegLinker *superRoleIt = indirectSuperRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); if (superRole == role) { return true; } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } return false; } bool CRole::hasIndirectSuperRoleTag(qint64 tag) { CSortedNegLinker *superRoleIt = indirectSuperRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); qint64 superRoleTag = superRole->getRoleTag(); if (tag == superRoleTag) { return true; } else if (superRoleTag > tag) { return false; } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } return false; } bool CRole::hasIndirectSuperRoleTag(qint64 tag, bool negated) { CSortedNegLinker *superRoleIt = indirectSuperRoles; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); qint64 superRoleTag = superRole->getRoleTag(); if (tag == superRoleTag && superRoleIt->isNegated() == negated) { return true; } else if (superRoleTag > tag) { return false; } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } return false; } bool CRole::operator<=(const CRole &role) { if (mTag < role.mTag) { return true; } else if (mTag > role.mTag) { return false; } else { return getTerminologyTag() <= role.getTerminologyTag(); } } bool CRole::operator==(const CRole &role) { return mTag == role.mTag && tax == role.tax; } bool CRole::hasPropertyName() { return hasName(); } CRole *CRole::setPropertyNameLinker(CLinker *propertyNameLinker) { setNameLinker(propertyNameLinker); return this; } CRole *CRole::addPropertyNameLinker(CLinker *propertyNameLinker) { addNameLinker(propertyNameLinker); return this; } CLinker *CRole::getPropertyNameLinker() { return getNameLinker(); } bool CRole::hasRoleChainSubSharing() { return mRoleChainSubSharingLinker != nullptr; } CRole *CRole::addRoleChainSubSharingLinker(CXLinker* roleChainLinker) { if (roleChainLinker) { if (!mRoleChainSubSharingLinker) { mRoleChainSubSharingLinker = roleChainLinker; } else { mRoleChainSubSharingLinker = roleChainLinker->append(mRoleChainSubSharingLinker); } } return this; } CXLinker* CRole::getRoleChainSubSharingLinker() { return mRoleChainSubSharingLinker; } bool CRole::hasRoleChainSubSharingLinker(CRoleChain* roleChain) { CXLinker* roleChainIt = mRoleChainSubSharingLinker; while (roleChainIt) { if (roleChainIt->getData() == roleChain) { return true; } roleChainIt = roleChainIt->getNext(); } return false; } bool CRole::hasRoleChainSuperSharing() { return mRoleChainSuperSharingLinker != nullptr; } CRole *CRole::addRoleChainSuperSharingLinker(CXLinker* roleChainLinker) { if (roleChainLinker) { if (!mRoleChainSuperSharingLinker) { mRoleChainSuperSharingLinker = roleChainLinker; } else { mRoleChainSuperSharingLinker = roleChainLinker->append(mRoleChainSuperSharingLinker); } } return this; } CXLinker* CRole::getRoleChainSuperSharingLinker() { return mRoleChainSuperSharingLinker; } bool CRole::hasRoleChainSuperSharingLinker(CRoleChain* roleChain) { CXLinker* roleChainIt = mRoleChainSuperSharingLinker; while (roleChainIt) { if (roleChainIt->getData() == roleChain) { return true; } roleChainIt = roleChainIt->getNext(); } return false; } }; // end namespace Ontology }; // end namespace Reasoner }; // end namespace Konclude