summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/sord.c181
-rw-r--r--src/syntax.c8
2 files changed, 95 insertions, 94 deletions
diff --git a/src/sord.c b/src/sord.c
index a2a4f07..c23b2c1 100644
--- a/src/sord.c
+++ b/src/sord.c
@@ -438,11 +438,11 @@ sord_iter_get_model(SordIter* iter)
}
void
-sord_iter_get(const SordIter* iter, SordQuad id)
+sord_iter_get(const SordIter* iter, SordQuad tup)
{
SordNode** key = (SordNode**)zix_btree_get(iter->cur);
for (int i = 0; i < TUP_LEN; ++i) {
- id[i] = key[i];
+ tup[i] = key[i];
}
}
@@ -546,14 +546,14 @@ sord_iter_free(SordIter* iter)
corresponding order with a G prepended (so G will be the MSN).
*/
static inline bool
-sord_has_index(SordModel* sord, SordOrder* order, int* n_prefix, bool graphs)
+sord_has_index(SordModel* model, SordOrder* order, int* n_prefix, bool graphs)
{
if (graphs) {
*order = (SordOrder)(*order + GSPO);
*n_prefix += 1;
}
- return sord->indices[*order];
+ return model->indices[*order];
}
/**
@@ -645,40 +645,40 @@ sord_best_index(SordModel* sord,
SordModel*
sord_new(SordWorld* world, unsigned indices, bool graphs)
{
- SordModel* sord = (SordModel*)malloc(sizeof(struct SordModelImpl));
- sord->world = world;
- sord->n_quads = 0;
- sord->n_iters = 0;
+ SordModel* model = (SordModel*)malloc(sizeof(struct SordModelImpl));
+ model->world = world;
+ model->n_quads = 0;
+ model->n_iters = 0;
for (unsigned i = 0; i < (NUM_ORDERS / 2); ++i) {
const int* const ordering = orderings[i];
const int* const g_ordering = orderings[i + (NUM_ORDERS / 2)];
if (indices & (1 << i)) {
- sord->indices[i] = zix_btree_new(
+ model->indices[i] = zix_btree_new(
sord_quad_compare, (void*)ordering, NULL);
if (graphs) {
- sord->indices[i + (NUM_ORDERS / 2)] = zix_btree_new(
+ model->indices[i + (NUM_ORDERS / 2)] = zix_btree_new(
sord_quad_compare, (void*)g_ordering, NULL);
} else {
- sord->indices[i + (NUM_ORDERS / 2)] = NULL;
+ model->indices[i + (NUM_ORDERS / 2)] = NULL;
}
} else {
- sord->indices[i] = NULL;
- sord->indices[i + (NUM_ORDERS / 2)] = NULL;
+ model->indices[i] = NULL;
+ model->indices[i + (NUM_ORDERS / 2)] = NULL;
}
}
- if (!sord->indices[DEFAULT_ORDER]) {
- sord->indices[DEFAULT_ORDER] = zix_btree_new(
+ if (!model->indices[DEFAULT_ORDER]) {
+ model->indices[DEFAULT_ORDER] = zix_btree_new(
sord_quad_compare, (void*)orderings[DEFAULT_ORDER], NULL);
}
- if (graphs && !sord->indices[DEFAULT_GRAPH_ORDER]) {
- sord->indices[DEFAULT_GRAPH_ORDER] = zix_btree_new(
+ if (graphs && !model->indices[DEFAULT_GRAPH_ORDER]) {
+ model->indices[DEFAULT_GRAPH_ORDER] = zix_btree_new(
sord_quad_compare, (void*)orderings[DEFAULT_GRAPH_ORDER], NULL);
}
- return sord;
+ return model;
}
static void
@@ -699,7 +699,7 @@ sord_node_free_internal(SordWorld* world, SordNode* node)
}
static void
-sord_add_quad_ref(SordModel* sord, const SordNode* node, SordQuadIndex i)
+sord_add_quad_ref(SordModel* model, const SordNode* node, SordQuadIndex i)
{
if (node) {
assert(node->refs > 0);
@@ -711,7 +711,7 @@ sord_add_quad_ref(SordModel* sord, const SordNode* node, SordQuadIndex i)
}
static void
-sord_drop_quad_ref(SordModel* sord, const SordNode* node, SordQuadIndex i)
+sord_drop_quad_ref(SordModel* model, const SordNode* node, SordQuadIndex i)
{
if (!node) {
return;
@@ -723,30 +723,30 @@ sord_drop_quad_ref(SordModel* sord, const SordNode* node, SordQuadIndex i)
--((SordNode*)node)->meta.res.refs_as_obj;
}
if (--((SordNode*)node)->refs == 0) {
- sord_node_free_internal(sord_get_world(sord), (SordNode*)node);
+ sord_node_free_internal(sord_get_world(model), (SordNode*)node);
}
}
void
-sord_free(SordModel* sord)
+sord_free(SordModel* model)
{
- if (!sord) {
+ if (!model) {
return;
}
// Free nodes
SordQuad tup;
- SordIter* i = sord_begin(sord);
+ SordIter* i = sord_begin(model);
for (; !sord_iter_end(i); sord_iter_next(i)) {
sord_iter_get(i, tup);
for (int t = 0; t < TUP_LEN; ++t) {
- sord_drop_quad_ref(sord, tup[t], (SordQuadIndex)t);
+ sord_drop_quad_ref(model, tup[t], (SordQuadIndex)t);
}
}
sord_iter_free(i);
// Free quads
- ZixBTreeIter* t = zix_btree_begin(sord->indices[DEFAULT_ORDER]);
+ ZixBTreeIter* t = zix_btree_begin(model->indices[DEFAULT_ORDER]);
for (; !zix_btree_iter_is_end(t); zix_btree_iter_increment(t)) {
free(zix_btree_get(t));
}
@@ -754,24 +754,24 @@ sord_free(SordModel* sord)
// Free indices
for (unsigned o = 0; o < NUM_ORDERS; ++o) {
- if (sord->indices[o]) {
- zix_btree_free(sord->indices[o]);
+ if (model->indices[o]) {
+ zix_btree_free(model->indices[o]);
}
}
- free(sord);
+ free(model);
}
SordWorld*
-sord_get_world(SordModel* sord)
+sord_get_world(SordModel* model)
{
- return sord->world;
+ return model->world;
}
size_t
-sord_num_quads(const SordModel* sord)
+sord_num_quads(const SordModel* model)
{
- return sord->n_quads;
+ return model->n_quads;
}
size_t
@@ -781,27 +781,27 @@ sord_num_nodes(const SordWorld* world)
}
SordIter*
-sord_begin(const SordModel* sord)
+sord_begin(const SordModel* model)
{
- if (sord_num_quads(sord) == 0) {
+ if (sord_num_quads(model) == 0) {
return NULL;
} else {
- ZixBTreeIter* cur = zix_btree_begin(sord->indices[DEFAULT_ORDER]);
+ ZixBTreeIter* cur = zix_btree_begin(model->indices[DEFAULT_ORDER]);
SordQuad pat = { 0, 0, 0, 0 };
- return sord_iter_new(sord, cur, pat, DEFAULT_ORDER, ALL, 0);
+ return sord_iter_new(model, cur, pat, DEFAULT_ORDER, ALL, 0);
}
}
SordIter*
-sord_find(SordModel* sord, const SordQuad pat)
+sord_find(SordModel* model, const SordQuad pat)
{
if (!pat[0] && !pat[1] && !pat[2] && !pat[3]) {
- return sord_begin(sord);
+ return sord_begin(model);
}
SearchMode mode;
int n_prefix;
- const SordOrder index_order = sord_best_index(sord, pat, &mode, &n_prefix);
+ const SordOrder index_order = sord_best_index(model, pat, &mode, &n_prefix);
SORD_FIND_LOG("Find " TUP_FMT " index=%s mode=%d n_prefix=%d\n",
TUP_FMT_ARGS(pat), order_names[index_order], mode, n_prefix);
@@ -810,7 +810,7 @@ sord_find(SordModel* sord, const SordQuad pat)
mode = SINGLE; // No duplicate quads (Sord is a set)
}
- ZixBTree* const db = sord->indices[index_order];
+ ZixBTree* const db = model->indices[index_order];
ZixBTreeIter* cur = NULL;
zix_btree_lower_bound(db, pat, &cur);
if (zix_btree_iter_is_end(cur)) {
@@ -826,7 +826,7 @@ sord_find(SordModel* sord, const SordQuad pat)
return NULL;
}
- return sord_iter_new(sord, cur, pat, index_order, mode, n_prefix);
+ return sord_iter_new(model, cur, pat, index_order, mode, n_prefix);
}
SordIter*
@@ -893,9 +893,9 @@ sord_count(SordModel* model,
}
bool
-sord_contains(SordModel* sord, const SordQuad pat)
+sord_contains(SordModel* model, const SordQuad pat)
{
- SordIter* iter = sord_find(sord, pat);
+ SordIter* iter = sord_find(model, pat);
bool ret = (iter != NULL);
sord_iter_free(iter);
return ret;
@@ -1022,23 +1022,23 @@ sord_new_uri_counted(SordWorld* world, const uint8_t* str,
}
SordNode*
-sord_new_uri(SordWorld* world, const uint8_t* str)
+sord_new_uri(SordWorld* world, const uint8_t* uri)
{
- const SerdNode node = serd_node_from_string(SERD_URI, str);
- return sord_new_uri_counted(world, str, node.n_bytes, node.n_chars, true);
+ const SerdNode node = serd_node_from_string(SERD_URI, uri);
+ return sord_new_uri_counted(world, uri, node.n_bytes, node.n_chars, true);
}
SordNode*
sord_new_relative_uri(SordWorld* world,
- const uint8_t* str,
- const uint8_t* base_str)
+ const uint8_t* uri,
+ const uint8_t* base_uri)
{
- if (serd_uri_string_has_scheme(str)) {
- return sord_new_uri(world, str);
+ if (serd_uri_string_has_scheme(uri)) {
+ return sord_new_uri(world, uri);
}
SerdURI buri = SERD_URI_NULL;
- SerdNode base = serd_node_new_uri_from_string(base_str, NULL, &buri);
- SerdNode node = serd_node_new_uri_from_string(str, &buri, NULL);
+ SerdNode base = serd_node_new_uri_from_string(base_uri, NULL, &buri);
+ SerdNode node = serd_node_new_uri_from_string(uri, &buri, NULL);
SordNode* ret = sord_new_uri_counted(
world, node.buf, node.n_bytes, node.n_chars, false);
@@ -1101,17 +1101,17 @@ sord_new_literal(SordWorld* world, SordNode* datatype,
SordNode*
sord_node_from_serd_node(SordWorld* world,
SerdEnv* env,
- const SerdNode* sn,
+ const SerdNode* node,
const SerdNode* datatype,
const SerdNode* lang)
{
- if (!sn) {
+ if (!node) {
return NULL;
}
SordNode* datatype_node = NULL;
SordNode* ret = NULL;
- switch (sn->type) {
+ switch (node->type) {
case SERD_NOTHING:
return NULL;
case SERD_LITERAL:
@@ -1120,23 +1120,23 @@ sord_node_from_serd_node(SordWorld* world,
ret = sord_new_literal_counted(
world,
datatype_node,
- sn->buf,
- sn->n_bytes,
- sn->n_chars,
- sn->flags,
+ node->buf,
+ node->n_bytes,
+ node->n_chars,
+ node->flags,
lang ? (const char*)lang->buf : NULL);
sord_node_free(world, datatype_node);
return ret;
case SERD_URI:
- if (serd_uri_string_has_scheme(sn->buf)) {
+ if (serd_uri_string_has_scheme(node->buf)) {
return sord_new_uri_counted(
- world, sn->buf, sn->n_bytes, sn->n_chars, true);
+ world, node->buf, node->n_bytes, node->n_chars, true);
} else {
SerdURI base_uri;
serd_env_get_base_uri(env, &base_uri);
SerdURI abs_uri;
SerdNode abs_uri_node = serd_node_new_uri_from_node(
- sn, &base_uri, &abs_uri);
+ node, &base_uri, &abs_uri);
ret = sord_new_uri_counted(world,
abs_uri_node.buf,
abs_uri_node.n_bytes,
@@ -1148,9 +1148,9 @@ sord_node_from_serd_node(SordWorld* world,
case SERD_CURIE: {
SerdChunk uri_prefix;
SerdChunk uri_suffix;
- if (serd_env_expand(env, sn, &uri_prefix, &uri_suffix)) {
+ if (serd_env_expand(env, node, &uri_prefix, &uri_suffix)) {
error(world, SERD_ERR_BAD_CURIE,
- "failed to expand CURIE `%s'\n", sn->buf);
+ "failed to expand CURIE `%s'\n", node->buf);
return NULL;
}
const size_t uri_len = uri_prefix.len + uri_suffix.len;
@@ -1163,7 +1163,8 @@ sord_node_from_serd_node(SordWorld* world,
return ret;
}
case SERD_BLANK:
- return sord_new_blank_counted(world, sn->buf, sn->n_bytes, sn->n_chars);
+ return sord_new_blank_counted(
+ world, node->buf, node->n_bytes, node->n_chars);
}
return NULL;
}
@@ -1197,29 +1198,29 @@ sord_node_copy(const SordNode* node)
}
static inline bool
-sord_add_to_index(SordModel* sord, const SordNode** tup, SordOrder order)
+sord_add_to_index(SordModel* model, const SordNode** tup, SordOrder order)
{
- return !zix_btree_insert(sord->indices[order], tup);
+ return !zix_btree_insert(model->indices[order], tup);
}
bool
-sord_add(SordModel* sord, const SordQuad tup)
+sord_add(SordModel* model, const SordQuad tup)
{
SORD_WRITE_LOG("Add " TUP_FMT "\n", TUP_FMT_ARGS(tup));
if (!tup[0] || !tup[1] || !tup[2]) {
- error(sord->world, SERD_ERR_BAD_ARG,
+ error(model->world, SERD_ERR_BAD_ARG,
"attempt to add quad with NULL field\n");
return false;
- } else if (sord->n_iters > 0) {
- error(sord->world, SERD_ERR_BAD_ARG, "added tuple during iteration\n");
+ } else if (model->n_iters > 0) {
+ error(model->world, SERD_ERR_BAD_ARG, "added tuple during iteration\n");
}
const SordNode** quad = (const SordNode**)malloc(sizeof(SordQuad));
memcpy(quad, tup, sizeof(SordQuad));
for (unsigned i = 0; i < NUM_ORDERS; ++i) {
- if (sord->indices[i] && (i < GSPO || tup[3])) {
- if (!sord_add_to_index(sord, quad, (SordOrder)i)) {
+ if (model->indices[i] && (i < GSPO || tup[3])) {
+ if (!sord_add_to_index(model, quad, (SordOrder)i)) {
assert(i == 0); // Assuming index coherency
free(quad);
return false; // Quad already stored, do nothing
@@ -1228,25 +1229,25 @@ sord_add(SordModel* sord, const SordQuad tup)
}
for (int i = 0; i < TUP_LEN; ++i) {
- sord_add_quad_ref(sord, tup[i], (SordQuadIndex)i);
+ sord_add_quad_ref(model, tup[i], (SordQuadIndex)i);
}
- ++sord->n_quads;
+ ++model->n_quads;
return true;
}
void
-sord_remove(SordModel* sord, const SordQuad tup)
+sord_remove(SordModel* model, const SordQuad tup)
{
SORD_WRITE_LOG("Remove " TUP_FMT "\n", TUP_FMT_ARGS(tup));
- if (sord->n_iters > 0) {
- error(sord->world, SERD_ERR_BAD_ARG, "remove with iterator\n");
+ if (model->n_iters > 0) {
+ error(model->world, SERD_ERR_BAD_ARG, "remove with iterator\n");
}
SordNode* quad = NULL;
for (unsigned i = 0; i < NUM_ORDERS; ++i) {
- if (sord->indices[i] && (i < GSPO || tup[3])) {
- if (zix_btree_remove(sord->indices[i], tup, (void**)&quad, NULL)) {
+ if (model->indices[i] && (i < GSPO || tup[3])) {
+ if (zix_btree_remove(model->indices[i], tup, (void**)&quad, NULL)) {
assert(i == 0); // Assuming index coherency
return; // Quad not found, do nothing
}
@@ -1256,17 +1257,17 @@ sord_remove(SordModel* sord, const SordQuad tup)
free(quad);
for (int i = 0; i < TUP_LEN; ++i) {
- sord_drop_quad_ref(sord, tup[i], (SordQuadIndex)i);
+ sord_drop_quad_ref(model, tup[i], (SordQuadIndex)i);
}
- --sord->n_quads;
+ --model->n_quads;
}
SerdStatus
-sord_erase(SordModel* sord, SordIter* iter)
+sord_erase(SordModel* model, SordIter* iter)
{
- if (sord->n_iters > 1) {
- error(sord->world, SERD_ERR_BAD_ARG, "erased with many iterators\n");
+ if (model->n_iters > 1) {
+ error(model->world, SERD_ERR_BAD_ARG, "erased with many iterators\n");
return SERD_ERR_BAD_ARG;
}
@@ -1277,8 +1278,8 @@ sord_erase(SordModel* sord, SordIter* iter)
SordNode* quad = NULL;
for (unsigned i = 0; i < NUM_ORDERS; ++i) {
- if (sord->indices[i] && (i < GSPO || tup[3])) {
- if (zix_btree_remove(sord->indices[i], tup, (void**)&quad,
+ if (model->indices[i] && (i < GSPO || tup[3])) {
+ if (zix_btree_remove(model->indices[i], tup, (void**)&quad,
i == iter->order ? &iter->cur : NULL)) {
return (i == 0) ? SERD_ERR_NOT_FOUND : SERD_ERR_INTERNAL;
}
@@ -1290,9 +1291,9 @@ sord_erase(SordModel* sord, SordIter* iter)
free(quad);
for (int i = 0; i < TUP_LEN; ++i) {
- sord_drop_quad_ref(sord, tup[i], (SordQuadIndex)i);
+ sord_drop_quad_ref(model, tup[i], (SordQuadIndex)i);
}
- --sord->n_quads;
+ --model->n_quads;
return SERD_SUCCESS;
}
diff --git a/src/syntax.c b/src/syntax.c
index 773fb95..2d924b3 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -46,17 +46,17 @@ sord_inserter_free(SordInserter* inserter)
SerdStatus
sord_inserter_set_base_uri(SordInserter* inserter,
- const SerdNode* uri_node)
+ const SerdNode* uri)
{
- return serd_env_set_base_uri(inserter->env, uri_node);
+ return serd_env_set_base_uri(inserter->env, uri);
}
SerdStatus
sord_inserter_set_prefix(SordInserter* inserter,
const SerdNode* name,
- const SerdNode* uri_node)
+ const SerdNode* uri)
{
- return serd_env_set_prefix(inserter->env, name, uri_node);
+ return serd_env_set_prefix(inserter->env, name, uri);
}
SerdStatus
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-18 02:43:09 +0000