/*
* 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 "CIndexedIndividualAssertionConvertionVisitor.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CIndexedIndividualAssertionConvertionVisitor::CIndexedIndividualAssertionConvertionVisitor(cint64 retrievingIndiId, CCalculationAlgorithmContext* calcAlgContext) : mPreprocessContext(calcAlgContext->getProcessingDataBox()->getOntology(), calcAlgContext->getSatisfiableCalculationTask()->getCalculationConfiguration(), calcAlgContext->getUsedProcessTaskMemoryAllocationManager()) {
mCalcAlgContext = calcAlgContext;
mMemoryAllocationManager = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
mRetrievingIndiId = retrievingIndiId;
mRetrievingIndi = getExistingOrCreateNewTemporaryIndividual(mRetrievingIndiId);
}
CIndexedIndividualAssertionConvertionVisitor::CIndexedIndividualAssertionConvertionVisitor(CIndividual* retrievingIndi, CCalculationAlgorithmContext* calcAlgContext) : mPreprocessContext(calcAlgContext->getProcessingDataBox()->getOntology(), calcAlgContext->getSatisfiableCalculationTask()->getCalculationConfiguration(), calcAlgContext->getUsedProcessTaskMemoryAllocationManager()) {
mCalcAlgContext = calcAlgContext;
mMemoryAllocationManager = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
mRetrievingIndiId = retrievingIndi->getIndividualID();
mRetrievingIndi = getNewTemporaryIndividual(retrievingIndi);
mConceptAssertionLinker = retrievingIndi->getAssertionConceptLinker();
mRoleAssertionLinker = retrievingIndi->getAssertionRoleLinker();
mReverseRoleAssertionLinker = retrievingIndi->getReverseAssertionRoleLinker();
mDataAssertionLinker = retrievingIndi->getAssertionDataLinker();
}
bool CIndexedIndividualAssertionConvertionVisitor::visitIndividualName(const QString& indiName, COntologyTriplesAssertionsAccessor* accessor) {
if (!mRetrievingIndi->getIndividualNameLinker()) {
CIRIName* name = CObjectAllocator< CIRIName >::allocateAndConstruct(mMemoryAllocationManager);
name->setIRIName(indiName);
CLinker* nameLinker = CObjectAllocator< CLinker >::allocateAndConstruct(mMemoryAllocationManager);
nameLinker->init(name);
mRetrievingIndi->setNameLinker(nameLinker);
}
return true;
}
bool CIndexedIndividualAssertionConvertionVisitor::visitRoleAssertion(CRole* role, cint64 otherIndividualId, COntologyTriplesAssertionsAccessor* accessor) {
CRoleAssertionLinker* roleAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
CIndividual* existingOrNewTemporaryIndi = getExistingOrCreateNewTemporaryIndividual(otherIndividualId);
roleAssertionLinker->initRoleAssertionLinker(role, existingOrNewTemporaryIndi);
mRoleAssertionLinker = roleAssertionLinker->append(mRoleAssertionLinker);
return true;
}
bool CIndexedIndividualAssertionConvertionVisitor::visitReverseRoleAssertion(CRole* role, cint64 otherIndividualId, COntologyTriplesAssertionsAccessor* accessor) {
CReverseRoleAssertionLinker* reversRoleAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
CIndividual* existingOrNewTemporaryIndi = getExistingOrCreateNewTemporaryIndividual(otherIndividualId);
CRoleAssertionLinker* roleAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
roleAssertionLinker->initRoleAssertionLinker(role, mRetrievingIndi);
reversRoleAssertionLinker->initReverseRoleAssertionLinker(roleAssertionLinker, existingOrNewTemporaryIndi);
mReverseRoleAssertionLinker = reversRoleAssertionLinker->append(mReverseRoleAssertionLinker);
return true;
}
bool CIndexedIndividualAssertionConvertionVisitor::visitDataAssertion(CRole* role, CDataLiteral* dataLiteral, COntologyTriplesAssertionsAccessor* accessor) {
CDataLiteral* copiedDataLiteral = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemoryAllocationManager, mCalcAlgContext);
copiedDataLiteral->initDataLiteral(dataLiteral->getLexicalDataLiteralValueString(), dataLiteral->getDatatype());
createDataLiteralValue(copiedDataLiteral);
// TODO: clean up of internal data of data literal and data literal value
CDataAssertionLinker* dataAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
dataAssertionLinker->initDataAssertionLinker(role, copiedDataLiteral);
mDataAssertionLinker = dataAssertionLinker->append(mDataAssertionLinker);
return true;
}
bool CIndexedIndividualAssertionConvertionVisitor::visitConceptAssertion(CConcept* concept, COntologyTriplesAssertionsAccessor* accessor) {
CConceptAssertionLinker* conceptAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
conceptAssertionLinker->initNegLinker(concept, false);
mConceptAssertionLinker = conceptAssertionLinker->append(mConceptAssertionLinker);
return true;
}
CIndividual* CIndexedIndividualAssertionConvertionVisitor::getExistingOrCreateNewTemporaryIndividual(cint64 indiId) {
CIndividual* indi = nullptr;
CIndividualVector* indiVector = mCalcAlgContext->getProcessingDataBox()->getIndividualVector(true);
indi = indiVector->getLocalData(indiId);
if (!indi) {
indi = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
indi->initIndividual(indiId);
indi->setTemporaryIndividual(true);
indiVector->setLocalData(indiId, indi);
}
return indi;
}
CIndividual* CIndexedIndividualAssertionConvertionVisitor::getNewTemporaryIndividual(CIndividual* existingIndi) {
CIndividualVector* indiVector = mCalcAlgContext->getProcessingDataBox()->getIndividualVector(true);
CIndividual* newIndi = CObjectAllocator::allocateAndConstruct(mMemoryAllocationManager);
newIndi->initIndividual(existingIndi->getIndividualID());
newIndi->setTemporaryIndividual(true);
newIndi->setIndividualData(existingIndi->getIndividualData());
indiVector->setLocalData(existingIndi->getIndividualID(), newIndi);
return newIndi;
}
CDataLiteralValue* CIndexedIndividualAssertionConvertionVisitor::createDataLiteralValue(CDataLiteral* dataLiteral) {
CDataLiteralValue* dataLiteralValue = mDataLiteralNormalizer.createPreprocessedDataLiteralValue(dataLiteral, &mPreprocessContext, mCalcAlgContext);
return dataLiteralValue;
}
CConceptAssertionLinker* CIndexedIndividualAssertionConvertionVisitor::getConceptAssertionLinker() {
return mConceptAssertionLinker;
}
CRoleAssertionLinker* CIndexedIndividualAssertionConvertionVisitor::getRoleAssertionLinker() {
return mRoleAssertionLinker;
}
CReverseRoleAssertionLinker* CIndexedIndividualAssertionConvertionVisitor::getReverseRoleAssertionLinker() {
return mReverseRoleAssertionLinker;
}
CDataAssertionLinker* CIndexedIndividualAssertionConvertionVisitor::getDataAssertionLinker() {
return mDataAssertionLinker;
}
CIndividual* CIndexedIndividualAssertionConvertionVisitor::getRetrievalIndividual() {
mRetrievingIndi->setAssertionDataLinker(mDataAssertionLinker);
mRetrievingIndi->setAssertionConceptLinker(mConceptAssertionLinker);
mRetrievingIndi->setAssertionRoleLinker(mRoleAssertionLinker);
mRetrievingIndi->setReverseAssertionRoleLinker(mReverseRoleAssertionLinker);
return mRetrievingIndi;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude