axiom/src/parser/libxml2/libxml2_writer_wrapper.c

/*
 * 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);
        return NULL;
    }
    writer_impl->xml_writer = xmlNewTextWriterFilename(filename, compression);

    if (!(writer_impl->xml_writer))
    {
        AXIS2_FREE(env->allocator, writer_impl);
        AXIS2_ERROR_SET(env->error,
            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);
        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);
        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);
            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_ERROR_SET(env->error, 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_ERROR_SET(env->error, 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);
        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);
        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_ERROR_SET(env->error, 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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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_ERROR_SET(env->error, AXIS2_ERROR_WRITING_EMPTY_ELEMENT, AXIS2_FAILURE);
        return AXIS2_FAILURE;
    }
    status =  xmlTextWriterEndElement(writer_impl->xml_writer);
    if (status < 0)
    {
        AXIS2_ERROR_SET(env->error, 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_ERROR_SET(env->error,
            AXIS2_ERROR_WRITING_EMPTY_ELEMENT_WITH_NAMESPACE, AXIS2_FAILURE);
        return AXIS2_FAILURE;
    }
    status =  xmlTextWriterEndElement(writer_impl->xml_writer);
    if (status < 0)
    {
        AXIS2_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            AXIS2_ERROR_WRITING_START_ELEMENT_WITH_NAMESPACE_PREFIX, AXIS2_FAILURE);
        return AXIS2_FAILURE;
    }
    status =  xmlTextWriterEndElement(writer_impl->xml_writer);
    if (status < 0)
    {
        AXIS2_ERROR_SET(env->error,
            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_ERROR_SET(env->error, 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_ERROR_SET(env->error, 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_ERROR_SET(env->error, 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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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_ERROR_SET(env->error, 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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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_ERROR_SET(env->error, 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_ERROR_SET(env->error, 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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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 *version,
    axis2_char_t *encoding)
{
    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_ERROR_SET(env->error,
            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_ERROR_SET(env->error,
            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);
        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_ERROR_SET(env->error,
            AXIS2_ERROR_WRITING_DATA_SOURCE, AXIS2_FAILURE);
        return AXIS2_FAILURE;
    }
    return AXIS2_SUCCESS;
}