From 0425aadc78680e53000fd0108b540d6eca048516 Mon Sep 17 00:00:00 2001 From: gmcdonald Date: Sat, 13 Feb 2010 01:32:03 +0000 Subject: Moving axis svn, part of TLP move INFRA-2441 git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68 --- axiom/src/parser/guththila/Makefile.am | 13 + .../guththila/guththila_xml_reader_wrapper.c | 613 ++++++++++++++++ .../guththila/guththila_xml_writer_wrapper.c | 787 +++++++++++++++++++++ 3 files changed, 1413 insertions(+) create mode 100644 axiom/src/parser/guththila/Makefile.am create mode 100644 axiom/src/parser/guththila/guththila_xml_reader_wrapper.c create mode 100644 axiom/src/parser/guththila/guththila_xml_writer_wrapper.c (limited to 'axiom/src/parser/guththila') diff --git a/axiom/src/parser/guththila/Makefile.am b/axiom/src/parser/guththila/Makefile.am new file mode 100644 index 0000000..0cc6be5 --- /dev/null +++ b/axiom/src/parser/guththila/Makefile.am @@ -0,0 +1,13 @@ +lib_LTLIBRARIES = libaxis2_parser.la + +libaxis2_parser_la_LIBADD = ../../../../guththila/src/libguththila.la \ + ../../../../util/src/libaxutil.la + +libaxis2_parser_la_SOURCES = ../xml_reader.c ../xml_writer.c guththila_xml_writer_wrapper.c \ + guththila_xml_reader_wrapper.c + +libaxis2_parser_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I ../../../../util/include \ + -I ../../../../guththila/include diff --git a/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c b/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c new file mode 100644 index 0000000..086ed12 --- /dev/null +++ b/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c @@ -0,0 +1,613 @@ +/* + * 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 +#include +#include +#include + +/**************** function prototypes ******************************************/ + +int AXIS2_CALL guththila_xml_reader_wrapper_next( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +void AXIS2_CALL guththila_xml_reader_wrapper_free( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +int AXIS2_CALL guththila_xml_reader_wrapper_get_attribute_count( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_name_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_prefix_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_value_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_namespace_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_value( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +int AXIS2_CALL guththila_xml_reader_wrapper_get_namespace_count( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_uri_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_prefix_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_prefix( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_name( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_pi_target( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_pi_data( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_dtd( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +void AXIS2_CALL guththila_xml_reader_wrapper_xml_free( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + void *data); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_char_set_encoding( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_namespace_uri( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_uri_by_prefix( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + axis2_char_t * prefix); + +void *AXIS2_CALL +guththila_xml_reader_wrapper_get_context( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_current_buffer( + axiom_xml_reader_t * parser, + const axutil_env_t * env); + +/*********** guththila_xml_reader_wrapper_impl_t wrapper struct *******************/ + +typedef struct guththila_xml_reader_wrapper_impl +{ + axiom_xml_reader_t parser; + guththila_t *guththila_parser; + guththila_reader_t *reader; + int event_map[10]; + void *context; + +} guththila_xml_reader_wrapper_impl_t; + +/********************************* Macro ***************************************/ + +#define AXIS2_INTF_TO_IMPL(p) ((guththila_xml_reader_wrapper_impl_t*)p) + +#define AXIS2_IMPL_TO_INTF(p) &(p->parser) + +/**********End macros -- event_map initializing function *********************/ + +static axis2_status_t +guththila_xml_reader_wrapper_init_map( + guththila_xml_reader_wrapper_impl_t * parser) +{ + if(parser) + { + parser->event_map[GUTHTHILA_START_DOCUMENT] = AXIOM_XML_READER_START_DOCUMENT; + parser->event_map[GUTHTHILA_START_ELEMENT] = AXIOM_XML_READER_START_ELEMENT; + parser->event_map[GUTHTHILA_END_ELEMENT] = AXIOM_XML_READER_END_ELEMENT; + parser->event_map[GUTHTHILA_SPACE] = AXIOM_XML_READER_SPACE; + parser->event_map[GUTHTHILA_EMPTY_ELEMENT] = AXIOM_XML_READER_EMPTY_ELEMENT; + parser->event_map[GUTHTHILA_CHARACTER] = AXIOM_XML_READER_CHARACTER; + parser->event_map[GUTHTHILA_ENTITY_REFERANCE] = AXIOM_XML_READER_ENTITY_REFERENCE; + parser->event_map[GUTHTHILA_COMMENT] = AXIOM_XML_READER_COMMENT; + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +static const axiom_xml_reader_ops_t axiom_xml_reader_ops_var = { guththila_xml_reader_wrapper_next, + guththila_xml_reader_wrapper_free, guththila_xml_reader_wrapper_get_attribute_count, + guththila_xml_reader_wrapper_get_attribute_name_by_number, + guththila_xml_reader_wrapper_get_attribute_prefix_by_number, + guththila_xml_reader_wrapper_get_attribute_value_by_number, + guththila_xml_reader_wrapper_get_attribute_namespace_by_number, + guththila_xml_reader_wrapper_get_value, guththila_xml_reader_wrapper_get_namespace_count, + guththila_xml_reader_wrapper_get_namespace_uri_by_number, + guththila_xml_reader_wrapper_get_namespace_prefix_by_number, + guththila_xml_reader_wrapper_get_prefix, guththila_xml_reader_wrapper_get_name, + guththila_xml_reader_wrapper_get_pi_target, guththila_xml_reader_wrapper_get_pi_data, + guththila_xml_reader_wrapper_get_dtd, guththila_xml_reader_wrapper_xml_free, + guththila_xml_reader_wrapper_get_char_set_encoding, + guththila_xml_reader_wrapper_get_namespace_uri, + guththila_xml_reader_wrapper_get_namespace_uri_by_prefix, + guththila_xml_reader_wrapper_get_context, + guththila_xml_reader_wrapper_get_current_buffer}; + +/********************************************************************************/ + +AXIS2_EXTERN axiom_xml_reader_t *AXIS2_CALL +axiom_xml_reader_create_for_file( + const axutil_env_t * env, + char *filename, + const axis2_char_t * encoding) +{ + guththila_xml_reader_wrapper_impl_t *guththila_impl = NULL; + guththila_t *guththila = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + guththila_impl = AXIS2_MALLOC(env->allocator, sizeof(guththila_xml_reader_wrapper_impl_t)); + + if(!guththila_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila_impl->reader = guththila_reader_create_for_file(filename, env); + + if(!(guththila_impl->reader)) + { + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila = (guththila_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_t)); + guththila_init(guththila, guththila_impl->reader, env); + if(!guththila) + { + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila_impl->guththila_parser = guththila; + guththila_impl->context = NULL; + guththila_impl->parser.ops = NULL; + /* guththila_impl->parser.ops = + (axiom_xml_reader_ops_t *) AXIS2_MALLOC(env->allocator, + sizeof(axiom_xml_reader_ops_t)); + if (!(guththila_impl->parser.ops)) + { + guththila_free(guththila, env); + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + */ + guththila_xml_reader_wrapper_init_map(guththila_impl); + + /************** ops *****/ + guththila_impl->parser.ops = &axiom_xml_reader_ops_var; + return &(guththila_impl->parser); +} + +/****** pull parser for io create function ***************************/ + +axiom_xml_reader_t *AXIS2_CALL +axiom_xml_reader_create_for_io( + const axutil_env_t * env, + AXIS2_READ_INPUT_CALLBACK read_input_callback, + AXIS2_CLOSE_INPUT_CALLBACK close_input_callback, + void *ctx, + const char *encoding) +{ + guththila_xml_reader_wrapper_impl_t *guththila_impl = NULL; + /*axutil_allocator_t *allocator = NULL; */ + guththila_t *guththila = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + guththila_impl = AXIS2_MALLOC(env->allocator, sizeof(guththila_xml_reader_wrapper_impl_t)); + + if(!guththila_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + /*allocator = axutil_allocator_init(NULL); */ + + /*-------difference of two create function is here--------*/ + guththila_impl->reader = guththila_reader_create_for_io(read_input_callback, ctx, env); + + if(!(guththila_impl->reader)) + { + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila = (guththila_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_t)); + guththila_init(guththila, guththila_impl->reader, env); + if(!guththila) + { + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila_impl->guththila_parser = guththila; + guththila_impl->context = ctx; + guththila_impl->parser.ops = NULL; + /* guththila_impl->parser.ops = (axiom_xml_reader_ops_t *) + AXIS2_MALLOC(env->allocator, sizeof(axiom_xml_reader_ops_t)); + if (!(guththila_impl->parser.ops)) + { + guththila_free(guththila, env); + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + }*/ + + guththila_xml_reader_wrapper_init_map(guththila_impl); + + /************** ops *****/ + guththila_impl->parser.ops = &axiom_xml_reader_ops_var; + return &(guththila_impl->parser); +} + +/* ####################################################################### */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_xml_reader_init() +{ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axiom_xml_reader_cleanup() +{ + return AXIS2_SUCCESS; +} + +/* ######################################################################## */ + +AXIS2_EXTERN axiom_xml_reader_t *AXIS2_CALL +axiom_xml_reader_create_for_memory( + const axutil_env_t * env, + void *buffer, + int size, + const char *encoding, + int type) +{ + guththila_xml_reader_wrapper_impl_t *guththila_impl = NULL; + /*axutil_allocator_t *allocator = NULL; */ + guththila_t *guththila = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + guththila_impl = AXIS2_MALLOC(env->allocator, sizeof(guththila_xml_reader_wrapper_impl_t)); + + if(!guththila_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + /*allocator = axutil_allocator_init(NULL); */ + + /*-------difference of two create function is here--------*/ + guththila_impl->reader = guththila_reader_create_for_memory(buffer, size, env); + + if(!(guththila_impl->reader)) + { + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila = (guththila_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_t)); + guththila_init(guththila, guththila_impl->reader, env); + if(!guththila) + { + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + guththila_impl->guththila_parser = guththila; + guththila_impl->context = NULL; + guththila_impl->parser.ops = NULL; + /* guththila_impl->parser.ops = (axiom_xml_reader_ops_t *) + AXIS2_MALLOC(env->allocator, sizeof(axiom_xml_reader_ops_t)); + if (!(guththila_impl->parser.ops)) + { + guththila_free(guththila, env); + AXIS2_FREE(env->allocator, guththila_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + */ + guththila_xml_reader_wrapper_init_map(guththila_impl); + + /************** ops *****/ + guththila_impl->parser.ops = &axiom_xml_reader_ops_var; + return &(guththila_impl->parser); +} + +int AXIS2_CALL +guththila_xml_reader_wrapper_next( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + int i = -1; + AXIS2_ENV_CHECK(env, -1); + i = guththila_next(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env); + return i == -1 ? -1 : AXIS2_INTF_TO_IMPL(parser)->event_map[i]; +} + +void AXIS2_CALL +guththila_xml_reader_wrapper_free( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + guththila_xml_reader_wrapper_impl_t *parser_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + parser_impl = AXIS2_INTF_TO_IMPL(parser); + if(parser_impl->reader) + { + guththila_reader_free(parser_impl->reader, env); + } + + if(parser_impl->guththila_parser) + { + guththila_un_init(parser_impl->guththila_parser, env); + } + + AXIS2_FREE(env->allocator, parser_impl); +} + +int AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_count( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + return guththila_get_attribute_count(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_name_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_attribute_name_by_number(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, i, + env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_prefix_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_attribute_prefix_by_number(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, + i, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_value_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_attribute_value_by_number(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, + i, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_attribute_namespace_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_attribute_namespace_by_number( + AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, i, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_value( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_value(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env); +} + +int AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_count( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + return guththila_get_namespace_count(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_uri_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_namespace_uri_by_number(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, i, + env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_prefix_by_number( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + int i) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_namespace_prefix_by_number(AXIS2_INTF_TO_IMPL(parser)-> guththila_parser, + i, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_prefix( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_prefix(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_name( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, NULL); + return guththila_get_name(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_pi_target( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + /* guththila_does not support pi's yet */ + return NULL; +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_pi_data( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + /* guththila_dose not support yet */ + return NULL; +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_dtd( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + printf("not implemented in guththila"); + return NULL; +} + +void AXIS2_CALL +guththila_xml_reader_wrapper_xml_free( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + void *data) +{ + if(data) + AXIS2_FREE(env->allocator, data); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_char_set_encoding( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + return guththila_get_encoding(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env); +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_uri( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + + return (axis2_char_t *)NULL; +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_namespace_uri_by_prefix( + axiom_xml_reader_t * parser, + const axutil_env_t * env, + axis2_char_t * prefix) +{ + return (axis2_char_t *)NULL; +} + +void *AXIS2_CALL +guththila_xml_reader_wrapper_get_context( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + guththila_xml_reader_wrapper_impl_t* parser_impl = NULL; + parser_impl = AXIS2_INTF_TO_IMPL(parser); + return parser_impl->context; +} + +axis2_char_t *AXIS2_CALL +guththila_xml_reader_wrapper_get_current_buffer( + axiom_xml_reader_t * parser, + const axutil_env_t * env) +{ + return guththila_get_current_buffer(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env); +} + diff --git a/axiom/src/parser/guththila/guththila_xml_writer_wrapper.c b/axiom/src/parser/guththila/guththila_xml_writer_wrapper.c new file mode 100644 index 0000000..31b4040 --- /dev/null +++ b/axiom/src/parser/guththila/guththila_xml_writer_wrapper.c @@ -0,0 +1,787 @@ +/* + * 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 +#include +#include +#include +#include + +/************************ function prototypes ************************************/ +void AXIS2_CALL guththila_xml_writer_wrapper_free( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_end_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +guththila_xml_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 +guththila_xml_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 +guththila_xml_writer_wrapper_write_empty_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname); + +axis2_status_t AXIS2_CALL +guththila_xml_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 +guththila_xml_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 +guththila_xml_writer_wrapper_write_end_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_end_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +guththila_xml_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 +guththila_xml_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 +guththila_xml_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 +guththila_xml_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 +guththila_xml_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 +guththila_xml_writer_wrapper_write_comment( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * value); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_processing_instruction( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * target); + +axis2_status_t AXIS2_CALL +guththila_xml_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 +guththila_xml_writer_wrapper_write_cdata( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * data); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_dtd( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * dtd); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_entity_ref( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * name); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_start_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +guththila_xml_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 +guththila_xml_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 +guththila_xml_writer_wrapper_write_characters( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text); + +axis2_char_t *AXIS2_CALL guththila_xml_writer_wrapper_get_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri); + +axis2_status_t AXIS2_CALL +guththila_xml_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 +guththila_xml_writer_wrapper_set_default_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_encoded( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text, + int in_attr); + +void *AXIS2_CALL guththila_xml_writer_wrapper_get_xml( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +unsigned int AXIS2_CALL guththila_xml_writer_wrapper_get_xml_size( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +int AXIS2_CALL guththila_xml_writer_wrapper_get_type( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_raw( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * content); + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_flush( + axiom_xml_writer_t * writer, + const axutil_env_t * env); + +/***************************** end function pointers *****************************/ + +typedef struct guththila_xml_writer_wrapper_impl +{ + axiom_xml_writer_t writer; + guththila_xml_writer_t *wr; +} guththila_xml_writer_wrapper_impl_t; + +static const axiom_xml_writer_ops_t axiom_xml_writer_ops_var = { guththila_xml_writer_wrapper_free, + guththila_xml_writer_wrapper_write_start_element, + guththila_xml_writer_wrapper_end_start_element, + guththila_xml_writer_wrapper_write_start_element_with_namespace, + guththila_xml_writer_wrapper_write_start_element_with_namespace_prefix, + guththila_xml_writer_wrapper_write_empty_element, + guththila_xml_writer_wrapper_write_empty_element_with_namespace, + guththila_xml_writer_wrapper_write_empty_element_with_namespace_prefix, + guththila_xml_writer_wrapper_write_end_element, + guththila_xml_writer_wrapper_write_end_document, guththila_xml_writer_wrapper_write_attribute, + guththila_xml_writer_wrapper_write_attribute_with_namespace, + guththila_xml_writer_wrapper_write_attribute_with_namespace_prefix, + guththila_xml_writer_wrapper_write_namespace, + guththila_xml_writer_wrapper_write_default_namespace, + guththila_xml_writer_wrapper_write_comment, + guththila_xml_writer_wrapper_write_processing_instruction, + guththila_xml_writer_wrapper_write_processing_instruction_data, + guththila_xml_writer_wrapper_write_cdata, guththila_xml_writer_wrapper_write_dtd, + guththila_xml_writer_wrapper_write_entity_ref, + guththila_xml_writer_wrapper_write_start_document, + guththila_xml_writer_wrapper_write_start_document_with_version, + guththila_xml_writer_wrapper_write_start_document_with_version_encoding, + guththila_xml_writer_wrapper_write_characters, guththila_xml_writer_wrapper_get_prefix, + guththila_xml_writer_wrapper_set_prefix, guththila_xml_writer_wrapper_set_default_prefix, + guththila_xml_writer_wrapper_write_encoded, guththila_xml_writer_wrapper_get_xml, + guththila_xml_writer_wrapper_get_xml_size, guththila_xml_writer_wrapper_get_type, + guththila_xml_writer_wrapper_write_raw, guththila_xml_writer_wrapper_flush }; + +/****************************** Macros *******************************************/ + +#define AXIS2_INTF_TO_IMPL(p) ((guththila_xml_writer_wrapper_impl_t*)p) + +/******************************* End macro ***************************************/ + +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) +{ + guththila_xml_writer_wrapper_impl_t *writer_impl; + + AXIS2_ENV_CHECK(env, NULL); + + writer_impl = (guththila_xml_writer_wrapper_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_wrapper_impl_t)); + 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) +{ + guththila_xml_writer_wrapper_impl_t *writer_impl = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + writer_impl = (guththila_xml_writer_wrapper_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_wrapper_impl_t)); + + if(!writer_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + /* creating guththila parser */ + /* guththila xml stream writer for memory */ + + writer_impl->wr = guththila_create_xml_stream_writer_for_memory(env); + + if(!(writer_impl->wr)) + { + AXIS2_FREE(env->allocator, writer_impl->wr); + AXIS2_FREE(env->allocator, writer_impl); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + writer_impl->writer.ops = NULL; + /* ops */ + writer_impl->writer.ops = &axiom_xml_writer_ops_var; + return &(writer_impl->writer); + +} + +void AXIS2_CALL +guththila_xml_writer_wrapper_free( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + if(AXIS2_INTF_TO_IMPL(writer)->wr) + { + guththila_xml_writer_free(AXIS2_INTF_TO_IMPL(writer)->wr, env); + } + + if(writer) + { + AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(writer)); + } + +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_start_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname) +{ + int status = AXIS2_SUCCESS; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + guththila_write_start_element(AXIS2_INTF_TO_IMPL(writer)->wr, localname, env); + return status; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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) +{ + int status = AXIS2_SUCCESS; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + guththila_write_start_element_with_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, namespace_uri, + localname, env); + return status; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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_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); + guththila_write_start_element_with_prefix_and_namespace(AXIS2_INTF_TO_IMPL + (writer)->wr, prefix, namespace_uri, localname, env); + return AXIS2_SUCCESS; + +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_empty_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + guththila_write_empty_element(AXIS2_INTF_TO_IMPL(writer)->wr, localname, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + guththila_write_empty_element_with_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, namespace_uri, + localname, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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_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); + + guththila_write_empty_element_with_prefix_and_namespace(AXIS2_INTF_TO_IMPL + (writer)->wr, prefix, namespace_uri, localname, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_end_element( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + guththila_write_end_element(AXIS2_INTF_TO_IMPL(writer)->wr, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_end_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + guththila_write_end_document(AXIS2_INTF_TO_IMPL(writer)->wr, env); + return AXIS2_SUCCESS; + +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_attribute( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * localname, + axis2_char_t * value) +{ + if(!value) + value = ""; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + guththila_write_attribute(AXIS2_INTF_TO_IMPL(writer)->wr, localname, value, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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) +{ + if(!value) + value = ""; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + + guththila_write_attribute_with_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, namespace_uri, + localname, value, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + guththila_write_attribute_with_prefix_and_namespace(AXIS2_INTF_TO_IMPL + (writer)->wr, prefix, namespace_uri, localname, value, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * prefix, + axis2_char_t * namespace_uri) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + /* when default namespace comes is passed, prefix is null */ + if(prefix) + guththila_write_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, prefix, namespace_uri, env); + else + guththila_write_default_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, namespace_uri, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_default_namespace( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * namespace_uri) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, namespace_uri, AXIS2_FAILURE); + guththila_write_default_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, namespace_uri, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_comment( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * value) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + guththila_write_comment(AXIS2_INTF_TO_IMPL(writer)->wr, value, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_processing_instruction( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * target) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, target, AXIS2_FAILURE); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, target, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_cdata( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * data) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_dtd( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * dtd) +{ + /* AXIS2_ENV_CHECK( env, AXIS2_FAILURE); */ + /* AXIS2_PARAM_CHECK(env->error, dtd, AXIS2_FAILURE); */ + /* return guththila_write_dtd( */ + /* (axutil_env_t *)env, */ + /* AXIS2_INTF_TO_IMPL(writer)->parser, */ + /* dtd); */ + return 0; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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 guththila_write_entity_ref( */ + /* (axutil_env_t *)env, */ + /* AXIS2_INTF_TO_IMPL(writer)->parser, */ + /* name); */ + return 0; + +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_start_document( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + guththila_write_start_document(AXIS2_INTF_TO_IMPL(writer)->wr, env, NULL, NULL); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_start_document_with_version( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * version) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, version, AXIS2_FAILURE); + guththila_write_start_document(AXIS2_INTF_TO_IMPL(writer)->wr, env, NULL, version); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, version, AXIS2_FAILURE); + guththila_write_start_document(AXIS2_INTF_TO_IMPL(writer)->wr, env, encoding, version); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_characters( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE); + guththila_write_characters(AXIS2_INTF_TO_IMPL(writer)->wr, text, env); + return AXIS2_SUCCESS; +} + +axis2_char_t *AXIS2_CALL +guththila_xml_writer_wrapper_get_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri) +{ + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, uri, NULL); + return guththila_get_prefix_for_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, uri, env); +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_set_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * prefix, + axis2_char_t * uri) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE); + guththila_write_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, prefix, uri, env); + return AXIS2_SUCCESS; + +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_set_default_prefix( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * uri) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE); + guththila_write_default_namespace(AXIS2_INTF_TO_IMPL(writer)->wr, uri, env); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_encoded( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * text, + int in_attr) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE); + return AXIS2_SUCCESS; +} + +void *AXIS2_CALL +guththila_xml_writer_wrapper_get_xml( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + char *buffer = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + buffer = guththila_get_memory_buffer(AXIS2_INTF_TO_IMPL(writer)->wr, env); + return (void *)buffer; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_write_raw( + axiom_xml_writer_t * writer, + const axutil_env_t * env, + axis2_char_t * content) +{ + if(!content) + { + return AXIS2_FAILURE; + } + else + { + guththila_write_to_buffer(AXIS2_INTF_TO_IMPL(writer)->wr, (char *)content, (int)strlen( + content), env); + return AXIS2_SUCCESS; + } +} + +unsigned int AXIS2_CALL +guththila_xml_writer_wrapper_get_xml_size( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + return guththila_get_memory_buffer_size(AXIS2_INTF_TO_IMPL(writer)->wr, env); +} + +int AXIS2_CALL +guththila_xml_writer_wrapper_get_type( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + return 0; +} + +axis2_status_t AXIS2_CALL +guththila_xml_writer_wrapper_flush( + axiom_xml_writer_t * writer, + const axutil_env_t * env) +{ + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +guththila_xml_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; +} -- cgit v1.1-32-gdbae