/* * 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 . * */ #ifdef KONCLUDE_REDLAND_INTEGRATION #include "CRedlandStoredTriplesIndividualAssertionConvertionIndexer.h" namespace Konclude { namespace Reasoner { namespace Triples { CRedlandStoredTriplesIndividualAssertionConvertionIndexer::CRedlandStoredTriplesIndividualAssertionConvertionIndexer() { } CRedlandStoredTriplesIndividualAssertionConvertionIndexer::~CRedlandStoredTriplesIndividualAssertionConvertionIndexer() { } bool CRedlandStoredTriplesIndividualAssertionConvertionIndexer::indexABoxIndividuals(CConcreteOntology* updateConcreteOntology, COntologyTriplesData* ontologyTripleData) { mIndexingTime.start(); mUupdatingOntology = updateConcreteOntology; mPreprocessContext = new CPreProcessContextBase(updateConcreteOntology, updateConcreteOntology->getConfiguration()); mAnonymousOntologyIdentifier = updateConcreteOntology->getOntologyName() + ":"; if (!mAnonymousOntologyIdentifier.startsWith("_:")) { mAnonymousOntologyIdentifier = "_:" + mAnonymousOntologyIdentifier; } bool newTriplesMapped = false; for (CTriplesData* tripleData : *ontologyTripleData->getAllTriplesData()) { CRedlandStoredTriplesData* redlandTriplesData = dynamic_cast(tripleData); librdf_world* world = redlandTriplesData->getRedlandWorld(); mNextIndiId = 0; mDatatypeHashInitialized = false; mMemMan = updateConcreteOntology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); librdf_node* rdfTypePredicate = librdf_new_node_from_uri_string(world, (const unsigned char*)PREFIX_RDF_TYPE); librdf_node* namedIndividualObject = librdf_new_node_from_uri_string(world, (const unsigned char*)PREFIX_OWL_NAMED_INDIVIDUAL); mRoleNodeDataHash.clear(); QSet* activeRoleSet = updateConcreteOntology->getRBox()->getActivePropertyRoleSet(false); if (activeRoleSet) { for (CRole* role : *activeRoleSet) { QByteArray roleCharData = CIRIName::getRecentIRIName(role->getPropertyNameLinker()).toUtf8(); librdf_node* roleNode = librdf_new_node_from_uri_string(world, (const unsigned char*)roleCharData.constData()); mRoleNodeDataHash.insert(CRedlandNodeHasher(roleNode), new CRoleNodeData(roleNode, role, role->isDataRole())); } } mConceptNodeDataHash.clear(); CConceptNodeData* topConceptData = nullptr; QSet* activeConceptSet = updateConcreteOntology->getTBox()->getActiveClassConceptSet(false); if (activeConceptSet) { for (CConcept* concept : *activeConceptSet) { QByteArray conceptCharData = CIRIName::getRecentIRIName(concept->getClassNameLinker()).toUtf8(); librdf_node* conceptNode = librdf_new_node_from_uri_string(world, (const unsigned char*)conceptCharData.constData()); CConceptNodeData* conceptData = new CConceptNodeData(conceptNode, concept); mConceptNodeDataHash.insert(CRedlandNodeHasher(conceptNode), conceptData); if (concept->getConceptTag() == 1) { topConceptData = conceptData; } } } mIndividualNodeDataHash.clear(); QSet* activeIndiSet = updateConcreteOntology->getABox()->getActiveIndividualSet(false); if (activeIndiSet && !activeIndiSet->isEmpty()) { cint64 maxIndividualId = updateConcreteOntology->getABox()->getNextIndividualId(false); mNextIndiId = qMax(maxIndividualId, mNextIndiId); for (CIndividual* indi : *activeIndiSet) { maxIndividualId = qMax(indi->getIndividualID(), maxIndividualId); QByteArray indiCharData = CIRIName::getRecentIRIName(indi->getIndividualNameLinker()).toUtf8(); librdf_node* indiNode = librdf_new_node_from_uri_string(world, (const unsigned char*)indiCharData.constData()); CIndividualNodeData* indiData = new CIndividualNodeData(indiNode, indi); mIndividualNodeDataHash.insert(CRedlandNodeHasher(indiNode), indiData); mNextIndiId = qMax(indi->getIndividualID(), mNextIndiId); } mNextIndiId++; } indexTriples(redlandTriplesData, rdfTypePredicate, namedIndividualObject, updateConcreteOntology); } LOG(INFO, "::Konclude::Reasoner::TripleEncodedAssertionsIndexer", QString("Identified %1 concept, %2 object property, and %3 data property assertions for overall %4 individuals in %5 ms.").arg(mConceptAssertionCount).arg(mObjectPropertyAssertionCount).arg(mDataPropertyAssertionCount).arg(mNextIndiId).arg(mIndexingTime.elapsed()), this); delete mPreprocessContext; return newTriplesMapped; } CDataLiteralValue* CRedlandStoredTriplesIndividualAssertionConvertionIndexer::createDataLiteralValue(CDataLiteral* dataLiteral, CConcreteOntology* ontology) { CDataLiteralValue* dataLiteralValue = mDataLiteralNormalizer.createPreprocessedDataLiteralValue(dataLiteral, mPreprocessContext, ontology->getDataBoxes()->getBoxContext()); return dataLiteralValue; } CRedlandStoredTriplesIndividualAssertionConvertionIndexer::CIndividualNodeData* CRedlandStoredTriplesIndividualAssertionConvertionIndexer::getIndividualData(librdf_node* indiNode, CConcreteOntology* ontology) { CIndividualNodeData* indiNodeData = mIndividualNodeDataHash.value(indiNode); if (!indiNodeData) { librdf_node* nodeCopy = librdf_new_node_from_node(indiNode); CIndividual* nextIndi = CObjectAllocator::allocateAndConstruct(mMemMan); nextIndi->initIndividual(mNextIndiId++); nextIndi->setAnonymousIndividual(true); indiNodeData = new CIndividualNodeData(nodeCopy, nextIndi); mIndividualNodeDataHash.insert(nodeCopy, indiNodeData); const char* indiNameCharPointer = nullptr; bool blankNode = false; if (!librdf_node_is_blank(indiNode)) { librdf_uri* uri = librdf_node_get_uri(indiNode); indiNameCharPointer = (const char*)librdf_uri_as_string(uri); } else { indiNameCharPointer = (const char*)librdf_node_get_blank_identifier(indiNode); blankNode = true; } CIRIName* newName = CObjectAllocator::allocateAndConstruct(mMemMan); QString indiName = QString::fromUtf8(indiNameCharPointer); if (blankNode) { if (!indiName.startsWith("_:")) { indiName = mAnonymousOntologyIdentifier + indiName; } else { indiName = mAnonymousOntologyIdentifier + indiName.mid(2); } } newName->init(indiName); CLinker* newNameLinker = CObjectAllocator< CLinker >::allocateAndConstruct(mMemMan); newNameLinker->init(newName); nextIndi->addNameLinker(newNameLinker); CIndividualProcessData* indiProcData = new CIndividualProcessData(); indiProcData->initIndividualProcessExtensionData(); nextIndi->setIndividualData(indiProcData); ontology->getABox()->getIndividualVector(true)->setData(nextIndi->getIndividualID(), nextIndi); ontology->getABox()->getActiveIndividualSet(true)->insert(nextIndi); ontology->getStringMapping()->getIndividualNameIndividualMappingHash()->insert(indiName, nextIndi); } return indiNodeData; } CRedlandStoredTriplesIndividualAssertionConvertionIndexer::CIndividualNodeData* CRedlandStoredTriplesIndividualAssertionConvertionIndexer::getIndividualData(librdf_node* subjectNode, CIndividualNodeData*& lastIndiData, librdf_node*& lastSubjectNode, CConcreteOntology* ontology) { if (!lastIndiData || !librdf_node_equals(lastSubjectNode, subjectNode)) { CIndividualNodeData* indiNodeData = getIndividualData(subjectNode, ontology); lastIndiData = indiNodeData; if (lastSubjectNode) { librdf_free_node(lastSubjectNode); } lastSubjectNode = librdf_new_node_from_node(subjectNode); } return lastIndiData; } CDatatype* CRedlandStoredTriplesIndividualAssertionConvertionIndexer::getDatatypeFromDatatypeUri(librdf_uri* uri, CConcreteOntology* ontology, CRedlandStoredTriplesData* ontologyTripleData) { CDatatype* datatype = nullptr; ensureDatatypeHashInitialized(ontology, ontologyTripleData); if (uri) { datatype = mDatatypeIriDatatypeHash.value(CRedlandUriHasher(uri)); } else { datatype = mDefaultDatatype; } return datatype; } void CRedlandStoredTriplesIndividualAssertionConvertionIndexer::ensureDatatypeHashInitialized(CConcreteOntology* ontology, CRedlandStoredTriplesData* ontologyTripleData) { if (!mDatatypeHashInitialized) { CBUILDHASH* datatypeDatatypeExpHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDatatypeDatatypeExpessionHash(); for (CBUILDHASH::const_iterator it = datatypeDatatypeExpHash->constBegin(), itEnd = datatypeDatatypeExpHash->constEnd(); it != itEnd; ++it) { CDatatype* datatype = it.key(); if (datatype->getDatatypeType() == CDatatype::DT_STRING) { mDefaultDatatype = datatype; } QByteArray datatypeCharData = datatype->getDatatypeIRI().toUtf8(); librdf_uri* datatypeUri = librdf_new_uri(ontologyTripleData->getRedlandWorld(), (const unsigned char*)datatypeCharData.constData()); mDatatypeIriDatatypeHash.insert(CRedlandUriHasher(datatypeUri), datatype); } mDatatypeHashInitialized = true; } } void CRedlandStoredTriplesIndividualAssertionConvertionIndexer::identifyIndividuals(librdf_statement* statement, librdf_node* rdfTypePredicate, librdf_node* namedIndividualObject, CIndividualNodeData* &lastIndiData, librdf_node* lastSubjectNode, CConcreteOntology* updateConcreteOntology, CRedlandStoredTriplesData* redlandTriplesData) { librdf_node* predicateNode = librdf_statement_get_predicate(statement); librdf_node* objectNode = librdf_statement_get_object(statement); librdf_node* subjectNode = librdf_statement_get_subject(statement); if (librdf_node_equals(predicateNode, rdfTypePredicate)) { if (librdf_node_equals(objectNode, namedIndividualObject)) { lastIndiData = getIndividualData(subjectNode, lastIndiData, lastSubjectNode, updateConcreteOntology); lastIndiData->mIndividual->setAnonymousIndividual(false); } else { CConceptNodeData* conceptData = mConceptNodeDataHash.value(CRedlandNodeHasher(objectNode)); if (conceptData) { lastIndiData = getIndividualData(subjectNode, lastIndiData, lastSubjectNode, updateConcreteOntology); CConceptAssertionLinker* conceptAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemMan); conceptAssertionLinker->initNegLinker(conceptData->mConcept, false); lastIndiData->mIndividual->addAssertionConceptLinker(conceptAssertionLinker); mConceptAssertionCount++; } if (lastIndiData && librdf_node_is_resource(subjectNode)) { lastIndiData->mIndividual->setAnonymousIndividual(false); } } } else { CRoleNodeData* roleData = mRoleNodeDataHash.value(CRedlandNodeHasher(predicateNode)); if (roleData) { lastIndiData = getIndividualData(subjectNode, lastIndiData, lastSubjectNode, updateConcreteOntology); if (librdf_node_is_resource(subjectNode)) { lastIndiData->mIndividual->setAnonymousIndividual(false); } if (roleData->mDataRole) { if (librdf_node_is_literal(objectNode)) { const char* literalValue = (const char*)librdf_node_get_literal_value(objectNode); librdf_uri* datatypeUri = librdf_node_get_literal_value_datatype_uri(objectNode); CDatatype* datatype = getDatatypeFromDatatypeUri(datatypeUri, updateConcreteOntology, redlandTriplesData); CDataLiteral* dataLiteral = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(mMemMan, updateConcreteOntology->getDataBoxes()->getBoxContext()); dataLiteral->initDataLiteral(QString::fromUtf8(literalValue), datatype); createDataLiteralValue(dataLiteral, updateConcreteOntology); CDataAssertionLinker* dataAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemMan); dataAssertionLinker->initDataAssertionLinker(roleData->mRole, dataLiteral); lastIndiData->mIndividual->addAssertionDataLinker(dataAssertionLinker); mDataPropertyAssertionCount++; } } else { if (!librdf_node_is_literal(objectNode)) { CIndividualNodeData* targetIndiNode = getIndividualData(objectNode, updateConcreteOntology); if (librdf_node_is_resource(objectNode)) { targetIndiNode->mIndividual->setAnonymousIndividual(false); } CRoleAssertionLinker* roleAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemMan); roleAssertionLinker->initRoleAssertionLinker(roleData->mRole, targetIndiNode->mIndividual); lastIndiData->mIndividual->addAssertionRoleLinker(roleAssertionLinker); CReverseRoleAssertionLinker* reverseRoleAssertionLinker = CObjectAllocator::allocateAndConstruct(mMemMan); reverseRoleAssertionLinker->initReverseRoleAssertionLinker(roleAssertionLinker, lastIndiData->mIndividual); targetIndiNode->mIndividual->addReverseAssertionRoleLinker(reverseRoleAssertionLinker); mObjectPropertyAssertionCount++; } } } } } void CRedlandStoredTriplesIndividualAssertionConvertionIndexer::indexTriples(CRedlandStoredTriplesData* redlandTriplesData, librdf_node* rdfTypePredicate, librdf_node* namedIndividualObject, CConcreteOntology* updateConcreteOntology) { CIndividualNodeData* lastIndiData = nullptr; librdf_node* lastSubjectNode = nullptr; CXLinker* statementLinker = redlandTriplesData->getRedlandStatementLinker(); if (statementLinker) { while (statementLinker) { librdf_statement* statement = statementLinker->getData(); identifyIndividuals(statement, rdfTypePredicate, namedIndividualObject, lastIndiData, lastSubjectNode, updateConcreteOntology, redlandTriplesData); statementLinker = statementLinker->getNext(); } } else { librdf_stream* stream = librdf_model_as_stream(redlandTriplesData->getRedlandIndexedModel()); if (stream) { while (!librdf_stream_end(stream)) { librdf_statement* statement = librdf_stream_get_object(stream); identifyIndividuals(statement, rdfTypePredicate, namedIndividualObject, lastIndiData, lastSubjectNode, updateConcreteOntology, redlandTriplesData); librdf_stream_next(stream); } librdf_free_stream(stream); } } bool deleteIndexedTriplesData = CConfigDataReader::readConfigBoolean(updateConcreteOntology->getConfiguration(), "Konclude.Calculation.Preprocessing.TripleEncodedAssertionsIndexing.DeleteTriplesDataAfterIndexing", false); if (deleteIndexedTriplesData) { auto tripleDeleteMapFunc = [&](CRedlandStoredTriplesData* redlandTriplesData) { if (redlandTriplesData) { librdf_world* world = redlandTriplesData->getRedlandWorld(); mMemMan = updateConcreteOntology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); CXLinker* statementLinker = redlandTriplesData->getRedlandStatementLinker(); if (statementLinker) { while (statementLinker) { librdf_statement* statement = statementLinker->getData(); librdf_free_statement(statement); CXLinker* tmpStatementLinker = statementLinker; statementLinker = statementLinker->getNext(); delete tmpStatementLinker; } redlandTriplesData->setRedlandStatementLinker(nullptr); } else { librdf_stream* stream = librdf_model_as_stream(redlandTriplesData->getRedlandIndexedModel()); if (stream) { while (!librdf_stream_end(stream)) { librdf_statement* statement = librdf_stream_get_object(stream); librdf_model_remove_statement(redlandTriplesData->getRedlandIndexedModel(), statement); librdf_free_statement(statement); librdf_stream_next(stream); } librdf_free_stream(stream); } } } }; tripleDeleteMapFunc(redlandTriplesData); } updateConcreteOntology->getABox()->setNextIndividualId(mNextIndiId); } }; // end namespace Triples }; // end namespace Reasoner }; // end namespace Konclude #endif // !KONCLUDE_REDLAND_INTEGRATION