| 1 |
/* |
| 2 |
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. |
| 3 |
* |
| 4 |
* This file is part of the reasoning system Konclude. |
| 5 |
* For details and support, see <http://konclude.com/>. |
| 6 |
* |
| 7 |
* Konclude is free software: you can redistribute it and/or modify |
| 8 |
* it under the terms of version 3 of the GNU Lesser General Public |
| 9 |
* License (LGPLv3) as published by the Free Software Foundation. |
| 10 |
* |
| 11 |
* Konclude is distributed in the hope that it will be useful, |
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 |
* GNU (Lesser) General Public License for more details. |
| 15 |
* |
| 16 |
* You should have received a copy of the GNU (Lesser) General Public |
| 17 |
* License along with Konclude. If not, see <http://www.gnu.org/licenses/>. |
| 18 |
* |
| 19 |
*/ |
| 20 |
#ifdef KONCLUDE_REDLAND_INTEGRATION |
| 21 |
|
| 22 |
#include "COntologyRedlandRDFRenderer.h" |
| 23 |
|
| 24 |
|
| 25 |
namespace Konclude { |
| 26 |
|
| 27 |
namespace Renderer { |
| 28 |
|
| 29 |
|
| 30 |
COntologyRedlandRDFRenderer::COntologyRedlandRDFRenderer(librdf_world* world) { |
| 31 |
mBlankNodeIdentifierPrefix = QString("kbni_%1_").arg(QUuid::createUuid().toString().replace("{", "").replace("}",""));; |
| 32 |
//mBlankNodeIdentifierPrefix = QString("konclude_redland_rdf_rendering_blank_node_identifier_"); |
| 33 |
|
| 34 |
mTmpRenderedNodeItemLinker = nullptr; |
| 35 |
mTmpRenderedTripleItemLinker = nullptr; |
| 36 |
|
| 37 |
mDefaultDatatypeString = PREFIX_XML_STRING_DATATYPE; |
| 38 |
|
| 39 |
|
| 40 |
mWorld = world; |
| 41 |
if (!mWorld) { |
| 42 |
mWorld = librdf_new_world(); |
| 43 |
librdf_world_open(mWorld); |
| 44 |
} |
| 45 |
|
| 46 |
initRenderedNodeItems(); |
| 47 |
} |
| 48 |
|
| 49 |
COntologyRedlandRDFRenderer::~COntologyRedlandRDFRenderer() { |
| 50 |
} |
| 51 |
|
| 52 |
|
| 53 |
|
| 54 |
|
| 55 |
|
| 56 |
CRedlandStoredTriplesData* COntologyRedlandRDFRenderer::getRenderedTripleData(CRedlandStoredTriplesData* tripleData) { |
| 57 |
|
| 58 |
if (!tripleData) { |
| 59 |
tripleData = new CRedlandStoredTriplesData(); |
| 60 |
tripleData->initTriplesData(CTRIPLES_DATA_UPDATE_TYPE::TRIPLES_DATA_QUERYING, nullptr); |
| 61 |
} |
| 62 |
|
| 63 |
bool inMemory = false; |
| 64 |
librdf_storage* indexedStorage = tripleData->getRedlandIndexedStorage(); |
| 65 |
if (!indexedStorage && mWorld) { |
| 66 |
indexedStorage = librdf_new_storage(mWorld, "memory", NULL, "contexts='yes'"); |
| 67 |
tripleData->setRedlandIndexedStorageData(indexedStorage); |
| 68 |
inMemory = true; |
| 69 |
} |
| 70 |
|
| 71 |
librdf_model* indexedModel = tripleData->getRedlandIndexedModel(); |
| 72 |
if (!indexedModel && indexedStorage) { |
| 73 |
indexedModel = librdf_new_model(mWorld, indexedStorage, NULL); |
| 74 |
tripleData->setRedlandIndexedModelData(indexedModel); |
| 75 |
} |
| 76 |
|
| 77 |
|
| 78 |
CXLinker<librdf_statement*>* firstLinker = nullptr; |
| 79 |
CXLinker<librdf_statement*>* lastLinker = nullptr; |
| 80 |
|
| 81 |
if (indexedModel) { |
| 82 |
addRenderedTripleItemLinkerToTripleData(mListRenderedItemLinker, firstLinker, lastLinker); |
| 83 |
addRenderedTripleItemLinkerToTripleData(mFacetRenderedItemLinker, firstLinker, lastLinker); |
| 84 |
addRenderedTripleItemLinkerToTripleData(mObjRenderedItemLinker, firstLinker, lastLinker); |
| 85 |
addRenderedTripleItemLinkerToTripleData(mAxiomRenderedItemLinker, firstLinker, lastLinker); |
| 86 |
QByteArray bytes = QString("http://test.de").toUtf8(); |
| 87 |
raptor_uri* uri = (raptor_uri*)librdf_new_uri(mWorld, (const unsigned char*)bytes.constData()); |
| 88 |
librdf_node* conNode = librdf_new_node_from_uri(mWorld, uri); |
| 89 |
if (firstLinker) { |
| 90 |
tripleData->setRedlandStatementLinker(firstLinker); |
| 91 |
|
| 92 |
for (CXLinker<librdf_statement*>* linkerIt = firstLinker; linkerIt; linkerIt = linkerIt->getNext()) { |
| 93 |
librdf_statement* statement = linkerIt->getData(); |
| 94 |
librdf_statement* statementCopy = librdf_new_statement_from_statement(statement); |
| 95 |
if (inMemory) { |
| 96 |
librdf_storage_context_add_statement(indexedStorage, conNode, statementCopy); |
| 97 |
} else { |
| 98 |
librdf_model_add_statement(indexedModel, statementCopy); |
| 99 |
} |
| 100 |
} |
| 101 |
} |
| 102 |
} else { |
| 103 |
delete tripleData; |
| 104 |
tripleData = nullptr; |
| 105 |
} |
| 106 |
|
| 107 |
return tripleData; |
| 108 |
|
| 109 |
} |
| 110 |
|
| 111 |
|
| 112 |
|
| 113 |
COntologyRedlandRDFRenderer* COntologyRedlandRDFRenderer::addRenderedTripleItemLinkerToTripleData(CRenderedRDFTripleItemBaseLinker* renderedItemLinker, CXLinker<librdf_statement*>*& firstLinker, CXLinker<librdf_statement*>*& lastLinker) { |
| 114 |
for (CRenderedRDFTripleItemBaseLinker* renderedItemLinkerIt = renderedItemLinker; renderedItemLinkerIt; renderedItemLinkerIt = renderedItemLinkerIt->getNextItemLinker()) { |
| 115 |
CRenderedRedlandRDFTripleItemBaseLinker* redlandRenderedItemLinker = (CRenderedRedlandRDFTripleItemBaseLinker*)renderedItemLinkerIt; |
| 116 |
CXLinker<librdf_statement*>* nextLinker = new CXLinker<librdf_statement *>(); |
| 117 |
nextLinker->initLinker(redlandRenderedItemLinker->getRedlandTripleStatement()); |
| 118 |
if (lastLinker) { |
| 119 |
lastLinker->setNext(nextLinker); |
| 120 |
lastLinker = nextLinker; |
| 121 |
} else { |
| 122 |
firstLinker = lastLinker = nextLinker; |
| 123 |
} |
| 124 |
} |
| 125 |
return this; |
| 126 |
} |
| 127 |
|
| 128 |
|
| 129 |
|
| 130 |
CRenderedRDFTripleItemBaseLinker* COntologyRedlandRDFRenderer::createRenderedTripleItemLinker() { |
| 131 |
CRenderedRedlandRDFTripleItemBaseLinker* linker = mTmpRenderedTripleItemLinker; |
| 132 |
if (linker) { |
| 133 |
mTmpRenderedTripleItemLinker = (CRenderedRedlandRDFTripleItemBaseLinker*)mTmpRenderedTripleItemLinker->getNextItemLinker(); |
| 134 |
linker->clearNext(); |
| 135 |
} else { |
| 136 |
linker = new CRenderedRedlandRDFTripleItemBaseLinker(); |
| 137 |
mRenderedTripleItemContainer.append(linker); |
| 138 |
} |
| 139 |
return linker; |
| 140 |
} |
| 141 |
|
| 142 |
COntologyRedlandRDFRenderer* COntologyRedlandRDFRenderer::releaseRenderedTripleItemLinkers(CRenderedItemLinker* linkers) { |
| 143 |
if (linkers) { |
| 144 |
for (CRenderedRedlandRDFTripleItemBaseLinker* linkerIt = (CRenderedRedlandRDFTripleItemBaseLinker*)linkers; linkerIt; linkerIt = (CRenderedRedlandRDFTripleItemBaseLinker*)linkerIt->getNextItemLinker()) { |
| 145 |
linkerIt->clearRedlandTripleStatement(); |
| 146 |
} |
| 147 |
mTmpRenderedTripleItemLinker = (CRenderedRedlandRDFTripleItemBaseLinker*)linkers->append(mTmpRenderedTripleItemLinker); |
| 148 |
} |
| 149 |
return this; |
| 150 |
} |
| 151 |
|
| 152 |
CRenderedRDFNodeItemBaseLinker* COntologyRedlandRDFRenderer::createRenderedNodeItemLinker() { |
| 153 |
CRenderedRedlandRDFNodeItemBaseLinker* linker = mTmpRenderedNodeItemLinker; |
| 154 |
if (linker) { |
| 155 |
mTmpRenderedNodeItemLinker = (CRenderedRedlandRDFNodeItemBaseLinker*)mTmpRenderedNodeItemLinker->getNextItemLinker(); |
| 156 |
linker->clearNext(); |
| 157 |
} else { |
| 158 |
linker = new CRenderedRedlandRDFNodeItemBaseLinker(); |
| 159 |
mRenderedNodeItemContainer.append(linker); |
| 160 |
} |
| 161 |
return linker; |
| 162 |
} |
| 163 |
|
| 164 |
COntologyRedlandRDFRenderer* COntologyRedlandRDFRenderer::releaseRenderedNodeItemLinkers(CRenderedItemLinker* linkers) { |
| 165 |
if (linkers) { |
| 166 |
for (CRenderedRedlandRDFNodeItemBaseLinker* linkerIt = (CRenderedRedlandRDFNodeItemBaseLinker*)linkers; linkerIt; linkerIt = (CRenderedRedlandRDFNodeItemBaseLinker*)linkerIt->getNextItemLinker()) { |
| 167 |
linkerIt->clearRedlandNode(); |
| 168 |
} |
| 169 |
mTmpRenderedNodeItemLinker = (CRenderedRedlandRDFNodeItemBaseLinker*)linkers->append(mTmpRenderedNodeItemLinker); |
| 170 |
} |
| 171 |
return this; |
| 172 |
} |
| 173 |
|
| 174 |
|
| 175 |
|
| 176 |
|
| 177 |
|
| 178 |
CRenderedRDFNodeItemBaseLinker* COntologyRedlandRDFRenderer::createRenderedIRIResourceNodeItem(const QString& iri) { |
| 179 |
CRenderedRedlandRDFNodeItemBaseLinker* nodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)createRenderedNodeItemLinker(); |
| 180 |
QByteArray bytes = iri.toUtf8(); |
| 181 |
raptor_uri* uri = (raptor_uri*)librdf_new_uri(mWorld, (const unsigned char*)bytes.constData()); |
| 182 |
librdf_node* node = librdf_new_node_from_uri(mWorld, uri); |
| 183 |
nodeItem->setRedlandNode(node); |
| 184 |
return nodeItem; |
| 185 |
} |
| 186 |
|
| 187 |
|
| 188 |
CRenderedRDFNodeItemBaseLinker* COntologyRedlandRDFRenderer::createRenderedBlankNodeItem(const QString& identifier) { |
| 189 |
CRenderedRedlandRDFNodeItemBaseLinker* nodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)createRenderedNodeItemLinker(); |
| 190 |
QByteArray bytes = identifier.toUtf8(); |
| 191 |
librdf_node* node = librdf_new_node_from_blank_identifier(mWorld, (const unsigned char*)bytes.constData()); |
| 192 |
nodeItem->setRedlandNode(node); |
| 193 |
return nodeItem; |
| 194 |
} |
| 195 |
|
| 196 |
CRenderedRDFNodeItemBaseLinker* COntologyRedlandRDFRenderer::createRenderedBlankNodeItem(cint64 id) { |
| 197 |
CRenderedRedlandRDFNodeItemBaseLinker* nodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)createRenderedNodeItemLinker(); |
| 198 |
QString identifier = QString("%1%2").arg(mBlankNodeIdentifierPrefix).arg(id); |
| 199 |
QByteArray bytes = identifier.toUtf8(); |
| 200 |
librdf_node* node = librdf_new_node_from_blank_identifier(mWorld, (const unsigned char*)bytes.constData()); |
| 201 |
nodeItem->setRedlandNode(node); |
| 202 |
return nodeItem; |
| 203 |
} |
| 204 |
|
| 205 |
CRenderedRDFNodeItemBaseLinker* COntologyRedlandRDFRenderer::createRenderedLiteralNodeItem(const QString& literal, const QString& datatype) { |
| 206 |
CRenderedRedlandRDFNodeItemBaseLinker* nodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)createRenderedNodeItemLinker(); |
| 207 |
QByteArray datatypeBytes = datatype.toUtf8(); |
| 208 |
librdf_uri* datatypeUri = nullptr; |
| 209 |
if (datatype != mDefaultDatatypeString) { |
| 210 |
librdf_new_uri(mWorld, (const unsigned char*)datatypeBytes.constData()); |
| 211 |
} |
| 212 |
QByteArray literalBytes = literal.toUtf8(); |
| 213 |
librdf_node* node = librdf_new_node_from_typed_literal(mWorld, (const unsigned char*)literalBytes.constData(), NULL, datatypeUri); |
| 214 |
nodeItem->setRedlandNode(node); |
| 215 |
return nodeItem; |
| 216 |
}; |
| 217 |
|
| 218 |
|
| 219 |
CRenderedRDFTripleItemBaseLinker* COntologyRedlandRDFRenderer::createTriple(CRenderedRDFNodeItemBaseLinker* subjectNodeItem, CRenderedRDFNodeItemBaseLinker* predicateNodeItem, CRenderedRDFNodeItemBaseLinker* objectNodeItem) { |
| 220 |
CRenderedRedlandRDFTripleItemBaseLinker* tripleItem = (CRenderedRedlandRDFTripleItemBaseLinker*)createRenderedTripleItemLinker(); |
| 221 |
tripleItem->setRDFNodeItem(0, subjectNodeItem); |
| 222 |
tripleItem->setRDFNodeItem(1, predicateNodeItem); |
| 223 |
tripleItem->setRDFNodeItem(2, objectNodeItem); |
| 224 |
CRenderedRedlandRDFNodeItemBaseLinker* redlandSubjectNodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)subjectNodeItem; |
| 225 |
CRenderedRedlandRDFNodeItemBaseLinker* redlandPredicateNodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)predicateNodeItem; |
| 226 |
CRenderedRedlandRDFNodeItemBaseLinker* redlandObjectNodeItem = (CRenderedRedlandRDFNodeItemBaseLinker*)objectNodeItem; |
| 227 |
librdf_statement* statement = librdf_new_statement_from_nodes(mWorld, librdf_new_node_from_node(redlandSubjectNodeItem->getRedlandNode()), librdf_new_node_from_node(redlandPredicateNodeItem->getRedlandNode()), librdf_new_node_from_node(redlandObjectNodeItem->getRedlandNode())); |
| 228 |
tripleItem->setRedlandTripleStatement(statement); |
| 229 |
return tripleItem; |
| 230 |
} |
| 231 |
|
| 232 |
|
| 233 |
}; // end namespace Renderer |
| 234 |
|
| 235 |
}; // end namespace Konclude |
| 236 |
|
| 237 |
#endif // !KONCLUDE_REDLAND_INTEGRATION |