/* * 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 "CSPARQLExtendedMappingBuildingParser.h" namespace Konclude { namespace Parser { CSPARQLExtendedMappingBuildingParser::CSPARQLExtendedMappingBuildingParser(COntologyBuilder* ontoBuilder, CConcreteOntology* ontology) : CSPARQLSimpleBuildingParser(ontoBuilder, ontology) { } CSPARQLExtendedMappingBuildingParser::~CSPARQLExtendedMappingBuildingParser() { } QList CSPARQLExtendedMappingBuildingParser::getTripleOWLAxioms(QHash* subjectTripleHash, bool anonymousIndividualsAsVariables) { QList* tripleDataList = createTermTripleData(subjectTripleHash); bool requiresMapping = analyseTermTripleDataRequiresExtendedMapping(tripleDataList, anonymousIndividualsAsVariables); if (!requiresMapping) { return CSPARQLSimpleBuildingParser::getTripleOWLAxioms(subjectTripleHash, anonymousIndividualsAsVariables); } else { return handlingMappingRequiredTermTripleData(tripleDataList, anonymousIndividualsAsVariables, nullptr); } } QList CSPARQLExtendedMappingBuildingParser::getTripleOWLAxioms(QList* tripleStringList, bool anonymousIndividualsAsVariables, QSet* varExpSet) { QList* tripleDataList = createTermTripleData(tripleStringList); bool requiresMapping = analyseTermTripleDataRequiresExtendedMapping(tripleDataList, anonymousIndividualsAsVariables); if (!requiresMapping) { return CSPARQLSimpleBuildingParser::getTripleOWLAxioms(tripleStringList, anonymousIndividualsAsVariables, varExpSet); } else { return handlingMappingRequiredTermTripleData(tripleDataList, anonymousIndividualsAsVariables, varExpSet); } } librdf_node* CSPARQLExtendedMappingBuildingParser::getRedlandRDFNode(CSPARQLBuildingParserTermData* termData, CRedlandStoredTriplesData* triplesData, QHash* reuseExpHash, QHash* termVariableExpressionNewEntityHash, cint64& newEntityNumber, QSet* varExpSet) { librdf_world* world = triplesData->getRedlandWorld(); librdf_node* node = nullptr; if (reuseExpHash->contains(termData)) { node = reuseExpHash->value(termData); node = librdf_new_node_from_node(node); return node; } CSPARQLBuildingParserTermData::TermType termType = termData->getTermType(); const QString& termString = termData->getTermString(); if (termType == CSPARQLBuildingParserTermData::RESOURCE_TYPE || termType == CSPARQLBuildingParserTermData::CLASS_TYPE || termType == CSPARQLBuildingParserTermData::PROPERTY_TYPE || termType == CSPARQLBuildingParserTermData::DATA_PROPERTY_TYPE || termType == CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_TYPE) { if (termString.startsWith("_:")) { QByteArray bytes = termString.toUtf8(); node = librdf_new_node_from_blank_identifier(world, (const unsigned char*)bytes.constData()); } else { QByteArray bytes = termString.toUtf8(); raptor_uri* uri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)bytes.constData()); node = librdf_new_node_from_uri(world, uri); } } else if (termType == CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE) { cint64 sepPos = termString.lastIndexOf("^^"); QByteArray datatypeBytes = termString.mid(sepPos+2).toUtf8(); QByteArray literalBytes; if (termString.startsWith("\"")) { literalBytes = termString.mid(1, sepPos - 1).toUtf8(); // remove quotes } else { literalBytes = termString.mid(0, sepPos).toUtf8(); } librdf_uri* datatypeUri = librdf_new_uri(world, (const unsigned char*)datatypeBytes.constData()); node = librdf_new_node_from_typed_literal(world, (const unsigned char*)literalBytes.constData(), NULL, datatypeUri); } else if (termData->isVariableTerm()) { CExpressionVariable* varExp = nullptr; CBuildExpression* varBuildExp = nullptr; QString varString = getVariableName(termString); if (termType == CSPARQLBuildingParserTermData::CLASS_VARIABLE_TYPE) { auto exp = mOntoBuilder->getClassVariable(varString); varBuildExp = exp; varExp = exp; } else if (termType == CSPARQLBuildingParserTermData::OBJECT_PROPERTY_VARIABLE_TYPE) { auto exp = mOntoBuilder->getObjectPropertyVariable(varString); varBuildExp = exp; varExp = exp; } else if (termType == CSPARQLBuildingParserTermData::DATA_PROPERTY_VARIABLE_TYPE) { auto exp = mOntoBuilder->getDataPropertyVariable(varString); varBuildExp = exp; varExp = exp; } else if (termType == CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_VARIABLE_TYPE) { auto exp = mOntoBuilder->getIndividualVariable(varString, false); varBuildExp = exp; varExp = exp; } else if (termType == CSPARQLBuildingParserTermData::ANONYMOUS_INDIVIDUAL_VARIABLE_TYPE) { auto exp = mOntoBuilder->getIndividualVariable(varString, true); varBuildExp = exp; varExp = exp; } else if (termType == CSPARQLBuildingParserTermData::DATA_LITERAL_VARIABLE_TYPE) { auto exp = mOntoBuilder->getDataLiteralVariable(varString); varBuildExp = exp; varExp = exp; } if (varExp) { varExpSet->insert(varExp); } QString replacedEntityString = termVariableExpressionNewEntityHash->value(varBuildExp); if (replacedEntityString.isEmpty()) { replacedEntityString = QString("http://konclude.com/temporary/variable-encoded-as-fresh-entity/%1").arg(newEntityNumber++); termVariableExpressionNewEntityHash->insert(varBuildExp, replacedEntityString); } QByteArray bytes = replacedEntityString.toUtf8(); raptor_uri* uri = (raptor_uri*)librdf_new_uri(world, (const unsigned char*)bytes.constData()); node = librdf_new_node_from_uri(world, uri); } reuseExpHash->insert(termData, node); return node; } CRedlandStoredTriplesData* CSPARQLExtendedMappingBuildingParser::getUpdatingTripleData() { CRedlandStoredTriplesData* prevTripleData = nullptr; CRedlandStoredTriplesData* tripleData = nullptr; if (!tripleData) { tripleData = new CRedlandStoredTriplesData(); tripleData->initTriplesData(CTRIPLES_DATA_UPDATE_TYPE::TRIPLES_DATA_QUERYING, prevTripleData); } librdf_world* world = tripleData->getRedlandWorld(); if (!world) { world = librdf_new_world(); librdf_world_open(world); tripleData->setRedlandWorldData(world); } librdf_storage* indexedStorage = tripleData->getRedlandIndexedStorage(); if (!indexedStorage && world) { indexedStorage = librdf_new_storage(world, "hashes", NULL, "hash-type='memory',index-predicates='yes'"); tripleData->setRedlandIndexedStorageData(indexedStorage); } librdf_model* indexedModel = tripleData->getRedlandIndexedModel(); if (!indexedModel && indexedStorage) { indexedModel = librdf_new_model(world, indexedStorage, NULL); tripleData->setRedlandIndexedModelData(indexedModel); } if (!indexedModel) { delete tripleData; tripleData = nullptr; } return tripleData; } QList* CSPARQLExtendedMappingBuildingParser::createTermTripleData(QHash* subjectTripleHash) { QHash termStringDataHash; QList* tripleDataList = new QList(); for (QHash::const_iterator it = subjectTripleHash->constBegin(), itEnd = subjectTripleHash->constEnd(); it != itEnd; ++it) { const QString& subjectString = it.key(); const CRDFHahsedSubjectData& subjectData = it.value(); CSPARQLBuildingParserTermData* term1 = getTermData(subjectString, &termStringDataHash); CSPARQLBuildingParserTermData* term2 = getTermData(subjectData.string[0], &termStringDataHash); CSPARQLBuildingParserTermData* term3 = getTermData(subjectData.string[1], &termStringDataHash); CSPARQLBuildingParserTripleData* triple = new CSPARQLBuildingParserTripleData(term1, term2, term3); tripleDataList->append(triple); } return tripleDataList; } QList* CSPARQLExtendedMappingBuildingParser::createTermTripleData(QList* tripleStringList) { QHash termStringDataHash; QList* tripleDataList = new QList(); for (CRDFStringTriple& tripleStringData : *tripleStringList) { CSPARQLBuildingParserTermData* term1 = getTermData(tripleStringData.string[0], &termStringDataHash); CSPARQLBuildingParserTermData* term2 = getTermData(tripleStringData.string[1], &termStringDataHash); CSPARQLBuildingParserTermData* term3 = getTermData(tripleStringData.string[2], &termStringDataHash); CSPARQLBuildingParserTripleData* triple = new CSPARQLBuildingParserTripleData(term1, term2, term3); tripleDataList->append(triple); } return tripleDataList; } CSPARQLBuildingParserTermData* CSPARQLExtendedMappingBuildingParser::getTermData(const QString& termString, QHash* termStringDataHash) { CSPARQLBuildingParserTermData*& termData = (*termStringDataHash)[termString]; if (!termData) { termData = new CSPARQLBuildingParserTermData(termString); } return termData; } bool CSPARQLExtendedMappingBuildingParser::analyseTermTripleDataRequiresExtendedMapping(QList* tripleList, bool anonymousIndividualsAsVariables) { bool updated = true; bool mappingRequired = false; for (CSPARQLBuildingParserTripleData* tripleData : *tripleList) { if (!tripleData->areTermsCompletelyTyped()) { for (cint64 i = 0; i < 3; ++i) { CSPARQLBuildingParserTermData* term = tripleData->getTermData(i); if (term->getTermType() == CSPARQLBuildingParserTermData::UNKNON_TYPE) { const QString& termString = term->getTermString(); if (termString.startsWith("?") || termString.startsWith("$")) { term->setTermType(CSPARQLBuildingParserTermData::VARIABLE_TYPE); } else if (termString.startsWith("_:")) { term->setTermType(CSPARQLBuildingParserTermData::BLANK_NODE_TYPE); } else if (termString.startsWith("\"")) { term->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE); } else { term->setTermType(CSPARQLBuildingParserTermData::RESOURCE_TYPE); } } } } } QSet predClassConSet; predClassConSet.insert(PREFIX_RDFS_SUBCLASS_OF); predClassConSet.insert(PREFIX_OWL_DISJOINT_WITH); predClassConSet.insert(PREFIX_OWL_DISJOINT_UNION_OF); QSet mapReqPredClassConSet; mapReqPredClassConSet.insert(PREFIX_OWL_INTERSECTION_OF); mapReqPredClassConSet.insert(PREFIX_OWL_UNION_OF); mapReqPredClassConSet.insert(PREFIX_OWL_COMPLEMENT_OF); mapReqPredClassConSet.insert(PREFIX_OWL_SOME_VALUES_FROM); mapReqPredClassConSet.insert(PREFIX_OWL_ALL_VALUES_FROM); mapReqPredClassConSet.insert(PREFIX_OWL_ALL_DISJOINT_CLASSES); QSet mapReqPredClassSingConSet; mapReqPredClassSingConSet.insert(PREFIX_OWL_MIN_CARDINALITY); mapReqPredClassSingConSet.insert(PREFIX_OWL_MAX_CARDINALITY); mapReqPredClassSingConSet.insert(PREFIX_OWL_CARDINALITY); mapReqPredClassSingConSet.insert(PREFIX_OWL_MIN_QUALIFIED_CARDINALITY); mapReqPredClassSingConSet.insert(PREFIX_OWL_MAX_QUALIFIED_CARDINALITY); mapReqPredClassSingConSet.insert(PREFIX_OWL_QUALIFIED_CARDINALITY); mapReqPredClassSingConSet.insert(PREFIX_OWL_ON_DATA_RANGE); CBUILDHASH* objPropEntityBuildHash = mOntology->getBuildData()->getObjectPropertyEntityBuildHash(); CBUILDHASH* dataPropEntityBuildHash = mOntology->getBuildData()->getDataPropertyEntityBuildHash(); while (updated) { updated = false; for (CSPARQLBuildingParserTripleData* tripleData : *tripleList) { if (!tripleData->areTermsCompletelyTyped()) { CSPARQLBuildingParserTermData* term1 = tripleData->getTermData(0); CSPARQLBuildingParserTermData* term2 = tripleData->getTermData(1); CSPARQLBuildingParserTermData* term3 = tripleData->getTermData(2); if (term2->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) { const QString& term2String = term2->getTermString(); const QString& term3String = term3->getTermString(); if (objPropEntityBuildHash->contains(term2String)) { makeIndividualTerm(term1, anonymousIndividualsAsVariables); makeIndividualTerm(term3, anonymousIndividualsAsVariables); } else if (dataPropEntityBuildHash->contains(term2String)) { makeIndividualTerm(term1, anonymousIndividualsAsVariables); makeDataLiteralTerm(term3); } if (predClassConSet.contains(term2String)) { updated |= makeClassTerm(term1); updated |= makeClassTerm(term3); } else if (mapReqPredClassConSet.contains(term2String)) { updated |= makeClassTerm(term1); updated |= makeClassTerm(term3); mappingRequired = true; } else if (mapReqPredClassSingConSet.contains(term2String)) { updated |= makeClassTerm(term1); mappingRequired = true; } if (term2String == PREFIX_RDFS_SUBPROPERTY_OF) { bool dataProp = term1->isDataPropertyTerm() || term3->isDataPropertyTerm(); bool objectProp = term1->isObjectPropertyTerm() || term3->isObjectPropertyTerm(); if (dataProp && !objectProp) { updated |= makeDataPropertyTerm(term1); updated |= makeDataPropertyTerm(term3); } else if (!dataProp && objectProp) { updated |= makeObjectPropertyTerm(term1); updated |= makeObjectPropertyTerm(term3); } else { updated |= makePropertyTerm(term1); updated |= makePropertyTerm(term3); } } if (term2String == PREFIX_RDF_TYPE) { if (term3->isClassTerm() && !term1->isCompletelyTyped()) { makeIndividualTerm(term1, anonymousIndividualsAsVariables); } if (term3String == PREFIX_OWL_OBJECT_PROPERTY) { updated |= makeObjectPropertyTerm(term1); } else if (term3String == PREFIX_OWL_DATATYPE_PROPERTY) { updated |= makeDataPropertyTerm(term1); } else if (term3String == PREFIX_OWL_CLASS) { updated |= makeClassTerm(term1); } else if (term3String == PREFIX_OWL_RESTRICTION) { updated |= makeClassTerm(term1); mappingRequired = true; } else if (term3String == PREFIX_OWL_NAMED_INDIVIDUAL) { updated |= makeIndividualTerm(term1, anonymousIndividualsAsVariables); } else if (term3String == PREFIX_RDFS_DATATYPE) { updated |= makeDataLiteralTerm(term1); } } if (term2String == PREFIX_RDF_FIRST || term2String == PREFIX_RDF_REST) { if (term3->getTermString() != PREFIX_RDF_NIL) { if (term1->isCompletelyTyped() && !term3->isCompletelyTyped()) { updated |= makeTermTypedBasedOnTerm(term3, term1, anonymousIndividualsAsVariables); } if (!term1->isCompletelyTyped() && term3->isCompletelyTyped()) { updated |= makeTermTypedBasedOnTerm(term1, term3, anonymousIndividualsAsVariables); } } } else if (term2String == PREFIX_OWL_ONE_OF) { updated |= makeClassTerm(term1); updated |= makeIndividualTerm(term3, anonymousIndividualsAsVariables); mappingRequired = true; } else if (term2String == PREFIX_OWL_HAS_VALUE) { mappingRequired = true; updated |= makeClassTerm(term1); } else if (term2String == PREFIX_OWL_ON_PROPERTY) { mappingRequired = true; updated |= makeClassTerm(term1); updated |= makePropertyTerm(term3); } else if (term2String == PREFIX_OWL_INVERSE_OF) { mappingRequired = true; updated |= makePropertyTerm(term1); updated |= makePropertyTerm(term3); if (term1->isCompletelyTyped() && !term3->isCompletelyTyped()) { updated |= makeTermTypedBasedOnTerm(term3, term1, anonymousIndividualsAsVariables); } if (!term1->isCompletelyTyped() && term3->isCompletelyTyped()) { updated |= makeTermTypedBasedOnTerm(term1, term3, anonymousIndividualsAsVariables); } } } } } } return mappingRequired; } bool CSPARQLExtendedMappingBuildingParser::makeTermTypedBasedOnTerm(CSPARQLBuildingParserTermData* termData, CSPARQLBuildingParserTermData* baseData, bool anonymousIndividualsAsVariables) { if (baseData->isClassTerm()) { return makeClassTerm(termData); } else if (baseData->isObjectPropertyTerm()) { return makeObjectPropertyTerm(termData); } else if (baseData->isDataPropertyTerm()) { return makeDataPropertyTerm(termData); } else if (baseData->isIndividualTerm()) { return makeIndividualTerm(termData, anonymousIndividualsAsVariables); } else if (baseData->isLiteralTerm()) { return makeDataLiteralTerm(termData); } return false; } bool CSPARQLExtendedMappingBuildingParser::makeIndividualTerm(CSPARQLBuildingParserTermData* termData, bool anonymousIndividualsAsVariables) { if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_VARIABLE_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::NAMED_INDIVIDUAL_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) { if (anonymousIndividualsAsVariables) { termData->setTermType(CSPARQLBuildingParserTermData::ANONYMOUS_INDIVIDUAL_VARIABLE_TYPE); } else { termData->setTermType(CSPARQLBuildingParserTermData::ANONYMOUS_INDIVIDUAL_TYPE); } return true; } return false; } bool CSPARQLExtendedMappingBuildingParser::makeClassTerm(CSPARQLBuildingParserTermData* termData) { if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::CLASS_VARIABLE_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::CLASS_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::CLASS_TYPE); return true; } return false; } bool CSPARQLExtendedMappingBuildingParser::makePropertyTerm(CSPARQLBuildingParserTermData* termData) { if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::PROPERTY_VARIABLE_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::PROPERTY_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::PROPERTY_TYPE); return true; } return false; } bool CSPARQLExtendedMappingBuildingParser::makeObjectPropertyTerm(CSPARQLBuildingParserTermData* termData) { if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_VARIABLE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::OBJECT_PROPERTY_VARIABLE_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::OBJECT_PROPERTY_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::OBJECT_PROPERTY_TYPE); return true; } return false; } bool CSPARQLExtendedMappingBuildingParser::makeDataPropertyTerm(CSPARQLBuildingParserTermData* termData) { if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_VARIABLE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::DATA_PROPERTY_VARIABLE_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE || termData->getTermType() == CSPARQLBuildingParserTermData::PROPERTY_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::DATA_PROPERTY_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::DATA_PROPERTY_TYPE); return true; } return false; } bool CSPARQLExtendedMappingBuildingParser::makeDataLiteralTerm(CSPARQLBuildingParserTermData* termData) { if (termData->getTermType() == CSPARQLBuildingParserTermData::VARIABLE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_VARIABLE_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::RESOURCE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE); return true; } if (termData->getTermType() == CSPARQLBuildingParserTermData::BLANK_NODE_TYPE) { termData->setTermType(CSPARQLBuildingParserTermData::DATA_LITERAL_TYPE); return true; } return false; } QList CSPARQLExtendedMappingBuildingParser::handlingMappingRequiredTermTripleData(QList* tripleDataList, bool anonymousIndividualsAsVariables, QSet* varExpSet) { QList axList; CRedlandStoredTriplesData* triplesData = getUpdatingTripleData(); librdf_world* world = triplesData->getRedlandWorld(); librdf_model* model = triplesData->getRedlandIndexedModel(); CConcreteOntologyRedlandTriplesDataQueryingExpressionMapper* expressionMapper = new CConcreteOntologyRedlandTriplesDataQueryingExpressionMapper(mOntoBuilder); QHash reuseExpHash; QHash termVariableExpressionNewEntityHash; cint64 newEntityNumber = 0; CXLinker* statementLinker = nullptr; CXLinker* lastStatementLinker = nullptr; for (CSPARQLBuildingParserTripleData* tripleData : *tripleDataList) { librdf_node* subjectNode = getRedlandRDFNode(tripleData->getTermData(0), triplesData, &reuseExpHash, &termVariableExpressionNewEntityHash, newEntityNumber, varExpSet); librdf_node* predicateNode = getRedlandRDFNode(tripleData->getTermData(1), triplesData, &reuseExpHash, &termVariableExpressionNewEntityHash, newEntityNumber, varExpSet); librdf_node* objectNode = getRedlandRDFNode(tripleData->getTermData(2), triplesData, &reuseExpHash, &termVariableExpressionNewEntityHash, newEntityNumber, varExpSet); librdf_statement* statement = librdf_new_statement_from_nodes(world, subjectNode, predicateNode, objectNode); librdf_statement* newStatement = librdf_new_statement_from_statement(statement); librdf_model_add_statement(model, newStatement); CXLinker* newStatementLinker = new CXLinker(); newStatementLinker->initLinker(statement, nullptr); if (statementLinker) { lastStatementLinker->setNext(newStatementLinker); lastStatementLinker = newStatementLinker; } else { statementLinker = newStatementLinker; lastStatementLinker = newStatementLinker; } } triplesData->setRedlandStatementLinker(statementLinker); QHash freshEntityUseVariableExpressionHash; for (QHash::const_iterator it = termVariableExpressionNewEntityHash.constBegin(), itEnd = termVariableExpressionNewEntityHash.constEnd(); it != itEnd; ++it) { freshEntityUseVariableExpressionHash.insert(it.value(), it.key()); } expressionMapper->useEntitiesVariableExpressionMapping(freshEntityUseVariableExpressionHash, triplesData); COntologyTriplesData ontTripData; ontTripData.addTriplesData(triplesData); expressionMapper->mapTriples(mOntology, &ontTripData); axList = expressionMapper->takeQueryingCollectedAxiomExpressions(); return axList; } }; // end namespace Parser }; // end namespace Konclude #endif // KONCLUDE_REDLAND_INTEGRATION