| 1 |
// Copyright 2011-2015 David Robillard <[email protected]> |
| 2 |
// SPDX-License-Identifier: ISC |
| 3 |
|
| 4 |
#include <serd/serd.h> |
| 5 |
#include <sord/sord.h> |
| 6 |
|
| 7 |
#include <stdbool.h> |
| 8 |
#include <stdint.h> |
| 9 |
#include <stdlib.h> |
| 10 |
#include <string.h> |
| 11 |
|
| 12 |
struct SordInserterImpl { |
| 13 |
SordModel* model; |
| 14 |
SerdEnv* env; |
| 15 |
}; |
| 16 |
|
| 17 |
SordInserter* |
| 18 |
sord_inserter_new(SordModel* model, SerdEnv* env) |
| 19 |
{ |
| 20 |
SordInserter* inserter = (SordInserter*)malloc(sizeof(SordInserter)); |
| 21 |
inserter->model = model; |
| 22 |
inserter->env = env; |
| 23 |
return inserter; |
| 24 |
} |
| 25 |
|
| 26 |
void |
| 27 |
sord_inserter_free(SordInserter* inserter) |
| 28 |
{ |
| 29 |
free(inserter); |
| 30 |
} |
| 31 |
|
| 32 |
SerdStatus |
| 33 |
sord_inserter_set_base_uri(SordInserter* inserter, const SerdNode* uri) |
| 34 |
{ |
| 35 |
return serd_env_set_base_uri(inserter->env, uri); |
| 36 |
} |
| 37 |
|
| 38 |
SerdStatus |
| 39 |
sord_inserter_set_prefix(SordInserter* inserter, |
| 40 |
const SerdNode* name, |
| 41 |
const SerdNode* uri) |
| 42 |
{ |
| 43 |
return serd_env_set_prefix(inserter->env, name, uri); |
| 44 |
} |
| 45 |
|
| 46 |
SerdStatus |
| 47 |
sord_inserter_write_statement(SordInserter* inserter, |
| 48 |
SerdStatementFlags flags, |
| 49 |
const SerdNode* graph, |
| 50 |
const SerdNode* subject, |
| 51 |
const SerdNode* predicate, |
| 52 |
const SerdNode* object, |
| 53 |
const SerdNode* object_datatype, |
| 54 |
const SerdNode* object_lang) |
| 55 |
{ |
| 56 |
(void)flags; |
| 57 |
|
| 58 |
SordWorld* world = sord_get_world(inserter->model); |
| 59 |
SerdEnv* env = inserter->env; |
| 60 |
|
| 61 |
SordNode* g = sord_node_from_serd_node(world, env, graph, NULL, NULL); |
| 62 |
SordNode* s = sord_node_from_serd_node(world, env, subject, NULL, NULL); |
| 63 |
SordNode* p = sord_node_from_serd_node(world, env, predicate, NULL, NULL); |
| 64 |
SordNode* o = |
| 65 |
sord_node_from_serd_node(world, env, object, object_datatype, object_lang); |
| 66 |
|
| 67 |
if (!s || !p || !o) { |
| 68 |
return SERD_ERR_BAD_ARG; |
| 69 |
} |
| 70 |
|
| 71 |
const SordQuad tup = {s, p, o, g}; |
| 72 |
sord_add(inserter->model, tup); |
| 73 |
|
| 74 |
sord_node_free(world, o); |
| 75 |
sord_node_free(world, p); |
| 76 |
sord_node_free(world, s); |
| 77 |
sord_node_free(world, g); |
| 78 |
|
| 79 |
return SERD_SUCCESS; |
| 80 |
} |
| 81 |
|
| 82 |
SORD_API SerdReader* |
| 83 |
sord_new_reader(SordModel* model, |
| 84 |
SerdEnv* env, |
| 85 |
SerdSyntax syntax, |
| 86 |
const SordNode* graph) |
| 87 |
{ |
| 88 |
SordInserter* inserter = sord_inserter_new(model, env); |
| 89 |
|
| 90 |
SerdReader* reader = |
| 91 |
serd_reader_new(syntax, |
| 92 |
inserter, |
| 93 |
(void (*)(void* ptr))sord_inserter_free, |
| 94 |
(SerdBaseSink)sord_inserter_set_base_uri, |
| 95 |
(SerdPrefixSink)sord_inserter_set_prefix, |
| 96 |
(SerdStatementSink)sord_inserter_write_statement, |
| 97 |
NULL); |
| 98 |
|
| 99 |
if (graph) { |
| 100 |
serd_reader_set_default_graph(reader, sord_node_to_serd_node(graph)); |
| 101 |
} |
| 102 |
|
| 103 |
return reader; |
| 104 |
} |
| 105 |
|
| 106 |
static SerdStatus |
| 107 |
write_statement(SordModel* sord, |
| 108 |
SerdWriter* writer, |
| 109 |
SordQuad tup, |
| 110 |
SerdStatementFlags flags) |
| 111 |
{ |
| 112 |
const SordNode* s = tup[SORD_SUBJECT]; |
| 113 |
const SordNode* p = tup[SORD_PREDICATE]; |
| 114 |
const SordNode* o = tup[SORD_OBJECT]; |
| 115 |
const SordNode* d = sord_node_get_datatype(o); |
| 116 |
const SerdNode* ss = sord_node_to_serd_node(s); |
| 117 |
const SerdNode* sp = sord_node_to_serd_node(p); |
| 118 |
const SerdNode* so = sord_node_to_serd_node(o); |
| 119 |
const SerdNode* sd = sord_node_to_serd_node(d); |
| 120 |
|
| 121 |
const char* lang_str = sord_node_get_language(o); |
| 122 |
size_t lang_len = lang_str ? strlen(lang_str) : 0; |
| 123 |
SerdNode language = SERD_NODE_NULL; |
| 124 |
if (lang_str) { |
| 125 |
language.type = SERD_LITERAL; |
| 126 |
language.n_bytes = lang_len; |
| 127 |
language.n_chars = lang_len; |
| 128 |
language.buf = (const uint8_t*)lang_str; |
| 129 |
} |
| 130 |
|
| 131 |
// TODO: Subject abbreviation |
| 132 |
|
| 133 |
if (sord_node_is_inline_object(s) && !(flags & SERD_ANON_CONT)) { |
| 134 |
return SERD_SUCCESS; |
| 135 |
} |
| 136 |
|
| 137 |
SerdStatus st = SERD_SUCCESS; |
| 138 |
if (sord_node_is_inline_object(o)) { |
| 139 |
SordQuad sub_pat = {o, 0, 0, 0}; |
| 140 |
SordIter* sub_iter = sord_find(sord, sub_pat); |
| 141 |
|
| 142 |
SerdStatementFlags start_flags = |
| 143 |
flags | ((sub_iter) ? SERD_ANON_O_BEGIN : SERD_EMPTY_O); |
| 144 |
|
| 145 |
st = serd_writer_write_statement( |
| 146 |
writer, start_flags, NULL, ss, sp, so, sd, &language); |
| 147 |
|
| 148 |
if (!st && sub_iter) { |
| 149 |
flags |= SERD_ANON_CONT; |
| 150 |
for (; !st && !sord_iter_end(sub_iter); sord_iter_next(sub_iter)) { |
| 151 |
SordQuad sub_tup; |
| 152 |
sord_iter_get(sub_iter, sub_tup); |
| 153 |
st = write_statement(sord, writer, sub_tup, flags); |
| 154 |
} |
| 155 |
serd_writer_end_anon(writer, so); |
| 156 |
} |
| 157 |
sord_iter_free(sub_iter); |
| 158 |
} else { |
| 159 |
st = serd_writer_write_statement( |
| 160 |
writer, flags, NULL, ss, sp, so, sd, &language); |
| 161 |
} |
| 162 |
|
| 163 |
return st; |
| 164 |
} |
| 165 |
|
| 166 |
bool |
| 167 |
sord_write(SordModel* model, SerdWriter* writer, const SordNode* graph) |
| 168 |
{ |
| 169 |
SordQuad pat = {0, 0, 0, graph}; |
| 170 |
SordIter* iter = sord_find(model, pat); |
| 171 |
return sord_write_iter(iter, writer); |
| 172 |
} |
| 173 |
|
| 174 |
static bool |
| 175 |
sord_write_iter_internal(SordIter* iter, SerdWriter* writer) |
| 176 |
{ |
| 177 |
SordModel* model = (SordModel*)sord_iter_get_model(iter); |
| 178 |
SerdStatus st = SERD_SUCCESS; |
| 179 |
for (; !st && !sord_iter_end(iter); sord_iter_next(iter)) { |
| 180 |
SordQuad tup; |
| 181 |
sord_iter_get(iter, tup); |
| 182 |
st = write_statement(model, writer, tup, 0); |
| 183 |
} |
| 184 |
sord_iter_free(iter); |
| 185 |
|
| 186 |
return !st; |
| 187 |
} |
| 188 |
|
| 189 |
bool |
| 190 |
sord_write_iter(SordIter* iter, SerdWriter* writer) |
| 191 |
{ |
| 192 |
return iter ? sord_write_iter_internal(iter, writer) : false; |
| 193 |
} |