Debian Codegraph @

Source/Renderer/COntologyRedlandRDFRenderer.cpp

raw
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