/**
* 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;
}
