/*
* 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 "CIndividual.h"
namespace Konclude {
namespace Reasoner {
namespace Ontology {
CIndividual::CIndividual(qint64 id) : CIndividualIdentifier(id) {
mAssertionConceptLinker = nullptr;
mAssertionRoleLinker = nullptr;
mAssertionDataLinker = nullptr;
mReverseAssertionRoleLinker = nullptr;
mNominalConcept = nullptr;
mAnonymousIndividual = false;
mTemporaryIndividual = false;
mFakeIndividual = false;
mIndividualData = nullptr;
}
bool CIndividual::hasIndividualName() {
return hasName();
}
CIndividual *CIndividual::setIndividualNameLinker(CLinker *individualNameLinker) {
setNameLinker(individualNameLinker);
return this;
}
CIndividual *CIndividual::addIndividualNameLinker(CLinker *individualNameLinker) {
addNameLinker(individualNameLinker);
return this;
}
CLinker *CIndividual::getIndividualNameLinker() {
return getNameLinker();
}
CConcept* CIndividual::getIndividualNominalConcept() {
return mNominalConcept;
}
CIndividual* CIndividual::setIndividualNominalConcept(CConcept* nomConcept) {
mNominalConcept = nomConcept;
return this;
}
CConceptAssertionLinker* CIndividual::getAssertionConceptLinker() {
return mAssertionConceptLinker;
}
CIndividual* CIndividual::addAssertionConceptLinker(CConceptAssertionLinker* assConLinker) {
mAssertionConceptLinker = assConLinker->append(mAssertionConceptLinker);
return this;
}
CIndividual* CIndividual::setAssertionConceptLinker(CConceptAssertionLinker* assConLinker) {
mAssertionConceptLinker = assConLinker;
return this;
}
CRoleAssertionLinker* CIndividual::getAssertionRoleLinker() {
return mAssertionRoleLinker;
}
CIndividual* CIndividual::addAssertionRoleLinker(CRoleAssertionLinker* assRoleLinker) {
mAssertionRoleLinker = assRoleLinker->append(mAssertionRoleLinker);
return this;
}
CIndividual* CIndividual::setAssertionRoleLinker(CRoleAssertionLinker* assRoleLinker) {
mAssertionRoleLinker = assRoleLinker;
return this;
}
CDataAssertionLinker* CIndividual::getAssertionDataLinker() {
return mAssertionDataLinker;
}
CIndividual* CIndividual::addAssertionDataLinker(CDataAssertionLinker* assDataLinker) {
mAssertionDataLinker = assDataLinker->append(mAssertionDataLinker);
return this;
}
CIndividual* CIndividual::setAssertionDataLinker(CDataAssertionLinker* assDataLinker) {
mAssertionDataLinker = assDataLinker;
return this;
}
CReverseRoleAssertionLinker* CIndividual::getReverseAssertionRoleLinker() {
return mReverseAssertionRoleLinker;
}
CIndividual* CIndividual::addReverseAssertionRoleLinker(CReverseRoleAssertionLinker* revAssRoleLinker) {
mReverseAssertionRoleLinker = revAssRoleLinker->append(mReverseAssertionRoleLinker);
return this;
}
CIndividual* CIndividual::setReverseAssertionRoleLinker(CReverseRoleAssertionLinker* revAssRoleLinker) {
mReverseAssertionRoleLinker = revAssRoleLinker;
return this;
}
CIndividual* CIndividual::initIndividual(qint64 indiID) {
mTag = indiID;
mAssertionConceptLinker = nullptr;
mNominalConcept = nullptr;
mAnonymousIndividual = false;
mTemporaryIndividual = false;
mFakeIndividual = false;
return this;
}
CIndividual *CIndividual::initIndividualCopy(CIndividual* individual, CMemoryAllocationManager* memMan) {
mNameLinker = individual->getIndividualNameLinker();
mTag = individual->mTag;
CConceptAssertionLinker* assConIt = individual->mAssertionConceptLinker;
while (assConIt) {
CConcept *con = assConIt->getData();
bool negated = assConIt->isNegated();
CConceptAssertionLinker *assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(memMan);
assLinker->initNegLinker(con,negated);
addAssertionConceptLinker(assLinker);
assConIt = assConIt->getNext();
}
mNominalConcept = individual->mNominalConcept;
mAnonymousIndividual = individual->mAnonymousIndividual;
mFakeIndividual = individual->mFakeIndividual;
mTemporaryIndividual = individual->mTemporaryIndividual;
return this;
}
bool CIndividual::hasAssertedConcept(CConcept* concept) {
CConceptAssertionLinker* assertionConceptLinkerIt = mAssertionConceptLinker;
while (assertionConceptLinkerIt) {
CConcept* assConcept = assertionConceptLinkerIt->getData();
if (assConcept->getConceptTag() == concept->getConceptTag()) {
return true;
}
assertionConceptLinkerIt = assertionConceptLinkerIt->getNext();
}
return false;
}
CIndividual* CIndividual::setAnonymousIndividual(bool anonymous) {
mAnonymousIndividual = anonymous;
return this;
}
bool CIndividual::isAnonymousIndividual() {
return mAnonymousIndividual;
}
CIndividual* CIndividual::setTemporaryFakeIndividual(bool temporaryFake) {
mFakeIndividual = mTemporaryIndividual = temporaryFake;
return this;
}
CIndividual* CIndividual::setTemporaryIndividual(bool temporary) {
mTemporaryIndividual = temporary;
return this;
}
bool CIndividual::isTemporaryIndividual() {
return mTemporaryIndividual;
}
CIndividual* CIndividual::setFakeIndividual(bool fake) {
mFakeIndividual = fake;
return this;
}
bool CIndividual::isFakeIndividual() {
return mFakeIndividual;
}
bool CIndividual::hasIndividualData() {
return mIndividualData != nullptr;
}
CIndividualData* CIndividual::getIndividualData() {
return mIndividualData;
}
CIndividual* CIndividual::setIndividualData(CIndividualData* individualData) {
mIndividualData = individualData;
return this;
}
}; // end namespace Ontology
}; // end namespace Reasoner
}; // end namespace Konclude