From b4d638dd57b3fd53e189c062fe3e6b1657c20a3f Mon Sep 17 00:00:00 2001 From: David Robillard Date: Wed, 27 Dec 2017 06:54:50 -0500 Subject: Fix inconsistent parameter names --- src/sord.c | 181 +++++++++++++++++++++++++++++++------------------------------ 1 file changed, 91 insertions(+), 90 deletions(-) (limited to 'src/sord.c') 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; } -- cgit v1.2.1