/** * raptor_avltree_print: * @tree: AVL Tree * @stream: stream to print to * * Print the items in the tree in order to a stream (for debugging) * * Return value: non-0 on failure */ int raptor_avltree_print(raptor_avltree* tree, FILE* stream) { int i; int rv = 0; raptor_avltree_iterator* iter = NULL; fprintf(stream, "AVL Tree size %u\n", tree->size); for(i = 0, (iter = raptor_new_avltree_iterator(tree, NULL, NULL, 1)); iter && !rv; i++, (rv = raptor_avltree_iterator_next(iter))) { void* data = raptor_avltree_iterator_get(iter); if(!data) continue; fprintf(stream, "%d) ", i); if(tree->print_handler) tree->print_handler(data, stream); else fprintf(stream, "Data Node %p\n", data); } /*assert(i == tree->size);*/ if(iter) raptor_free_avltree_iterator(iter); return 0; }
void raptor_print_subject(raptor_abbrev_subject* subject) { int i; unsigned char *subj; unsigned char *pred; unsigned char *obj; raptor_avltree_iterator* iter=NULL; /* Note: The raptor_abbrev_node field passed as the first argument for * raptor_statement_part_as_string() is somewhat arbitrary, since as * the data structure is designed, the first word in the value union * is what was passed as the subject/predicate/object of the * statement. */ subj = raptor_statement_part_as_string(subject->node->value.resource.uri, subject->node->type, NULL, NULL); if(subject->type) { obj=raptor_statement_part_as_string(subject->type->value.resource.uri, subject->type->type, subject->type->value.literal.datatype, subject->type->value.literal.language); fprintf(stderr,"[%s, http://www.w3.org/1999/02/22-rdf-syntax-ns#type, %s]\n", subj, obj); RAPTOR_FREE(cstring, obj); } for(i=0; i < raptor_sequence_size(subject->elements); i++) { raptor_abbrev_node* o = raptor_sequence_get_at(subject->elements, i); if(o) { obj = raptor_statement_part_as_string(o->value.literal.string, o->type, o->value.literal.datatype, o->value.literal.language); fprintf(stderr,"[%s, [rdf:_%d], %s]\n", subj, i, obj); RAPTOR_FREE(cstring, obj); } } iter=raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1); while(iter) { raptor_abbrev_node** nodes; nodes=(raptor_abbrev_node**)raptor_avltree_iterator_get(iter); if(!nodes) break; raptor_print_abbrev_po(stderr, nodes); if(raptor_avltree_iterator_next(iter)) break; } if(iter) raptor_free_avltree_iterator(iter); RAPTOR_FREE(cstring, subj); }
static rasqal_row* rasqal_groupby_rowsource_read_row(rasqal_rowsource* rowsource, void *user_data) { rasqal_groupby_rowsource_context* con; rasqal_row *row = NULL; con = (rasqal_groupby_rowsource_context*)user_data; /* ensure we have stored grouped rows */ if(rasqal_groupby_rowsource_process(rowsource, con)) return NULL; if(con->tree) { rasqal_groupby_tree_node* node = NULL; /* Rows were grouped so iterate through grouped rows */ while(1) { node = (rasqal_groupby_tree_node*)raptor_avltree_iterator_get(con->group_iterator); if(!node) { /* No more nodes. finished last group and last row */ raptor_free_avltree_iterator(con->group_iterator); con->group_iterator = NULL; raptor_free_avltree(con->tree); con->tree = NULL; /* row = NULL is already set */ break; } /* removes row from sequence and this code now owns the reference */ row = (rasqal_row*)raptor_sequence_delete_at(node->rows, con->group_row_index++); if(row) break; /* End of sequence so reset row sequence index and advance iterator */ con->group_row_index = 0; if(raptor_avltree_iterator_next(con->group_iterator)) break; } if(node && row) row->group_id = node->group_id; } else { /* just pass rows through all in one group */ row = rasqal_rowsource_read_row(con->rowsource); if(row) row->group_id = con->group_id; } if(row) row->offset = con->offset++; return row; }
/* * raptor_turtle_emit: * @serializer: #raptor_serializer object * * Emit Turtle for all stored triples. * * Return value: non-0 on failure **/ static int raptor_turtle_emit(raptor_serializer *serializer) { raptor_turtle_context* context=(raptor_turtle_context*)serializer->context; raptor_abbrev_subject* subject; raptor_abbrev_subject* blank; int rc; raptor_avltree_iterator* iter=NULL; iter = raptor_new_avltree_iterator(context->subjects, NULL, NULL, 1); while (iter) { subject = (raptor_abbrev_subject *)raptor_avltree_iterator_get(iter); if (subject) { rc = raptor_turtle_emit_subject(serializer, subject, 0); if (rc) { raptor_free_avltree_iterator(iter); return rc; } } if (raptor_avltree_iterator_next(iter)) break; } if (iter) raptor_free_avltree_iterator(iter); /* Emit any remaining blank nodes. */ iter = raptor_new_avltree_iterator(context->blanks, NULL, NULL, 1); while (iter) { blank = (raptor_abbrev_subject *)raptor_avltree_iterator_get(iter); if (blank) { rc = raptor_turtle_emit_subject(serializer, blank, 0); if (rc) { raptor_free_avltree_iterator(iter); return rc; } } if (raptor_avltree_iterator_next(iter)) break; } if (iter) raptor_free_avltree_iterator(iter); return 0; }
/* * raptor_turtle_emit_subject: * @serializer: #raptor_serializer object * @subject: subject node * @depth: depth into tree * * Emit a subject node * * Return value: non-0 on failure **/ static int raptor_turtle_emit_subject(raptor_serializer *serializer, raptor_abbrev_subject* subject, int depth) { raptor_turtle_context* context=(raptor_turtle_context*)serializer->context; raptor_turtle_writer* turtle_writer=context->turtle_writer; int blank = 1; int collection = 0; int rc = 0; if (!raptor_abbrev_subject_valid(subject)) return 0; RAPTOR_DEBUG5("Emitting subject node %p refcount %d subject %d object %d\n", subject->node, subject->node->ref_count, subject->node->count_as_subject, subject->node->count_as_object); if(!depth && subject->node->type == RAPTOR_IDENTIFIER_TYPE_ANONYMOUS && subject->node->count_as_subject == 1 && subject->node->count_as_object == 1) { RAPTOR_DEBUG2("Skipping subject node %p\n", subject->node); return 0; } if(raptor_avltree_size(subject->properties) == 0) { RAPTOR_DEBUG2("Skipping subject node %p\n", subject->node); return 0; } /* check if we can do collection abbreviation */ if(raptor_avltree_size(subject->properties) >= 2) { raptor_avltree_iterator* iter=NULL; raptor_abbrev_node* pred1; raptor_abbrev_node* pred2; iter=raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1); if(!iter) return 1; pred1=((raptor_abbrev_node**)raptor_avltree_iterator_get(iter))[0]; raptor_avltree_iterator_next(iter); pred2=((raptor_abbrev_node**)raptor_avltree_iterator_get(iter))[0]; raptor_free_avltree_iterator(iter); if(pred1->type == RAPTOR_IDENTIFIER_TYPE_RESOURCE && pred2->type == RAPTOR_IDENTIFIER_TYPE_RESOURCE && ( (raptor_uri_equals_v2(serializer->world, pred1->value.resource.uri, context->rdf_first_uri) && raptor_uri_equals_v2(serializer->world, pred2->value.resource.uri, context->rdf_rest_uri)) || (raptor_uri_equals_v2(serializer->world, pred2->value.resource.uri, context->rdf_first_uri) && raptor_uri_equals_v2(serializer->world, pred1->value.resource.uri, context->rdf_rest_uri)) ) ) { collection = 1; } } /* emit the subject node */ if(subject->node->type == RAPTOR_IDENTIFIER_TYPE_RESOURCE) { rc= raptor_turtle_emit_resource(serializer, subject->node, depth+1); if(rc) return rc; blank = 0; } else if(subject->node->type == RAPTOR_IDENTIFIER_TYPE_ANONYMOUS) { if((subject->node->count_as_subject == 1 && subject->node->count_as_object == 0) && depth > 1) { blank = 1; } else if(subject->node->count_as_object == 0) { raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"[]"); blank = 0; } else if(!collection && subject->node->count_as_object > 1) { /* Referred to (used as an object), so needs a nodeID */ const unsigned char* genid = subject->node->value.blank.string; size_t len = strlen((const char*)genid); unsigned char* subject_str; subject_str= (unsigned char *)RAPTOR_MALLOC(cstring, len+3); if(!subject_str) return 1; subject_str[0]='_'; subject_str[1]=':'; strncpy((char*)&subject_str[2], (const char*)genid, len+1); raptor_turtle_writer_raw(turtle_writer, subject_str); RAPTOR_FREE(cstring, subject_str); } } else if(subject->node->type == RAPTOR_IDENTIFIER_TYPE_ORDINAL) { unsigned char* subject_str; subject_str = (unsigned char *)RAPTOR_MALLOC(string, raptor_rdf_namespace_uri_len + MAX_ASCII_INT_SIZE + 2); if(!subject_str) return 1; sprintf((char*)subject, "%s_%d", raptor_rdf_namespace_uri, subject->node->value.ordinal.ordinal); raptor_turtle_writer_raw(turtle_writer, subject_str); RAPTOR_FREE(cstring, subject_str); return blank = 0; } if(collection) { raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"("); raptor_turtle_writer_increase_indent(turtle_writer); rc=raptor_turtle_emit_subject_collection_items(serializer, subject, depth+1); raptor_turtle_writer_decrease_indent(turtle_writer); raptor_turtle_writer_newline(turtle_writer); raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)")"); } else { if(blank && depth > 1) raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"["); raptor_turtle_writer_increase_indent(turtle_writer); raptor_turtle_writer_newline(turtle_writer); raptor_turtle_emit_subject_properties(serializer, subject, depth+1); raptor_turtle_writer_decrease_indent(turtle_writer); if(blank && depth > 1) { raptor_turtle_writer_newline(turtle_writer); raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"]"); } } if(depth == 0) { /* NOTE: the space before the . here MUST be there or statements * that end in a numeric literal will be interpreted incorrectly * (the "." will be parsed as part of the literal and statement * left unterminated) */ raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" ."); raptor_turtle_writer_newline(turtle_writer); raptor_turtle_writer_newline(turtle_writer); } return rc; }
/* * raptor_turtle_emit_subject_properties: * @serializer: #raptor_serializer object * @subject: subject node * @depth: depth into tree * * Emit the properties about a subject node. * * Return value: non-0 on failure **/ static int raptor_turtle_emit_subject_properties(raptor_serializer* serializer, raptor_abbrev_subject* subject, int depth) { raptor_turtle_context* context=(raptor_turtle_context*)serializer->context; raptor_turtle_writer *turtle_writer = context->turtle_writer; raptor_abbrev_node* last_predicate=NULL; int rv = 0; raptor_avltree_iterator* iter=NULL; int i; RAPTOR_DEBUG5("Emitting subject properties for node %p refcount %d subject %d object %d\n", subject->node, subject->node->ref_count, subject->node->count_as_subject, subject->node->count_as_object); /* Emit any rdf:_n properties collected */ if(raptor_sequence_size(subject->list_items) > 0) rv = raptor_turtle_emit_subject_list_items(serializer, subject, depth+1); for(i=0, (iter=raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1)); iter && !rv; i++, (rv=raptor_avltree_iterator_next(iter))) { raptor_abbrev_node** nodes; raptor_abbrev_node* predicate; raptor_abbrev_node* object; raptor_qname *qname; nodes=(raptor_abbrev_node**)raptor_avltree_iterator_get(iter); if(!nodes) break; predicate= nodes[0]; object= nodes[1]; if(!(last_predicate && raptor_abbrev_node_equals(predicate, last_predicate))) { /* no object list abbreviation possible, terminate last object */ if(last_predicate) { raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" ;"); raptor_turtle_writer_newline(turtle_writer); } if(predicate->type == RAPTOR_IDENTIFIER_TYPE_ORDINAL) { /* we should only get here in rare cases -- usually when there * are multiple ordinals with the same value. */ unsigned char uri_string[MAX_ASCII_INT_SIZE + 2]; sprintf((char*)uri_string, "_%d", predicate->value.ordinal.ordinal); qname = raptor_new_qname_from_namespace_local_name_v2(serializer->world, context->rdf_nspace, uri_string, NULL); } else { qname = raptor_namespaces_qname_from_uri(context->nstack, predicate->value.resource.uri, 10); } if(raptor_abbrev_node_equals(predicate, context->rdf_type)) raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"a"); else if(qname) raptor_turtle_writer_qname(turtle_writer, qname); else raptor_turtle_writer_reference(turtle_writer, predicate->value.resource.uri); raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" "); if(qname) raptor_free_qname(qname); } else raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)", "); switch(object->type) { case RAPTOR_IDENTIFIER_TYPE_RESOURCE: rv = raptor_turtle_emit_resource(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_LITERAL: rv = raptor_turtle_emit_literal(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS: rv = raptor_turtle_emit_blank(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_XML_LITERAL: rv = raptor_turtle_emit_xml_literal(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_ORDINAL: /* ordinals should never appear as an object with current parsers */ case RAPTOR_IDENTIFIER_TYPE_PREDICATE: /* predicates should never appear as an object */ case RAPTOR_IDENTIFIER_TYPE_UNKNOWN: default: RAPTOR_FATAL1("Unsupported identifier type\n"); break; } last_predicate = predicate; } if (iter) raptor_free_avltree_iterator(iter); return rv; }
/* * raptor_turtle_emit_subject_collection_items: * @serializer: #raptor_serializer object * @subject: subject node * @depth: depth into tree * * Emit an abbreviated rdf collection of items (rdf:first, rdf:rest) about a subject node. * * Return value: non-0 on failure **/ static int raptor_turtle_emit_subject_collection_items(raptor_serializer* serializer, raptor_abbrev_subject* subject, int depth) { raptor_turtle_context* context=(raptor_turtle_context*)serializer->context; int rv = 0; raptor_avltree_iterator* iter=NULL; int i; int is_new_subject = 0; RAPTOR_DEBUG5("Emitting subject collection items for node %p refcount %d subject %d object %d\n", subject->node, subject->node->ref_count, subject->node->count_as_subject, subject->node->count_as_object); /* if just saw a new subject (is_new_subject is true) then there is no need * to advance the iterator - it was just reset */ for(i=0, (iter=raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1)); iter && !rv; i++, (rv = is_new_subject ? 0 : raptor_avltree_iterator_next(iter))) { raptor_abbrev_node** nodes; raptor_abbrev_node* predicate; raptor_abbrev_node* object; is_new_subject = 0; nodes=(raptor_abbrev_node**)raptor_avltree_iterator_get(iter); if(!nodes) break; predicate= nodes[0]; object= nodes[1]; if(!raptor_uri_equals_v2(serializer->world, predicate->value.resource.uri, context->rdf_first_uri)) { raptor_serializer_error(serializer, "Malformed collection - first predicate is not rdf:first"); return 1; } if(!object) continue; if(i > 0) raptor_turtle_writer_newline(context->turtle_writer); switch(object->type) { case RAPTOR_IDENTIFIER_TYPE_RESOURCE: rv = raptor_turtle_emit_resource(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_LITERAL: rv = raptor_turtle_emit_literal(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_XML_LITERAL: rv = raptor_turtle_emit_xml_literal(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS: rv = raptor_turtle_emit_blank(serializer, object, depth+1); break; case RAPTOR_IDENTIFIER_TYPE_ORDINAL: /* ordinals should never appear as an object with current parsers */ case RAPTOR_IDENTIFIER_TYPE_PREDICATE: /* predicates should never appear as an object */ case RAPTOR_IDENTIFIER_TYPE_UNKNOWN: default: RAPTOR_FATAL1("Unsupported identifier type\n"); break; } /* last item */ rv=raptor_avltree_iterator_next(iter); if(rv) break; nodes=(raptor_abbrev_node**)raptor_avltree_iterator_get(iter); predicate = nodes[0]; object = nodes[1]; if(!raptor_uri_equals_v2(serializer->world, predicate->value.resource.uri, context->rdf_rest_uri)) { raptor_serializer_error(serializer, "Malformed collection - second predicate is not rdf:rest"); return 1; } if(object->type == RAPTOR_IDENTIFIER_TYPE_ANONYMOUS) { subject = raptor_abbrev_subject_find(context->blanks, object->type, object->value.blank.string); if(!subject) { raptor_serializer_error(serializer, "Malformed collection - could not find subject for rdf:rest"); return 1; } /* got a <(old)subject> rdf:rest <(new)subject> triple so know * subject has changed and should reset the properties iterator */ if(iter) raptor_free_avltree_iterator(iter); iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1); is_new_subject = 1; } else { if(object->type != RAPTOR_IDENTIFIER_TYPE_RESOURCE || !raptor_uri_equals_v2(serializer->world, object->value.resource.uri, context->rdf_nil_uri)) { raptor_serializer_error(serializer, "Malformed collection - last rdf:rest resource is not rdf:nil"); return 1; } break; } } if(iter) raptor_free_avltree_iterator(iter); return rv; }
int main(int argc, char *argv[]) { raptor_world *world; const char *program = raptor_basename(argv[0]); #define ITEM_COUNT 8 const char *items[ITEM_COUNT+1] = { "ron", "amy", "jen", "bij", "jib", "daj", "jim", "def", NULL }; #define DELETE_COUNT 2 const char *delete_items[DELETE_COUNT+1] = { "jen", "jim", NULL }; #define RESULT_COUNT (ITEM_COUNT-DELETE_COUNT) const char *results[RESULT_COUNT+1] = { "amy", "bij", "daj", "def", "jib", "ron", NULL}; raptor_avltree* tree; raptor_avltree_iterator* iter; visit_state vs; int i; world = raptor_new_world(); if(!world || raptor_world_open(world)) exit(1); tree = raptor_new_avltree(compare_strings, NULL, /* no free as they are static pointers above */ 0); if(!tree) { fprintf(stderr, "%s: Failed to create tree\n", program); exit(1); } for(i = 0; items[i]; i++) { int rc; void* node; #if RAPTOR_DEBUG > 1 fprintf(stderr, "%s: Adding tree item '%s'\n", program, items[i]); #endif rc = raptor_avltree_add(tree, (void*)items[i]); if(rc) { fprintf(stderr, "%s: Adding tree item %d '%s' failed, returning error %d\n", program, i, items[i], rc); exit(1); } #ifdef RAPTOR_DEBUG raptor_avltree_check(tree); #endif node = raptor_avltree_search(tree, (void*)items[i]); if(!node) { fprintf(stderr, "%s: Tree did NOT contain item %d '%s' as expected\n", program, i, items[i]); exit(1); } } #if RAPTOR_DEBUG > 1 fprintf(stderr, "%s: Printing tree\n", program); vs.fh = stderr; vs.count = 0; raptor_avltree_visit(tree, print_string, &vs); fprintf(stderr, "%s: Dumping tree\n", program); raptor_avltree_dump(tree, stderr); #endif for(i = 0; delete_items[i]; i++) { int rc; #if RAPTOR_DEBUG > 1 fprintf(stderr, "%s: Deleting tree item '%s'\n", program, delete_items[i]); #endif rc = raptor_avltree_delete(tree, (void*)delete_items[i]); if(!rc) { fprintf(stderr, "%s: Deleting tree item %d '%s' failed, returning error %d\n", program, i, delete_items[i], rc); exit(1); } #ifdef RAPTOR_DEBUG raptor_avltree_check(tree); #endif } #if RAPTOR_DEBUG > 1 fprintf(stderr, "%s: Walking tree forwards via iterator\n", program); #endif iter = raptor_new_avltree_iterator(tree, NULL, NULL, 1); for(i = 0; 1; i++) { const char* data = (const char*)raptor_avltree_iterator_get(iter); const char* result = results[i]; if((!data && data != result) || (data && strcmp(data, result))) { fprintf(stderr, "%3d: Forwards iterator expected '%s' but found '%s'\n", i, result, data); exit(1); } #if RAPTOR_DEBUG > 1 fprintf(stderr, "%3d: Got '%s'\n", i, data); #endif if(raptor_avltree_iterator_next(iter)) break; if(i > RESULT_COUNT) { fprintf(stderr, "Forward iterator did not end on result %i as expected\n", i); exit(1); } } raptor_free_avltree_iterator(iter); #if RAPTOR_DEBUG > 1 fprintf(stderr, "%s: Checking tree\n", program); #endif vs.count = 0; vs.results = results; vs.failed = 0; raptor_avltree_visit(tree, check_string, &vs); if(vs.failed) { fprintf(stderr, "%s: Checking tree failed\n", program); exit(1); } for(i = 0; results[i]; i++) { const char* result = results[i]; char* data = (char*)raptor_avltree_remove(tree, (void*)result); if(!data) { fprintf(stderr, "%s: remove %i failed at item '%s'\n", program, i, result); exit(1); } if(strcmp(data, result)) { fprintf(stderr, "%s: remove %i returned %s not %s as expected\n", program, i, data, result); exit(1); } } #if RAPTOR_DEBUG > 1 fprintf(stderr, "%s: Freeing tree\n", program); #endif raptor_free_avltree(tree); raptor_free_world(world); /* keep gcc -Wall happy */ return(0); }
/* * raptor_turtle_emit_subject_properties: * @serializer: #raptor_serializer object * @subject: subject node * @depth: depth into tree * * Emit the properties about a subject node. * * Return value: non-0 on failure **/ static int raptor_turtle_emit_subject_properties(raptor_serializer* serializer, raptor_abbrev_subject* subject, int depth) { raptor_turtle_context* context = (raptor_turtle_context*)serializer->context; raptor_turtle_writer *turtle_writer = context->turtle_writer; raptor_abbrev_node* last_predicate = NULL; int rv = 0; raptor_avltree_iterator* iter = NULL; int i; RAPTOR_DEBUG5("Emitting subject properties for node %p refcount %d subject %d object %d\n", subject->node, subject->node->ref_count, subject->node->count_as_subject, subject->node->count_as_object); /* Emit any rdf:_n properties collected */ if(raptor_sequence_size(subject->list_items) > 0) rv = raptor_turtle_emit_subject_list_items(serializer, subject, depth+1); for(i = 0, (iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1)); iter && !rv; i++, (rv = raptor_avltree_iterator_next(iter))) { raptor_abbrev_node** nodes; raptor_abbrev_node* predicate; raptor_abbrev_node* object; raptor_qname *qname; nodes = (raptor_abbrev_node**)raptor_avltree_iterator_get(iter); if(!nodes) break; predicate= nodes[0]; object= nodes[1]; if(!(last_predicate && raptor_abbrev_node_equals(predicate, last_predicate))) { /* no object list abbreviation possible, terminate last object */ if(last_predicate) { raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" ;"); raptor_turtle_writer_newline(turtle_writer); } qname = raptor_new_qname_from_namespace_uri(context->nstack, predicate->term->value.uri, 10); if(raptor_abbrev_node_equals(predicate, context->rdf_type)) raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"a"); else if(qname) raptor_turtle_writer_qname(turtle_writer, qname); else raptor_turtle_writer_reference(turtle_writer, predicate->term->value.uri); raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" "); if(qname) raptor_free_qname(qname); } else raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)", "); switch(object->term->type) { case RAPTOR_TERM_TYPE_URI: rv = raptor_turtle_emit_resource(serializer, object, depth+1); break; case RAPTOR_TERM_TYPE_LITERAL: rv = raptor_turtle_emit_literal(serializer, object, depth+1); break; case RAPTOR_TERM_TYPE_BLANK: rv = raptor_turtle_emit_blank(serializer, object, depth+1); break; case RAPTOR_TERM_TYPE_UNKNOWN: default: raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Triple has unsupported term type %d", object->term->type); break; } /* Return error if emitting something failed above */ if(rv) return rv; last_predicate = predicate; } if(iter) raptor_free_avltree_iterator(iter); return rv; }
/* * raptor_turtle_emit_subject_collection_items: * @serializer: #raptor_serializer object * @subject: subject node * @depth: depth into tree * * Emit an abbreviated rdf collection of items (rdf:first, rdf:rest) about a subject node. * * Return value: non-0 on failure **/ static int raptor_turtle_emit_subject_collection_items(raptor_serializer* serializer, raptor_abbrev_subject* subject, int depth) { raptor_turtle_context* context = (raptor_turtle_context*)serializer->context; int rv = 0; raptor_avltree_iterator* iter = NULL; int i; int is_new_subject = 0; RAPTOR_DEBUG5("Emitting subject collection items for node %p refcount %d subject %d object %d\n", subject->node, subject->node->ref_count, subject->node->count_as_subject, subject->node->count_as_object); /* if just saw a new subject (is_new_subject is true) then there is no need * to advance the iterator - it was just reset */ for(i = 0, (iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1)); iter && !rv; i++, (rv = is_new_subject ? 0 : raptor_avltree_iterator_next(iter))) { raptor_abbrev_node** nodes; raptor_abbrev_node* predicate; raptor_abbrev_node* object; is_new_subject = 0; nodes = (raptor_abbrev_node**)raptor_avltree_iterator_get(iter); if(!nodes) break; predicate= nodes[0]; object= nodes[1]; if(!raptor_uri_equals(predicate->term->value.uri, context->rdf_first_uri)) { raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Malformed collection - first predicate is not rdf:first"); return 1; } if(!object) continue; if(i > 0) raptor_turtle_writer_newline(context->turtle_writer); switch(object->term->type) { case RAPTOR_TERM_TYPE_URI: rv = raptor_turtle_emit_resource(serializer, object, depth+1); break; case RAPTOR_TERM_TYPE_LITERAL: rv = raptor_turtle_emit_literal(serializer, object, depth+1); break; case RAPTOR_TERM_TYPE_BLANK: rv = raptor_turtle_emit_blank(serializer, object, depth+1); break; case RAPTOR_TERM_TYPE_UNKNOWN: default: raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Triple has unsupported term type %d", object->term->type); break; } /* Return error if emitting something failed above */ if(rv) return rv; /* last item */ rv = raptor_avltree_iterator_next(iter); if(rv) break; nodes = (raptor_abbrev_node**)raptor_avltree_iterator_get(iter); predicate = nodes[0]; object = nodes[1]; if(!raptor_uri_equals(predicate->term->value.uri, context->rdf_rest_uri)) { raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Malformed collection - second predicate is not rdf:rest"); return 1; } if(object->term->type == RAPTOR_TERM_TYPE_BLANK) { subject = raptor_abbrev_subject_find(context->blanks, object->term); if(!subject) { raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Malformed collection - could not find subject for rdf:rest"); return 1; } /* got a <(old)subject> rdf:rest <(new)subject> triple so know * subject has changed and should reset the properties iterator */ if(iter) raptor_free_avltree_iterator(iter); iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1); is_new_subject = 1; } else { if(object->term->type != RAPTOR_TERM_TYPE_URI || !raptor_uri_equals(object->term->value.uri, context->rdf_nil_uri)) { raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Malformed collection - last rdf:rest resource is not rdf:nil"); return 1; } break; } } if(iter) raptor_free_avltree_iterator(iter); return rv; }