diff options
Diffstat (limited to 'src/raptor_serialize_rdfxmla.c')
| -rw-r--r-- | src/raptor_serialize_rdfxmla.c | 1553 |
1 files changed, 1553 insertions, 0 deletions
diff --git a/src/raptor_serialize_rdfxmla.c b/src/raptor_serialize_rdfxmla.c new file mode 100644 index 0000000..2341947 --- /dev/null +++ b/src/raptor_serialize_rdfxmla.c @@ -0,0 +1,1553 @@ +/* -*- Mode: c; c-basic-offset: 2 -*- + * + * raptor_serialize_rdfxmla.c - RDF/XML with abbreviations serializer + * + * Copyright (C) 2004-2010, David Beckett http://www.dajobe.org/ + * Copyright (C) 2004-2005, University of Bristol, UK http://www.bristol.ac.uk/ + * Copyright (C) 2005, Steve Shepard steveshep@gmail.com + * + * This package is Free Software and part of Redland http://librdf.org/ + * + * It is licensed under the following three licenses as alternatives: + * 1. GNU Lesser General Public License (LGPL) V2.1 or any newer version + * 2. GNU General Public License (GPL) V2 or any newer version + * 3. Apache License, V2.0 or any newer version + * + * You may not use this file except in compliance with at least one of + * the above three licenses. + * + * See LICENSE.html or LICENSE.txt at the top of this package for the + * complete terms and further detail along with the license texts for + * the licenses in COPYING.LIB, COPYING and LICENSE-2.0.txt respectively. + * + */ + +#ifdef HAVE_CONFIG_H +#include <raptor_config.h> +#endif + +#include <stdio.h> +#include <string.h> +#include <ctype.h> +#include <stdarg.h> +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif + +/* Raptor includes */ +#include "raptor2.h" +#include "raptor_internal.h" + + +/* + * Raptor rdfxml-abbrev serializer object + */ +typedef struct { + raptor_namespace_stack *nstack; /* Namespace stack */ + raptor_namespace *xml_nspace; /* the xml: namespace */ + raptor_namespace *rdf_nspace; /* the rdf: namespace */ + raptor_xml_element* rdf_RDF_element; /* the rdf:RDF element */ + raptor_xml_writer *xml_writer; /* where the xml is being written */ + raptor_sequence *namespaces; /* User declared namespaces */ + raptor_avltree *subjects; /* subject items */ + raptor_avltree *blanks; /* blank subject items */ + raptor_avltree *nodes; /* nodes */ + raptor_abbrev_node *rdf_type; /* rdf:type uri */ + + /* non-zero if is Adobe XMP abbreviated form */ + int is_xmp; + + /* non zero if rdf:RDF has been written (and thus no new namespaces + * can be declared). + */ + int written_header; + + /* for labeling namespaces */ + int namespace_count; + + /* xml_writer was passed in and not owned by us */ + int external_xml_writer; + + /* true if should write rdf:RDF */ + int write_rdf_RDF; + + /* starting namespace stack depth */ + int starting_depth; + + /* namespaces stack was passed in andn not owned by us */ + int external_nstack; + + /* If not NULL, the URI of the single node to serialize - starting + * from property elements */ + raptor_uri* single_node; + + /* If non-0, emit typed nodes */ + int write_typed_nodes; +} raptor_rdfxmla_context; + + +/* prototypes for functions */ + +static int raptor_rdfxmla_emit_resource(raptor_serializer *serializer, + raptor_xml_element *element, + raptor_abbrev_node *node, + int depth); + +static int raptor_rdfxmla_emit_literal(raptor_serializer *serializer, + raptor_xml_element *element, + raptor_abbrev_node *node, + int depth); +static int raptor_rdfxmla_emit_blank(raptor_serializer *serializer, + raptor_xml_element *element, + raptor_abbrev_node* node, + int depth); +static int raptor_rdfxmla_emit_subject_list_items(raptor_serializer* serializer, + raptor_abbrev_subject* subject, + int depth); +static int raptor_rdfxmla_emit_subject_properties(raptor_serializer *serializer, + raptor_abbrev_subject* subject, + int depth); +static int raptor_rdfxmla_emit_subject(raptor_serializer *serializer, + raptor_abbrev_subject* subject, + int depth); +static int raptor_rdfxmla_emit(raptor_serializer *serializer); + +static int raptor_rdfxmla_serialize_init(raptor_serializer* serializer, + const char *name); +static void raptor_rdfxmla_serialize_terminate(raptor_serializer* serializer); +static int raptor_rdfxmla_serialize_declare_namespace(raptor_serializer* serializer, + raptor_uri *uri, + const unsigned char *prefix); +static int raptor_rdfxmla_serialize_start(raptor_serializer* serializer); +static int raptor_rdfxmla_serialize_statement(raptor_serializer* serializer, + raptor_statement *statement); + +static int raptor_rdfxmla_serialize_end(raptor_serializer* serializer); +static void raptor_rdfxmla_serialize_finish_factory(raptor_serializer_factory* factory); + + +/* helper functions */ + + +/* + * raptor_rdfxmla_emit_resource_uri: + * @serializer: #raptor_serializer object + * @element: XML Element + * @uri: URI object + * @depth: depth into tree + * + * Emit a description of a resource using an XML Element + * + * Return value: non-0 on failure + **/ +static int +raptor_rdfxmla_emit_resource_uri(raptor_serializer *serializer, + raptor_xml_element *element, + raptor_uri* uri, + int depth) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_xml_writer *xml_writer = context->xml_writer; + raptor_qname **attrs; + unsigned char *attr_name; + unsigned char *attr_value; + + RAPTOR_DEBUG2("Emitting resource predicate URI %s\n", + raptor_uri_as_string(uri)); + + attrs = RAPTOR_CALLOC(raptor_qname**, 1, sizeof(raptor_qname*)); + if(!attrs) + return 1; + + attr_name = (unsigned char *)"resource"; + + if(RAPTOR_OPTIONS_GET_NUMERIC(serializer, RAPTOR_OPTION_RELATIVE_URIS)) + /* newly allocated string */ + attr_value = raptor_uri_to_relative_uri_string(serializer->base_uri, uri); + else + attr_value = raptor_uri_as_string(uri); + + attrs[0] = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + attr_name, + attr_value); + + if(RAPTOR_OPTIONS_GET_NUMERIC(serializer, RAPTOR_OPTION_RELATIVE_URIS)) + RAPTOR_FREE(char*, attr_value); + + if(!attrs[0]) { + RAPTOR_FREE(qnamearray, attrs); + return 1; + } + + raptor_xml_element_set_attributes(element, attrs, 1); + + raptor_xml_writer_start_element(xml_writer, element); + raptor_xml_writer_end_element(context->xml_writer, element); + + RAPTOR_DEBUG2("Emitted resource predicate URI %s\n", + raptor_uri_as_string(uri)); + + return 0; +} + + +/* + * raptor_rdfxmla_emit_resource: + * @serializer: #raptor_serializer object + * @element: XML Element + * @node: resource node + * @depth: depth into tree + * + * Emit a description of a resource using an XML Element + * + * Return value: non-0 on failure + **/ +static int +raptor_rdfxmla_emit_resource(raptor_serializer *serializer, + raptor_xml_element *element, + raptor_abbrev_node* node, + int depth) +{ + int rc; + + RAPTOR_DEBUG_ABBREV_NODE("Emitting resource node", node); + + if(node->term->type != RAPTOR_TERM_TYPE_URI) + return 1; + + rc = raptor_rdfxmla_emit_resource_uri(serializer, element, + node->term->value.uri, depth); + + RAPTOR_DEBUG_ABBREV_NODE("Emitted resource node", node); + + return rc; +} + + +/* + * raptor_rdfxmla_emit_literal: + * @serializer: #raptor_serializer object + * @element: XML Element + * @node: literal node + * @depth: depth into tree + * + * Emit a description of a literal using an XML Element + * + * Return value: non-0 on failure + **/ +static int +raptor_rdfxmla_emit_literal(raptor_serializer *serializer, + raptor_xml_element *element, + raptor_abbrev_node* node, + int depth) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_xml_writer *xml_writer = context->xml_writer; + raptor_qname **attrs; + int attrs_count; + + RAPTOR_DEBUG_ABBREV_NODE("Emitting literal node", node); + + if(node->term->type != RAPTOR_TERM_TYPE_LITERAL) + return 1; + + if(node->term->value.literal.language || node->term->value.literal.datatype) { + + attrs_count = 0; + attrs = RAPTOR_CALLOC(raptor_qname**, 2, sizeof(raptor_qname*)); + if(!attrs) + return 1; + + if(node->term->value.literal.language) { + attrs[attrs_count] = raptor_new_qname(context->nstack, + (unsigned char*)"xml:lang", + node->term->value.literal.language); + if(!attrs[attrs_count]) + goto attrs_oom; + attrs_count++; + } + + if(node->term->value.literal.datatype) { + unsigned char *datatype_value; + datatype_value = raptor_uri_as_string(node->term->value.literal.datatype); + attrs[attrs_count] = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + (const unsigned char*)"datatype", + datatype_value); + if(!attrs[attrs_count]) + goto attrs_oom; + attrs_count++; + + /* SJS Note: raptor_default_uri_as_string simply returns a + * pointer to the string. Hope this is also true of alternate + * uri implementations. */ + /* RAPTOR_FREE(char*, datatype_value); */ + + } + + raptor_xml_element_set_attributes(element, attrs, attrs_count); + + } + + raptor_xml_writer_start_element(xml_writer, element); + raptor_xml_writer_cdata(xml_writer, node->term->value.literal.string); + raptor_xml_writer_end_element(xml_writer, element); + + RAPTOR_DEBUG_ABBREV_NODE("Emitted literal node", node); + + return 0; + + attrs_oom: + + raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_FATAL, NULL, + "Out of memory"); + + /* attrs_count has not been incremented yet + * and it points to the qname the allocation of which failed */ + attrs_count--; + while(attrs_count>=0) + raptor_free_qname(attrs[attrs_count--]); + + RAPTOR_FREE(qnamearray, attrs); + + return 1; +} + + +/* + * raptor_rdfxmla_emit_blank: + * @serializer: #raptor_serializer object + * @element: XML Element + * @node: blank node + * @depth: depth into tree + * + * Emit a description of a blank node using an XML Element + * + * Return value: non-0 on failure + **/ +static int +raptor_rdfxmla_emit_blank(raptor_serializer *serializer, + raptor_xml_element *element, raptor_abbrev_node* node, + int depth) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + + RAPTOR_DEBUG_ABBREV_NODE("Emitting blank node", node); + + if(node->term->type != RAPTOR_TERM_TYPE_BLANK) + return 1; + + if((node->count_as_subject == 1 && node->count_as_object == 1)) { + /* If this is only used as a 1 subject and object or never + * used as a subject or never used as an object, it never need + * be referenced with an explicit name */ + raptor_abbrev_subject* blank; + + raptor_xml_writer_start_element(context->xml_writer, element); + + blank = raptor_abbrev_subject_find(context->blanks, node->term); + + if(blank) { + raptor_rdfxmla_emit_subject(serializer, blank, depth + 1); + raptor_abbrev_subject_invalidate(blank); + } + + } else { + unsigned char *attr_name = (unsigned char*)"nodeID"; + unsigned char *attr_value = node->term->value.blank.string; + raptor_qname **attrs; + + attrs = RAPTOR_CALLOC(raptor_qname**, 1, sizeof(raptor_qname*)); + if(!attrs) + return 1; + + attrs[0] = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + attr_name, + attr_value); + + raptor_xml_element_set_attributes(element, attrs, 1); + raptor_xml_writer_start_element(context->xml_writer, element); + + } + + raptor_xml_writer_end_element(context->xml_writer, element); + + RAPTOR_DEBUG_ABBREV_NODE("Emitted blank node", node); + + return 0; +} + + +/* + * raptor_rdfxmla_emit_subject_list_items: + * @serializer: #raptor_serializer object + * @subject: subject node + * @depth: depth into tree + * + * Emit an rdf list of items (rdf:li) about a subject node. + * + * Return value: non-0 on failure + **/ +static int +raptor_rdfxmla_emit_subject_list_items(raptor_serializer* serializer, + raptor_abbrev_subject* subject, + int depth) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + int rv = 0; + int i = 0; + raptor_uri* base_uri = NULL; + + RAPTOR_DEBUG_ABBREV_NODE("Emitting subject list items", subject->node); + + while(!rv && i < raptor_sequence_size(subject->list_items)) { + + raptor_abbrev_node* object; + raptor_qname *qname; + raptor_xml_element *element; + + object = (raptor_abbrev_node*)raptor_sequence_get_at(subject->list_items, i++); + if(!object) + continue; + + qname = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + (unsigned char *)"li", + NULL); + + if(serializer->base_uri) + base_uri = raptor_uri_copy(serializer->base_uri); + element = raptor_new_xml_element(qname, NULL, base_uri); + if(!element) { + raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_FATAL, NULL, + "Out of memory"); + raptor_free_qname(qname); + rv = 1; /* error */ + break; + } + + switch (object->term->type) { + + case RAPTOR_TERM_TYPE_URI: + rv = raptor_rdfxmla_emit_resource(serializer, element, object, + depth + 1); + break; + + case RAPTOR_TERM_TYPE_LITERAL: + rv = raptor_rdfxmla_emit_literal(serializer, element, object, + depth + 1); + break; + + case RAPTOR_TERM_TYPE_BLANK: + rv = raptor_rdfxmla_emit_blank(serializer, element, 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 %u", + object->term->type); + break; + + } + + raptor_free_xml_element(element); + + } + + return rv; +} + + +/* + * raptor_rdfxmla_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_rdfxmla_emit_subject_properties(raptor_serializer* serializer, + raptor_abbrev_subject* subject, + int depth) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + int rv = 0; + raptor_avltree_iterator* iter = NULL; + raptor_term* subject_term = subject->node->term; + + RAPTOR_DEBUG_ABBREV_NODE("Emitting subject properties", subject->node); + + /* Emit any rdf:_n properties collected */ + if(raptor_sequence_size(subject->list_items) > 0) { + rv = raptor_rdfxmla_emit_subject_list_items(serializer, subject, depth + 1); + if(rv) + return rv; + } + + + if(subject->node_type && !context->write_typed_nodes) { + raptor_uri *base_uri = NULL; + raptor_qname *qname = NULL; + raptor_xml_element *element = NULL; + + /* if rdf:type was associated with this subject and do not want + * a typed node, emit it as a property element + */ + qname = raptor_new_qname_from_resource(context->namespaces, + context->nstack, + &context->namespace_count, + context->rdf_type); + if(!qname) + goto oom; + + if(serializer->base_uri) + base_uri = raptor_uri_copy(serializer->base_uri); + + element = raptor_new_xml_element(qname, NULL, base_uri); + if(!element) { + if(base_uri) + raptor_free_uri(base_uri); + raptor_free_qname(qname); + goto oom; + } + + rv = raptor_rdfxmla_emit_resource_uri(serializer, element, + subject_term->value.uri, + depth + 1); + raptor_free_xml_element(element); + } + + + for(iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1); + iter && !rv; + (rv = raptor_avltree_iterator_next(iter))) { + raptor_uri *base_uri = NULL; + raptor_qname *qname; + raptor_xml_element *element; + raptor_abbrev_node** nodes; + raptor_abbrev_node* predicate; + raptor_abbrev_node* object; + + nodes = (raptor_abbrev_node**)raptor_avltree_iterator_get(iter); + if(!nodes) + break; + predicate= nodes[0]; + object= nodes[1]; + + qname = raptor_new_qname_from_resource(context->namespaces, + context->nstack, + &context->namespace_count, + predicate); + if(!qname) { + raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Cannot split URI '%s' into an XML qname", + raptor_uri_as_string(predicate->term->value.uri)); + continue; + } + + if(serializer->base_uri) + base_uri = raptor_uri_copy(serializer->base_uri); + element = raptor_new_xml_element(qname, NULL, base_uri); + if(!element) { + if(base_uri) + raptor_free_uri(base_uri); + raptor_free_qname(qname); + goto oom; + } + + switch (object->term->type) { + + case RAPTOR_TERM_TYPE_URI: + rv = raptor_rdfxmla_emit_resource(serializer, element, object, + depth + 1); + break; + + case RAPTOR_TERM_TYPE_LITERAL: + rv = raptor_rdfxmla_emit_literal(serializer, element, object, + depth + 1); + break; + + case RAPTOR_TERM_TYPE_BLANK: + rv = raptor_rdfxmla_emit_blank(serializer, element, 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 %u", + object->term->type); + break; + } + + /* Return error if emitting something failed above */ + if(rv) + break; + + raptor_free_xml_element(element); + + } + if(iter) + raptor_free_avltree_iterator(iter); + + return rv; + + oom: + if(iter) + raptor_free_avltree_iterator(iter); + raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_FATAL, NULL, + "Out of memory"); + return 1; +} + + +/* + * raptor_rdfxmla_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_rdfxmla_emit_subject(raptor_serializer *serializer, + raptor_abbrev_subject* subject, + int depth) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_qname *qname = NULL; + raptor_xml_element *element = NULL; + raptor_qname **attrs; + unsigned char *attr_name; + unsigned char *attr_value; + raptor_uri *base_uri = NULL; + int subject_is_single_node; + raptor_term *subject_term = subject->node->term; + + if(!raptor_abbrev_subject_valid(subject)) + return 0; + + subject_is_single_node = (context->single_node && + subject_term->type == RAPTOR_TERM_TYPE_URI && + raptor_uri_equals(subject_term->value.uri, + context->single_node)); + + + RAPTOR_DEBUG_ABBREV_NODE("Emitting subject node", subject->node); + + if(!depth && + subject_term->type == RAPTOR_TERM_TYPE_BLANK && + subject->node->count_as_subject == 1 && + subject->node->count_as_object == 1) { + RAPTOR_DEBUG_ABBREV_NODE("Skipping subject node", subject->node); + return 0; + } + + + if(subject->node_type && context->write_typed_nodes) { + /* if rdf:type was associated with this subject */ + qname = raptor_new_qname_from_resource(context->namespaces, + context->nstack, + &context->namespace_count, + subject->node_type); + + if(!qname) { + raptor_log_error_formatted(serializer->world, + RAPTOR_LOG_LEVEL_ERROR, NULL, + "Cannot split URI '%s' into an XML qname", + raptor_uri_as_string(subject->node_type->term->value.uri)); + return 1; + } + + } else { + qname = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + (unsigned const char*)"Description", + NULL); + if(!qname) + goto oom; + } + + if(serializer->base_uri) + base_uri = raptor_uri_copy(serializer->base_uri); + element = raptor_new_xml_element(qname, NULL, base_uri); + if(!element) { + if(base_uri) + raptor_free_uri(base_uri); + raptor_free_qname(qname); + goto oom; + } + + attrs = RAPTOR_CALLOC(raptor_qname**, 1, sizeof(raptor_qname*)); + if(!attrs) + goto oom; + + attr_name = NULL; + attr_value = NULL; + + /* emit the subject node */ + if(subject_term->type == RAPTOR_TERM_TYPE_URI) { + attr_name = (unsigned char*)"about"; + if(context->is_xmp) { + /* XML rdf:about value is always "" */ + attr_value = RAPTOR_CALLOC(unsigned char*, 1, sizeof(unsigned char)); + } else if(RAPTOR_OPTIONS_GET_NUMERIC(serializer, + RAPTOR_OPTION_RELATIVE_URIS)) + attr_value = raptor_uri_to_relative_uri_string(serializer->base_uri, + subject_term->value.uri); + else + attr_value = raptor_uri_to_string(subject_term->value.uri); + + } else if(subject_term->type == RAPTOR_TERM_TYPE_BLANK) { + if(subject->node->count_as_subject && + subject->node->count_as_object && + !(subject->node->count_as_subject == 1 && + subject->node->count_as_object == 1)) { + /* No need for nodeID if this node is never used as a subject + * or object OR if it is used exactly once as subject and object. + */ + attr_name = (unsigned char*)"nodeID"; + attr_value = subject_term->value.blank.string; + } + } + + if(attr_name) { + attrs[0] = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + attr_name, + attr_value); + + if(subject_term->type != RAPTOR_TERM_TYPE_BLANK) + RAPTOR_FREE(char*, attr_value); + + if(!attrs[0]) { + RAPTOR_FREE(qnamearray, attrs); + goto oom; + } + + /* Note: if we were willing to track the in-scope rdf:lang, we + * could do the "2.5 Property Attributes" abbreviation here */ + raptor_xml_element_set_attributes(element, attrs, 1); + } else { + RAPTOR_FREE(qnamearray, attrs); + } + + if(!subject_is_single_node) { + raptor_xml_writer_start_element(context->xml_writer, element); + raptor_rdfxmla_emit_subject_properties(serializer, subject, depth + 1); + raptor_xml_writer_end_element(context->xml_writer, element); + } else + raptor_rdfxmla_emit_subject_properties(serializer, subject, depth); + + raptor_free_xml_element(element); + + return 0; + + oom: + if(element) + raptor_free_xml_element(element); + raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Out of memory"); + return 1; +} + + +/* + * raptor_rdfxmla_emit - + * @serializer: #raptor_serializer object + * + * Emit RDF/XML for all stored triples. + * + * Return value: non-0 on failure + **/ +static int +raptor_rdfxmla_emit(raptor_serializer *serializer) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_abbrev_subject* subject; + raptor_abbrev_subject* blank; + 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) { + raptor_rdfxmla_emit_subject(serializer, subject, context->starting_depth); + } + if(raptor_avltree_iterator_next(iter)) + break; + } + if(iter) + raptor_free_avltree_iterator(iter); + + if(!context->single_node) { + /* 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) { + raptor_rdfxmla_emit_subject(serializer, blank, context->starting_depth); + } + if(raptor_avltree_iterator_next(iter)) + break; + } + if(iter) + raptor_free_avltree_iterator(iter); + } + + return 0; +} + + +/* + * raptor serializer rdfxml-abbrev implementation + */ + + +static void +raptor_rdfxmla_serialize_init_nstack(raptor_serializer* serializer, + raptor_namespace_stack *nstack) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + + context->xml_nspace = raptor_new_namespace(context->nstack, + (const unsigned char*)"xml", + raptor_xml_namespace_uri, + context->starting_depth); + + context->rdf_nspace = raptor_new_namespace(context->nstack, + (const unsigned char*)"rdf", + raptor_rdf_namespace_uri, + context->starting_depth); +} + + + +/* create a new serializer */ +static int +raptor_rdfxmla_serialize_init(raptor_serializer* serializer, const char *name) +{ + raptor_rdfxmla_context* context; + raptor_term* type_term; + + context = (raptor_rdfxmla_context*)serializer->context; + + context->nstack = raptor_new_namespaces(serializer->world, 1); + if(!context->nstack) + return 1; + + raptor_rdfxmla_serialize_init_nstack(serializer, context->nstack); + + context->namespaces = raptor_new_sequence(NULL, NULL); + + context->subjects = + raptor_new_avltree((raptor_data_compare_handler)raptor_abbrev_subject_compare, + (raptor_data_free_handler)raptor_free_abbrev_subject, 0); + + context->blanks = + raptor_new_avltree((raptor_data_compare_handler)raptor_abbrev_subject_compare, + (raptor_data_free_handler)raptor_free_abbrev_subject, 0); + + context->nodes = + raptor_new_avltree((raptor_data_compare_handler)raptor_abbrev_node_compare, + (raptor_data_free_handler)raptor_free_abbrev_node, 0); + + type_term = RAPTOR_RDF_type_term(serializer->world); + context->rdf_type = raptor_new_abbrev_node(serializer->world, type_term); + + if(!context->xml_nspace || !context->rdf_nspace || !context->namespaces || + !context->subjects || !context->blanks || !context->nodes || + !context->rdf_type) { + raptor_rdfxmla_serialize_terminate(serializer); + return 1; + } + + context->is_xmp=!strncmp(name, "rdfxml-xmp", 10); + if(context->is_xmp) + RAPTOR_OPTIONS_SET_NUMERIC(serializer, + RAPTOR_OPTION_WRITER_XML_DECLARATION, 0); + + /* Note: item 0 in the list is rdf:RDF's namespace */ + if(raptor_sequence_push(context->namespaces, context->rdf_nspace)) { + raptor_rdfxmla_serialize_terminate(serializer); + return 1; + } + + context->write_rdf_RDF = 1; + context->starting_depth = 0; + context->single_node = NULL; + context->write_typed_nodes = 1; + + return 0; +} + + +/* destroy a serializer */ +static void +raptor_rdfxmla_serialize_terminate(raptor_serializer* serializer) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + + if(context->xml_writer) { + if(!context->external_xml_writer) + raptor_free_xml_writer(context->xml_writer); + context->xml_writer = NULL; + context->external_xml_writer = 0; + } + + if(context->rdf_RDF_element) { + raptor_free_xml_element(context->rdf_RDF_element); + context->rdf_RDF_element = NULL; + } + + if(context->rdf_nspace) { + raptor_free_namespace(context->rdf_nspace); + context->rdf_nspace = NULL; + } + + if(context->xml_nspace) { + raptor_free_namespace(context->xml_nspace); + context->xml_nspace = NULL; + } + + if(context->namespaces) { + int i; + + /* Note: item 0 in the list is rdf:RDF's namespace and freed above */ + for(i = 1; i< raptor_sequence_size(context->namespaces); i++) { + raptor_namespace* ns; + ns = (raptor_namespace*)raptor_sequence_get_at(context->namespaces, i); + if(ns) + raptor_free_namespace(ns); + } + raptor_free_sequence(context->namespaces); + context->namespaces = NULL; + } + + if(context->subjects) { + raptor_free_avltree(context->subjects); + context->subjects = NULL; + } + + if(context->blanks) { + raptor_free_avltree(context->blanks); + context->blanks = NULL; + } + + if(context->nodes) { + raptor_free_avltree(context->nodes); + context->nodes = NULL; + } + + /* always free raptor_namespace* before stack */ + if(context->nstack) { + if(!context->external_nstack) + raptor_free_namespaces(context->nstack); + context->nstack = NULL; + } + + if(context->rdf_type) { + raptor_free_abbrev_node(context->rdf_type); + context->rdf_type = NULL; + } +} + + +#define RDFXMLA_NAMESPACE_DEPTH 0 + +/* add a namespace */ +static int +raptor_rdfxmla_serialize_declare_namespace_from_namespace(raptor_serializer* serializer, + raptor_namespace *nspace) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + int i; + + if(context->written_header) + return 1; + + for(i = 0; i< raptor_sequence_size(context->namespaces); i++) { + raptor_namespace* ns; + ns = (raptor_namespace*)raptor_sequence_get_at(context->namespaces, i); + + /* If prefix is already declared, ignore it */ + if(!ns->prefix && !nspace->prefix) + return 1; + + if(ns->prefix && nspace->prefix && + !strcmp((const char*)ns->prefix, (const char*)nspace->prefix)) + return 1; + + if(ns->uri && nspace->uri && + raptor_uri_equals(ns->uri, nspace->uri)) + return 1; + } + + nspace = raptor_new_namespace_from_uri(context->nstack, + nspace->prefix, nspace->uri, + context->starting_depth + + RDFXMLA_NAMESPACE_DEPTH); + if(!nspace) + return 1; + + raptor_sequence_push(context->namespaces, nspace); + return 0; +} + + +/* add a namespace */ +static int +raptor_rdfxmla_serialize_declare_namespace(raptor_serializer* serializer, + raptor_uri *uri, + const unsigned char *prefix) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_namespace *ns; + int rc; + + ns = raptor_new_namespace_from_uri(context->nstack, prefix, uri, + context->starting_depth + + RDFXMLA_NAMESPACE_DEPTH); + + rc = raptor_rdfxmla_serialize_declare_namespace_from_namespace(serializer, + ns); + raptor_free_namespace(ns); + + return rc; +} + + +/* + * raptor_rdfxmla_serialize_set_write_rdf_RDF: + * @serializer: serializer object + * @value: value + * + * INTERNAL - Set flag to write rdf:RDF root element + * + * Return value: non-0 on failure + */ +int +raptor_rdfxmla_serialize_set_write_rdf_RDF(raptor_serializer* serializer, + int value) +{ + raptor_rdfxmla_context* context; + + if(strcmp(serializer->factory->desc.names[0], "rdfxml-abbrev")) + return 1; + + context = (raptor_rdfxmla_context*)serializer->context; + + context->write_rdf_RDF = value; + + return 0; +} + + +/* + * raptor_rdfxmla_serialize_set_xml_writer: + * @serializer: serializer object + * @xml_writer: XML writer + * @nstack: namespace stack + * + * INTERNAL - Set an existing created XML writer to write the serializing to + * + * Return value: non-0 on failure + */ +int +raptor_rdfxmla_serialize_set_xml_writer(raptor_serializer* serializer, + raptor_xml_writer* xml_writer, + raptor_namespace_stack *nstack) +{ + raptor_rdfxmla_context* context; + + if(strcmp(serializer->factory->desc.names[0], "rdfxml-abbrev")) + return 1; + + context = (raptor_rdfxmla_context*)serializer->context; + + context->xml_writer = xml_writer; + context->starting_depth = xml_writer ? (raptor_xml_writer_get_depth(xml_writer) + 1) : -1; + context->external_xml_writer = (xml_writer != NULL); + + if(context->xml_nspace) + raptor_free_namespace(context->xml_nspace); + if(context->rdf_nspace) + raptor_free_namespace(context->rdf_nspace); + /* always free raptor_namespace* before stack */ + if(context->nstack) + raptor_free_namespaces(context->nstack); + + context->nstack = nstack; + context->external_nstack = 1; + raptor_rdfxmla_serialize_init_nstack(serializer, context->nstack); + + return 0; +} + + +/* + * raptor_rdfxmla_serialize_set_single_node: + * @serializer: + * @uri: + * + * INTERNAL - Set a single node to serialize the contents + * + * The outer node element with this URI is not serialized, the inner + * property elements are written. @uri is copied + * + * Return value: non-0 on failure + */ +int +raptor_rdfxmla_serialize_set_single_node(raptor_serializer* serializer, + raptor_uri* uri) +{ + raptor_rdfxmla_context* context; + + if(strcmp(serializer->factory->desc.names[0], "rdfxml-abbrev")) + return 1; + + context = (raptor_rdfxmla_context*)serializer->context; + + if(context->single_node) + raptor_free_uri(context->single_node); + + context->single_node = raptor_uri_copy(uri); + + return 0; +} + + +/* + * raptor_rdfxmla_serialize_set_write_typed_nodes: + * @serializer: + * @value: + * + * INTERNAL - Set flag to write typed node elements + * + * Return value: non-0 on failure + */ +int +raptor_rdfxmla_serialize_set_write_typed_nodes(raptor_serializer* serializer, + int value) +{ + raptor_rdfxmla_context* context; + + if(strcmp(serializer->factory->desc.names[0], "rdfxml-abbrev")) + return 1; + + context = (raptor_rdfxmla_context*)serializer->context; + + context->write_typed_nodes = value; + + return 0; +} + + +/* start a serialize */ +static int +raptor_rdfxmla_serialize_start(raptor_serializer* serializer) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + + if(!context->external_xml_writer) { + raptor_xml_writer* xml_writer; + raptor_option option; + + if(context->xml_writer) + raptor_free_xml_writer(context->xml_writer); + + xml_writer = raptor_new_xml_writer(serializer->world, context->nstack, + serializer->iostream); + if(!xml_writer) + return 1; + + raptor_xml_writer_set_option(xml_writer, + RAPTOR_OPTION_WRITER_AUTO_INDENT, NULL,1); + raptor_xml_writer_set_option(xml_writer, + RAPTOR_OPTION_WRITER_AUTO_EMPTY, NULL, 1); + raptor_xml_writer_set_option(xml_writer, + RAPTOR_OPTION_WRITER_INDENT_WIDTH, NULL, 2); + option = RAPTOR_OPTION_WRITER_XML_VERSION; + raptor_xml_writer_set_option(xml_writer, option, NULL, + RAPTOR_OPTIONS_GET_NUMERIC(serializer, option)); + option = RAPTOR_OPTION_WRITER_XML_DECLARATION; + raptor_xml_writer_set_option(xml_writer, option, NULL, + RAPTOR_OPTIONS_GET_NUMERIC(serializer, option)); + + context->xml_writer = xml_writer; + } + + return 0; +} + + +static int +raptor_rdfxmla_ensure_writen_header(raptor_serializer* serializer, + raptor_rdfxmla_context* context) +{ + raptor_xml_writer* xml_writer; + raptor_qname *qname; + raptor_uri *base_uri; + int i; + raptor_qname **attrs = NULL; + int attrs_count = 0; + + if(context->written_header) + return 0; /* already succeeded */ + + if(!context->write_rdf_RDF) { + context->written_header = 1; + return 0; + } + + xml_writer = context->xml_writer; + if(context->is_xmp) + raptor_xml_writer_raw(xml_writer, + (const unsigned char*)"<?xpacket begin='' id='W5M0MpCehiHzreSzNTczkc9d'?>\n<x:xmpmeta xmlns:x='adobe:ns:meta/'>\n"); + + qname = raptor_new_qname_from_namespace_local_name(serializer->world, + context->rdf_nspace, + (const unsigned char*)"RDF", + NULL); + if(!qname) + goto oom; + base_uri = serializer->base_uri; + if(base_uri) + base_uri = raptor_uri_copy(base_uri); + context->rdf_RDF_element = raptor_new_xml_element(qname, NULL, base_uri); + if(!context->rdf_RDF_element) { + if(base_uri) + raptor_free_uri(base_uri); + raptor_free_qname(qname); + goto oom; + } + + /* NOTE: Starts at item 1 as item 0 is the element's namespace (rdf) + * and does not need to be declared + */ + for(i = 1; i< raptor_sequence_size(context->namespaces); i++) { + raptor_namespace* ns; + ns = (raptor_namespace*)raptor_sequence_get_at(context->namespaces, i); + raptor_xml_element_declare_namespace(context->rdf_RDF_element, ns); + } + + if(base_uri && + RAPTOR_OPTIONS_GET_NUMERIC(serializer, RAPTOR_OPTION_WRITE_BASE_URI)) { + const unsigned char* base_uri_string; + + attrs = RAPTOR_CALLOC(raptor_qname**, 1, sizeof(raptor_qname*)); + if(!attrs) + goto oom; + + base_uri_string = raptor_uri_as_string(base_uri); + attrs[attrs_count] = raptor_new_qname_from_namespace_local_name(serializer->world, + context->xml_nspace, + (const unsigned char*)"base", + base_uri_string); + if(!attrs[attrs_count]) { + RAPTOR_FREE(qnamearray, attrs); + goto oom; + } + attrs_count++; + } + + if(attrs_count) + raptor_xml_element_set_attributes(context->rdf_RDF_element, attrs, + attrs_count); + else + raptor_xml_element_set_attributes(context->rdf_RDF_element, NULL, 0); + + + + raptor_xml_writer_start_element(xml_writer, context->rdf_RDF_element); + + context->written_header = 1; + + return 0; + + oom: + raptor_log_error(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Out of memory"); + return 1; +} + + +/* serialize a statement */ +static int +raptor_rdfxmla_serialize_statement(raptor_serializer* serializer, + raptor_statement *statement) +{ + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_abbrev_subject* subject = NULL; + raptor_abbrev_node* predicate = NULL; + raptor_abbrev_node* object = NULL; + int rv = 0; + raptor_term_type object_type; + + if(!(statement->subject->type == RAPTOR_TERM_TYPE_URI || + statement->subject->type == RAPTOR_TERM_TYPE_BLANK)) { + raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Cannot serialize a triple with subject node type %u", + statement->subject->type); + return 1; + } + + subject = raptor_abbrev_subject_lookup(context->nodes, context->subjects, + context->blanks, + statement->subject); + if(!subject) + return 1; + + object_type = statement->object->type; + + if(!(object_type == RAPTOR_TERM_TYPE_URI || + object_type == RAPTOR_TERM_TYPE_BLANK || + object_type == RAPTOR_TERM_TYPE_LITERAL)) { + raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Cannot serialize a triple with object node type %u", + object_type); + return 1; + } + + object = raptor_abbrev_node_lookup(context->nodes, + statement->object); + if(!object) + return 1; + + + if(statement->predicate->type == RAPTOR_TERM_TYPE_URI) { + predicate = raptor_abbrev_node_lookup(context->nodes, statement->predicate); + if(!predicate) + return 1; + + if(!subject->node_type && + raptor_abbrev_node_equals(predicate, context->rdf_type) && + statement->object->type == RAPTOR_TERM_TYPE_URI) { + + /* Store the first one as the type for abbreviation 2.14 + * purposes. Note that it is perfectly legal to have + * multiple type definitions. All definitions after the + * first go in the property list */ + subject->node_type = raptor_abbrev_node_lookup(context->nodes, + statement->object); + if(!subject->node_type) + return 1; + subject->node_type->ref_count++; + return 0; + + } else { + int add_property = 1; + + if(context->is_xmp && predicate->ref_count > 1) { + raptor_avltree_iterator* iter = NULL; + for((iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1)); + iter && !rv; + (rv = raptor_avltree_iterator_next(iter))) { + raptor_abbrev_node** nodes; + raptor_abbrev_node* node; + + nodes = (raptor_abbrev_node**)raptor_avltree_iterator_get(iter); + if(!nodes) + break; + node= nodes[0]; + + if(node == predicate) { + add_property = 0; + if(object->term->type == RAPTOR_TERM_TYPE_BLANK) { + /* look for any generated blank node associated with this + * statement and free it + */ + raptor_abbrev_subject *blank = + raptor_abbrev_subject_find(context->blanks, + statement->object); + if(subject) raptor_avltree_delete(context->blanks, blank); + } + break; + } + } + if(iter) + raptor_free_avltree_iterator(iter); + } + + if(add_property) { + rv = raptor_abbrev_subject_add_property(subject, predicate, object); + if(rv < 0) { + raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Unable to add properties to subject %p", + RAPTOR_VOIDP(subject)); + return rv; + } + } + } + + } else { + raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + "Cannot serialize a triple with predicate node type %u", + statement->predicate->type); + return 1; + } + + if(object_type == RAPTOR_TERM_TYPE_URI || + object_type == RAPTOR_TERM_TYPE_BLANK) + object->count_as_object++; + + + return 0; + +} + + +/* end a serialize */ +static int +raptor_rdfxmla_serialize_end(raptor_serializer* serializer) +{ + + raptor_rdfxmla_context* context = (raptor_rdfxmla_context*)serializer->context; + raptor_xml_writer* xml_writer = context->xml_writer; + + if(xml_writer) { + if(!raptor_rdfxmla_ensure_writen_header(serializer, context)) { + + raptor_rdfxmla_emit(serializer); + + if(context->write_rdf_RDF) { + /* ensure_writen_header() returned success, can assume context->rdf_RDF_element is non-NULL */ + raptor_xml_writer_end_element(xml_writer, context->rdf_RDF_element); + + raptor_xml_writer_raw_counted(xml_writer, (const unsigned char*)"\n", 1); + } + } + } + + if(context->rdf_RDF_element) { + raptor_free_xml_element(context->rdf_RDF_element); + context->rdf_RDF_element = NULL; + } + + if(context->is_xmp && xml_writer) + raptor_xml_writer_raw(xml_writer, + (const unsigned char*)"</x:xmpmeta>\n<?xpacket end='r'?>\n"); + + if(xml_writer) + raptor_xml_writer_flush(xml_writer); + + if(context->single_node) + raptor_free_uri(context->single_node); + + context->written_header = 0; + + return 0; +} + + +/* finish the serializer factory */ +static void +raptor_rdfxmla_serialize_finish_factory(raptor_serializer_factory* factory) +{ + /* NOP */ +} + + +static const char* const rdfxml_xmp_names[2] = { "rdfxml-xmp", NULL}; + +static const char* const rdfxml_xmp_uri_strings[2] = { + "http://www.w3.org/TR/rdf-syntax-grammar", + NULL +}; + +#define RDFXML_XMP_TYPES_COUNT 1 +static const raptor_type_q rdfxml_xmp_types[RDFXML_XMP_TYPES_COUNT + 1] = { + { "application/rdf+xml", 19, 0}, + { NULL, 0, 0} +}; + +static int +raptor_rdfxml_xmp_serializer_register_factory(raptor_serializer_factory *factory) +{ + factory->desc.names = rdfxml_xmp_names; + factory->desc.mime_types = rdfxml_xmp_types; + + factory->desc.label = "RDF/XML (XMP Profile)"; + factory->desc.uri_strings = rdfxml_xmp_uri_strings; + + factory->context_length = sizeof(raptor_rdfxmla_context); + + factory->init = raptor_rdfxmla_serialize_init; + factory->terminate = raptor_rdfxmla_serialize_terminate; + factory->declare_namespace = raptor_rdfxmla_serialize_declare_namespace; + factory->declare_namespace_from_namespace = raptor_rdfxmla_serialize_declare_namespace_from_namespace; + factory->serialize_start = raptor_rdfxmla_serialize_start; + factory->serialize_statement = raptor_rdfxmla_serialize_statement; + factory->serialize_end = raptor_rdfxmla_serialize_end; + factory->finish_factory = raptor_rdfxmla_serialize_finish_factory; + + return 0; +} + + +static const char* const rdfxmla_names[2] = { "rdfxml-abbrev", NULL}; + +static const char* const rdfxml_uri_strings[3] = { + "http://www.w3.org/ns/formats/RDF_XML", + "http://www.w3.org/TR/rdf-syntax-grammar", + NULL +}; + +#define RDFXMLA_TYPES_COUNT 1 +static const raptor_type_q rdfxmla_types[RDFXMLA_TYPES_COUNT + 1] = { + { "application/rdf+xml", 19, 0}, + { NULL, 0, 0} +}; + +static int +raptor_rdfxmla_serializer_register_factory(raptor_serializer_factory *factory) +{ + factory->desc.names = rdfxmla_names; + factory->desc.mime_types = rdfxmla_types; + + factory->desc.label = "RDF/XML (Abbreviated)"; + factory->desc.uri_strings = rdfxml_uri_strings; + + factory->context_length = sizeof(raptor_rdfxmla_context); + + factory->init = raptor_rdfxmla_serialize_init; + factory->terminate = raptor_rdfxmla_serialize_terminate; + factory->declare_namespace = raptor_rdfxmla_serialize_declare_namespace; + factory->declare_namespace_from_namespace = raptor_rdfxmla_serialize_declare_namespace_from_namespace; + factory->serialize_start = raptor_rdfxmla_serialize_start; + factory->serialize_statement = raptor_rdfxmla_serialize_statement; + factory->serialize_end = raptor_rdfxmla_serialize_end; + factory->finish_factory = raptor_rdfxmla_serialize_finish_factory; + + return 0; +} + + +int +raptor_init_serializer_rdfxmla(raptor_world* world) +{ + int rc; + + rc = !raptor_serializer_register_factory(world, + &raptor_rdfxml_xmp_serializer_register_factory); + if(rc) + return rc; + + rc = !raptor_serializer_register_factory(world, + &raptor_rdfxmla_serializer_register_factory); + + return rc; +} + |