diff options
Diffstat (limited to 'axiom/src/parser/libxml2/libxml2_writer_wrapper.c')
-rw-r--r-- | axiom/src/parser/libxml2/libxml2_writer_wrapper.c | 1571 |
1 files changed, 1571 insertions, 0 deletions
diff --git a/axiom/src/parser/libxml2/libxml2_writer_wrapper.c b/axiom/src/parser/libxml2/libxml2_writer_wrapper.c new file mode 100644 index 0000000..4c889d4 --- /dev/null +++ b/axiom/src/parser/libxml2/libxml2_writer_wrapper.c @@ -0,0 +1,1571 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <libxml/xmlwriter.h> +#include <axutil_utils.h> +#include <axutil_utils_defines.h> +#include <axutil_env.h> +#include <axiom_xml_writer.h> +#include <axutil_string.h> +#include <string.h> +#include <axutil_stack.h> +#include <axutil_hash.h> +#include <axutil_array_list.h> + +/*******************************************************************************/ + +#define ENCODING "ISO-8859-1" + +#define AXIS2_XMLNS_NAMESPACE_URI "http://www.w3.org/XML/1998/namespace" +#define AXIS2_XMLNS_PREFIX "xml" + +typedef struct uri_prefix_element +{ + axis2_char_t *prefix; + + axis2_char_t *uri; + + axis2_char_t *real_prefix; + + axis2_char_t *key; + +} uri_prefix_element_t; + +typedef struct axis2_libxml2_writer_wrapper_impl +{ + axiom_xml_writer_t writer; + + xmlTextWriterPtr xml_writer; + + xmlBufferPtr buffer; + + xmlDocPtr doc; + + int writer_type; + + axis2_char_t *encoding; + + int is_prefix_defaulting; + + int compression; + + axutil_stack_t *stack; + + axis2_bool_t in_empty_element; + + axis2_bool_t in_start_element; + + axutil_hash_t *uri_prefix_map; + + uri_prefix_element_t *default_lang_namespace; + +} axis2_libxml2_writer_wrapper_impl_t; + +#define AXIS2_INTF_TO_IMPL(p) ((axis2_libxml2_writer_wrapper_impl_t*)p) + +void AXIS2_CALL axis2_libxml2_writer_wrapper_free( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_end_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_element_with_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_element_with_namespace_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri, + axis2_char_t * prefix); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_empty_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_empty_element_with_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_empty_element_with_namespace_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri, + axis2_char_t * prefix); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_end_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_end_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_attribute( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_attribute_with_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value, + axis2_char_t * namespace_uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_attribute_with_namespace_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value, + axis2_char_t * namespace_uri, + axis2_char_t * prefix); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * prefix, + axis2_char_t * namespace_uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_default_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * namespace_uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_comment( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * value); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_processing_instruction( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * target); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_processing_instruction_data( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * target, + axis2_char_t * data); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_cdata( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * data); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_dtd( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * dtd); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_entity_ref( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * name); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_document_with_version( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * version); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_document_with_version_encoding( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * encoding, + axis2_char_t * version); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_characters( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text); + +axis2_char_t *AXIS2_CALL axis2_libxml2_writer_wrapper_get_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_set_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * prefix, + axis2_char_t * uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_set_default_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_encoded( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text, + int in_attr); + +void *AXIS2_CALL axis2_libxml2_writer_wrapper_get_xml( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +unsigned int AXIS2_CALL axis2_libxml2_writer_wrapper_get_xml_size( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_flush( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +int AXIS2_CALL axis2_libxml2_writer_wrapper_get_type( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_raw( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * content); + +static axis2_status_t +axis2_libxml2_writer_wrapper_push( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + const axis2_char_t * uri, + const axis2_char_t * prefix); + +static axis2_bool_t +axis2_libxml2_writer_wrapper_is_namespace_declared( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * key); + +static void +uri_prefix_element_free( + uri_prefix_element_t * up_element, + const axutil_env_t * env); + +static uri_prefix_element_t * +uri_prefix_element_create( + const axutil_env_t * env, + const axis2_char_t * uri, + const axis2_char_t * prefix, + const axis2_char_t * real_prefix, + const axis2_char_t * key); + +static void +create_key_from_uri_prefix( + const axutil_env_t * env, + const axis2_char_t * uri, + const axis2_char_t * prefix, + axis2_char_t * array); + +static axis2_char_t * +axis2_libxml2_writer_wrapper_find_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri); + +static uri_prefix_element_t * +axis2_libxml2_writer_wrapper_find_prefix_in_context( + axutil_array_list_t * context, + const axutil_env_t * env, + axis2_char_t * uri); + +static const axiom_xml_writer_ops_t axiom_xml_writer_ops_var = { axis2_libxml2_writer_wrapper_free, + axis2_libxml2_writer_wrapper_write_start_element, + axis2_libxml2_writer_wrapper_end_start_element, + axis2_libxml2_writer_wrapper_write_start_element_with_namespace, + axis2_libxml2_writer_wrapper_write_start_element_with_namespace_prefix, + axis2_libxml2_writer_wrapper_write_empty_element, + axis2_libxml2_writer_wrapper_write_empty_element_with_namespace, + axis2_libxml2_writer_wrapper_write_empty_element_with_namespace_prefix, + axis2_libxml2_writer_wrapper_write_end_element, + axis2_libxml2_writer_wrapper_write_end_document, axis2_libxml2_writer_wrapper_write_attribute, + axis2_libxml2_writer_wrapper_write_attribute_with_namespace, + axis2_libxml2_writer_wrapper_write_attribute_with_namespace_prefix, + axis2_libxml2_writer_wrapper_write_namespace, + axis2_libxml2_writer_wrapper_write_default_namespace, + axis2_libxml2_writer_wrapper_write_comment, + axis2_libxml2_writer_wrapper_write_processing_instruction, + axis2_libxml2_writer_wrapper_write_processing_instruction_data, + axis2_libxml2_writer_wrapper_write_cdata, axis2_libxml2_writer_wrapper_write_dtd, + axis2_libxml2_writer_wrapper_write_entity_ref, + axis2_libxml2_writer_wrapper_write_start_document, + axis2_libxml2_writer_wrapper_write_start_document_with_version, + axis2_libxml2_writer_wrapper_write_start_document_with_version_encoding, + axis2_libxml2_writer_wrapper_write_characters, axis2_libxml2_writer_wrapper_get_prefix, + axis2_libxml2_writer_wrapper_set_prefix, axis2_libxml2_writer_wrapper_set_default_prefix, + axis2_libxml2_writer_wrapper_write_encoded, axis2_libxml2_writer_wrapper_get_xml, + axis2_libxml2_writer_wrapper_get_xml_size, axis2_libxml2_writer_wrapper_get_type, + axis2_libxml2_writer_wrapper_write_raw, axis2_libxml2_writer_wrapper_flush }; + +AXIS2_EXTERN axiom_xml_writer_t *AXIS2_CALL +axiom_xml_writer_create( + const axutil_env_t * env, + axis2_char_t * filename, + axis2_char_t * encoding, + int is_prefix_default, + int compression) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + writer_impl = (axis2_libxml2_writer_wrapper_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_libxml2_writer_wrapper_impl_t)); + if(!writer_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create an XML writer wrapper"); + return NULL; + } + writer_impl->xml_writer = xmlNewTextWriterFilename(filename, compression); + + if(!(writer_impl->xml_writer)) + { + AXIS2_FREE(env->allocator, writer_impl); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_CREATING_XML_STREAM_WRITER, AXIS2_FAILURE); + return NULL; + } + writer_impl->buffer = NULL; + writer_impl->encoding = NULL; + writer_impl->compression = 0; + writer_impl->in_empty_element = AXIS2_FALSE; + writer_impl->in_start_element = AXIS2_FALSE; + writer_impl->stack = NULL; + writer_impl->uri_prefix_map = NULL; + writer_impl->default_lang_namespace = NULL; + + writer_impl->writer_type = AXIS2_XML_PARSER_TYPE_FILE; + writer_impl->compression = compression; + + if(encoding) + { + writer_impl->encoding = axutil_strdup(env, encoding); + } + else + { + writer_impl->encoding = axutil_strdup(env, ENCODING); + } + + writer_impl->uri_prefix_map = axutil_hash_make(env); + if(!(writer_impl->uri_prefix_map)) + { + axis2_libxml2_writer_wrapper_free(&(writer_impl->writer), env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create URI prefix hash map"); + return NULL; + } + writer_impl->writer.ops = &axiom_xml_writer_ops_var; + return &(writer_impl->writer); +} + +AXIS2_EXTERN axiom_xml_writer_t *AXIS2_CALL +axiom_xml_writer_create_for_memory( + const axutil_env_t * env, + axis2_char_t * encoding, + int is_prefix_default, + int compression, + int type) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + writer_impl = (axis2_libxml2_writer_wrapper_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_libxml2_writer_wrapper_impl_t)); + if(!writer_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create writer wrapper"); + return NULL; + } + + writer_impl->encoding = NULL; + writer_impl->buffer = NULL; + writer_impl->doc = NULL; + writer_impl->in_empty_element = AXIS2_FALSE; + writer_impl->in_start_element = AXIS2_FALSE; + writer_impl->stack = NULL; + writer_impl->uri_prefix_map = NULL; + writer_impl->default_lang_namespace = NULL; + writer_impl->compression = compression; + + if(AXIS2_XML_PARSER_TYPE_BUFFER == type) + { + writer_impl->writer_type = AXIS2_XML_PARSER_TYPE_BUFFER; + writer_impl->buffer = xmlBufferCreate(); + if(!(writer_impl->buffer)) + { + axis2_libxml2_writer_wrapper_free(&(writer_impl->writer), env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create a buffer for writer wrapper"); + return NULL; + } + + writer_impl->xml_writer = xmlNewTextWriterMemory(writer_impl->buffer, 0); + } + else if(AXIS2_XML_PARSER_TYPE_DOC == type) + { + writer_impl->writer_type = AXIS2_XML_PARSER_TYPE_DOC; + writer_impl->xml_writer = xmlNewTextWriterDoc(&writer_impl->doc, 0); + } + else + { + axis2_libxml2_writer_wrapper_free(&(writer_impl->writer), env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_XML_PARSER_INVALID_MEM_TYPE, AXIS2_FAILURE); + return NULL; + } + + if(!(writer_impl->xml_writer)) + { + axis2_libxml2_writer_wrapper_free(&(writer_impl->writer), env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_CREATING_XML_STREAM_WRITER, AXIS2_FAILURE); + return NULL; + } + + if(encoding) + { + writer_impl->encoding = axutil_strdup(env, encoding); + } + else + { + writer_impl->encoding = axutil_strdup(env, ENCODING); + } + + writer_impl->uri_prefix_map = axutil_hash_make(env); + if(!(writer_impl->uri_prefix_map)) + { + axis2_libxml2_writer_wrapper_free(&(writer_impl->writer), env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create URI prefix hash map"); + return NULL; + } + writer_impl->stack = axutil_stack_create(env); + if(!(writer_impl->stack)) + { + axis2_libxml2_writer_wrapper_free(&(writer_impl->writer), env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create the stack for writer wrapper"); + return NULL; + } + + writer_impl->writer.ops = &axiom_xml_writer_ops_var; + + return &(writer_impl->writer); +} + +void AXIS2_CALL +axis2_libxml2_writer_wrapper_free( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + if(writer_impl->xml_writer) + { + xmlFreeTextWriter(writer_impl->xml_writer); + writer_impl->xml_writer = NULL; + } + if(writer_impl->buffer) + { + xmlBufferFree(writer_impl->buffer); + writer_impl->buffer = NULL; + } + if(writer_impl->encoding) + { + AXIS2_FREE(env->allocator, writer_impl->encoding); + writer_impl->encoding = NULL; + } + if(writer_impl->uri_prefix_map) + { + axutil_hash_free(writer_impl->uri_prefix_map, env); + writer_impl->uri_prefix_map = NULL; + } + if(writer_impl->stack) + { + axutil_stack_free(writer_impl->stack, env); + writer_impl->stack = NULL; + } + if(writer_impl->default_lang_namespace) + { + uri_prefix_element_free(writer_impl->default_lang_namespace, env); + writer_impl->default_lang_namespace = NULL; + } + + AXIS2_FREE(env->allocator, writer_impl); + writer_impl = NULL; + return; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname) +{ + int status = 0; + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + writer_impl->in_start_element = AXIS2_TRUE; + + status = xmlTextWriterStartElement(writer_impl->xml_writer, (xmlChar *)localname); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_ELEMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_end_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + /* nothing to do , + it is automatically taken care by the libxml2 writer */ + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_element_with_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterStartElementNS(writer_impl->xml_writer, + NULL, BAD_CAST localname, NULL); + + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_ELEMENT_WITH_NAMESPACE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_element_with_namespace_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri, + axis2_char_t * prefix) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + writer_impl->in_start_element = AXIS2_TRUE; + + status = xmlTextWriterStartElementNS(writer_impl->xml_writer, + BAD_CAST prefix, + BAD_CAST localname, BAD_CAST NULL); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_ELEMENT_WITH_NAMESPACE_PREFIX, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_empty_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname) +{ + int status = 0; + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterStartElement(writer_impl->xml_writer, (xmlChar *)localname); + + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_EMPTY_ELEMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + status = xmlTextWriterEndElement(writer_impl->xml_writer); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_EMPTY_ELEMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_empty_element_with_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterStartElementNS(writer_impl->xml_writer, + NULL, BAD_CAST localname, + BAD_CAST namespace_uri); + + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_EMPTY_ELEMENT_WITH_NAMESPACE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + status = xmlTextWriterEndElement(writer_impl->xml_writer); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_EMPTY_ELEMENT_WITH_NAMESPACE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_empty_element_with_namespace_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * namespace_uri, + axis2_char_t * prefix) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterStartElementNS(writer_impl->xml_writer, + BAD_CAST prefix, + BAD_CAST localname, BAD_CAST NULL); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_ELEMENT_WITH_NAMESPACE_PREFIX, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + status = xmlTextWriterEndElement(writer_impl->xml_writer); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_EMPTY_ELEMENT_WITH_NAMESPACE_PREFIX, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_end_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + writer_impl->in_start_element = AXIS2_FALSE; + /* write an empty element in case the element is empty, + status = xmlTextWriterFullEndElement(writer_impl->xml_writer); + Above call write it like <a></a>. + Call below will write it like <a/> */ + status = xmlTextWriterEndElement(writer_impl->xml_writer); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_END_ELEMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_end_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterEndDocument(writer_impl->xml_writer); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_END_DOCUMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_attribute( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + if(!value) + { + value = ""; + } + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterWriteAttribute(writer_impl->xml_writer, + BAD_CAST localname, BAD_CAST value); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_ATTRIBUTE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_attribute_with_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value, + axis2_char_t * namespace_uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + + if(!value) + { + value = ""; + } + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterWriteAttributeNS(writer_impl->xml_writer, + NULL, BAD_CAST localname, + BAD_CAST NULL, BAD_CAST value); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_ATTRIBUTE_WITH_NAMESPACE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_attribute_with_namespace_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value, + axis2_char_t * namespace_uri, + axis2_char_t * prefix) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + + if(!value) + { + value = ""; + } + writer_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterWriteAttributeNS(writer_impl->xml_writer, + BAD_CAST prefix, BAD_CAST localname, + BAD_CAST NULL, BAD_CAST value); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_ATTRIBUTE_WITH_NAMESPACE_PREFIX, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +/** need to work on this */ +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * prefix, + axis2_char_t * namespace_uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + char *xmlnsprefix = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + if(prefix && (axutil_strcmp(prefix, "") != 0)) + { + xmlnsprefix = (axis2_char_t *)AXIS2_MALLOC(env->allocator, (sizeof(char) * (axutil_strlen( + prefix) + 7))); + sprintf(xmlnsprefix, "xmlns:%s", prefix); + } + else + { + xmlnsprefix = axutil_strdup(env, "xmlns"); + } + + status = xmlTextWriterWriteAttribute(writer_impl->xml_writer, + BAD_CAST xmlnsprefix, + BAD_CAST namespace_uri); + AXIS2_FREE(env->allocator, xmlnsprefix); + xmlnsprefix = NULL; + + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_ATTRIBUTE_WITH_NAMESPACE_PREFIX, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + AXIS2_FREE(env->allocator, xmlnsprefix); + xmlnsprefix = NULL; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_default_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * namespace_uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + axis2_char_t *xmlns = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE) + xmlns = AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * (strlen("xmlns") + 1)); + sprintf(xmlns, "xmlns"); + status = xmlTextWriterWriteAttribute(writer_impl->xml_writer, + (const xmlChar *) xmlns, + BAD_CAST namespace_uri); + + if(xmlns) + { + AXIS2_FREE(env->allocator, xmlns); + xmlns = NULL; + } + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_DEFAULT_NAMESPACE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_comment( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * value) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterWriteComment(writer_impl->xml_writer, BAD_CAST value); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_COMMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_processing_instruction( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * target) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, target, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterStartPI(writer_impl->xml_writer, BAD_CAST target); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_PROCESSING_INSTRUCTION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_processing_instruction_data( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * target, + axis2_char_t * data) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, target, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterWritePI(writer_impl->xml_writer, + BAD_CAST target, BAD_CAST data); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_PROCESSING_INSTRUCTION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_cdata( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * data) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterWriteCDATA(writer_impl->xml_writer, BAD_CAST data); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_CDATA, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_dtd( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * dtd) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dtd, AXIS2_FAILURE); + + status = xmlTextWriterStartDTD(writer_impl->xml_writer, + BAD_CAST dtd, NULL, NULL); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_DTD, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_entity_ref( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * name) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, name, AXIS2_FAILURE); + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *wrapper_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + wrapper_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterStartDocument(wrapper_impl->xml_writer, NULL, NULL, NULL); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_DOCUMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_document_with_version( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * version) +{ + axis2_libxml2_writer_wrapper_impl_t *wrapper_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, version, AXIS2_FAILURE); + + wrapper_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterStartDocument(wrapper_impl->xml_writer, version, NULL, NULL); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_DOCUMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_start_document_with_version_encoding( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * encoding, + axis2_char_t * version) +{ + axis2_libxml2_writer_wrapper_impl_t *wrapper_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + wrapper_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterStartDocument(wrapper_impl->xml_writer, version, encoding, NULL); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_DOCUMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_characters( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + status = xmlTextWriterWriteString(writer_impl->xml_writer, BAD_CAST text); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_START_DOCUMENT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_char_t *AXIS2_CALL +axis2_libxml2_writer_wrapper_get_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_PARAM_CHECK(env->error, uri, NULL); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + if(!uri || axutil_strcmp(uri, "") == 0) + { + return NULL; + } + return axis2_libxml2_writer_wrapper_find_prefix(writer, env, uri); +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_set_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * prefix, + axis2_char_t * uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + + axis2_bool_t is_declared = AXIS2_FALSE; + axis2_char_t key[1024]; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + if(axutil_strcmp(uri, "") == 0) + { + return AXIS2_FAILURE; + } + + create_key_from_uri_prefix(env, uri, prefix, key); + + is_declared = axis2_libxml2_writer_wrapper_is_namespace_declared(writer, env, key); + if(!is_declared) + { + return axis2_libxml2_writer_wrapper_push(writer, env, uri, prefix); + } + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_set_default_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri) +{ + axis2_bool_t is_declared = AXIS2_FALSE; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE); + if(axutil_strcmp(uri, "") == 0) + { + return AXIS2_FAILURE; + } + is_declared = axis2_libxml2_writer_wrapper_is_namespace_declared(writer, env, uri); + if(!is_declared) + { + return axis2_libxml2_writer_wrapper_push(writer, env, uri, NULL); + } + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_encoded( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text, + int in_attr) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + return AXIS2_FAILURE; +} + +void *AXIS2_CALL +axis2_libxml2_writer_wrapper_get_xml( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + writer_impl = AXIS2_INTF_TO_IMPL(writer); + if(writer_impl->writer_type == AXIS2_XML_PARSER_TYPE_BUFFER) + { + int output_bytes = 0; + output_bytes = xmlTextWriterFlush(writer_impl->xml_writer); + return writer_impl->buffer->content; + } + else if(writer_impl->writer_type == AXIS2_XML_PARSER_TYPE_DOC) + { + return (void *)writer_impl->doc; + } + else if(writer_impl->writer_type == AXIS2_XML_PARSER_TYPE_FILE) + { + return NULL; + } + + return NULL; +} + +unsigned int AXIS2_CALL +axis2_libxml2_writer_wrapper_get_xml_size( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + if(writer_impl->writer_type == AXIS2_XML_PARSER_TYPE_BUFFER) + { + return writer_impl->buffer->use; + } + else + { + return 0; + } +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_flush( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + writer_impl = AXIS2_INTF_TO_IMPL(writer); + if(writer_impl->xml_writer) + { + int ret = 0; + ret = xmlTextWriterFlush(writer_impl->xml_writer); + if(ret > -1) + return AXIS2_SUCCESS; + } + + return AXIS2_FAILURE; +} + +int AXIS2_CALL +axis2_libxml2_writer_wrapper_get_type( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + return writer_impl->writer_type; +} + +static axis2_status_t +axis2_libxml2_writer_wrapper_push( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + const axis2_char_t * uri, + const axis2_char_t * prefix) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + axutil_array_list_t *current_list = NULL; + axis2_char_t key[1024]; + const axis2_char_t *temp_prefix = NULL; + writer_impl = AXIS2_INTF_TO_IMPL(writer); + if(!prefix || axutil_strcmp(prefix, "") == 0) + { + temp_prefix = "default"; + } + else + { + temp_prefix = prefix; + } + + if(writer_impl->stack) + { + current_list = (axutil_array_list_t *)axutil_stack_get(writer_impl->stack, env); + + if(current_list) + { + uri_prefix_element_t *ele = NULL; + create_key_from_uri_prefix(env, uri, prefix, key); + + ele = uri_prefix_element_create(env, uri, temp_prefix, prefix, key); + if(ele) + { + axutil_array_list_add(current_list, env, ele); + axutil_hash_set(writer_impl->uri_prefix_map, ele->key, AXIS2_HASH_KEY_STRING, + ele->prefix); + } + } + } + return AXIS2_SUCCESS; +} + +static axis2_bool_t +axis2_libxml2_writer_wrapper_is_namespace_declared( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * key) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FALSE); + writer_impl = AXIS2_INTF_TO_IMPL(writer); + if(writer_impl->uri_prefix_map && NULL != key) + { + void *ret = NULL; + ret = axutil_hash_get(writer_impl->uri_prefix_map, key, AXIS2_HASH_KEY_STRING); + if(ret) + { + return AXIS2_TRUE; + } + } + return AXIS2_FALSE; +} + +static void +uri_prefix_element_free( + uri_prefix_element_t * up_element, + const axutil_env_t * env) +{ + if(up_element) + { + if(up_element->uri) + { + AXIS2_FREE(env->allocator, up_element->uri); + up_element->uri = NULL; + } + if(up_element->prefix) + { + AXIS2_FREE(env->allocator, up_element->prefix); + up_element->prefix = NULL; + } + if(up_element->key) + { + AXIS2_FREE(env->allocator, up_element->key); + up_element->key = NULL; + } + if(up_element->real_prefix) + { + AXIS2_FREE(env->allocator, up_element->real_prefix); + up_element->real_prefix = NULL; + } + AXIS2_FREE(env->allocator, up_element); + up_element = NULL; + } + return; +} + +static uri_prefix_element_t * +uri_prefix_element_create( + const axutil_env_t * env, + const axis2_char_t * uri, + const axis2_char_t * prefix, + const axis2_char_t * real_prefix, + const axis2_char_t * key) +{ + uri_prefix_element_t *up_element = NULL; + up_element = (uri_prefix_element_t *)AXIS2_MALLOC(env->allocator, sizeof(uri_prefix_element_t)); + + if(!uri) + { + return NULL; + } + + if(!up_element) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create URI prefix element %s", + uri); + return NULL; + } + up_element->key = NULL; + up_element->prefix = NULL; + up_element->uri = NULL; + up_element->real_prefix = NULL; + + up_element->uri = axutil_strdup(env, uri); + if(!up_element->uri) + { + uri_prefix_element_free(up_element, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + up_element->prefix = axutil_strdup(env, prefix); + if(prefix && !up_element->prefix) + { + uri_prefix_element_free(up_element, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + up_element->key = axutil_strdup(env, key); + if(key && !up_element->key) + { + uri_prefix_element_free(up_element, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + up_element->real_prefix = axutil_strdup(env, real_prefix); + + return up_element; +} + +static void +create_key_from_uri_prefix( + const axutil_env_t * env, + const axis2_char_t * uri, + const axis2_char_t * prefix, + axis2_char_t * array) +{ + if(!prefix) + { + prefix = ""; + } + sprintf(array, "%s%s%s", uri, "|", prefix); +} + +static axis2_char_t * +axis2_libxml2_writer_wrapper_find_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int size = 0; + int i = 0; + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + + if(!writer_impl->stack) + { + return NULL; + } + size = axutil_stack_size(writer_impl->stack, env); + if(size <= 0) + { + return NULL; + } + + for(i = size - 1; i < 0; i--) + { + axutil_array_list_t *context = NULL; + void *value = NULL; + value = axutil_stack_get_at(writer_impl->stack, env, i); + if(value) + { + uri_prefix_element_t *up_ele = NULL; + context = (axutil_array_list_t *)value; + up_ele = axis2_libxml2_writer_wrapper_find_prefix_in_context(context, env, uri); + if(up_ele) + { + return up_ele->real_prefix; + } + } + } + return NULL; +} + +static uri_prefix_element_t * +axis2_libxml2_writer_wrapper_find_prefix_in_context( + axutil_array_list_t * context, + const axutil_env_t * env, + axis2_char_t * uri) +{ + int size = 0; + int i = 0; + if(!context) + { + return NULL; + } + size = axutil_array_list_size(context, env); + for(i = 0; i < size; i++) + { + uri_prefix_element_t *ele = NULL; + void *value = NULL; + value = axutil_array_list_get(context, env, i); + if(value) + { + ele = (uri_prefix_element_t *)value; + if(ele->uri && axutil_strcmp(uri, ele->uri)) + { + return ele; + } + } + } + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_libxml2_writer_wrapper_write_raw( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * content) +{ + axis2_libxml2_writer_wrapper_impl_t *writer_impl = NULL; + int status = 0; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content, AXIS2_FAILURE); + + writer_impl = AXIS2_INTF_TO_IMPL(writer); + status = xmlTextWriterWriteRaw(writer_impl->xml_writer, BAD_CAST content); + if(status < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_DATA_SOURCE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} |