/*
* 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