You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2005/10/18 05:59:57 UTC
svn commit: r326023 - in /webservices/axis2/trunk/c/modules/xml:
guththila/src/ om/src/
Author: samisa
Date: Mon Oct 17 20:59:42 2005
New Revision: 326023
URL: http://svn.apache.org/viewcvs?rev=326023&view=rev
Log:
Added changes related to env related updates
Modified:
webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.c
webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.h
webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_comment.c
webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_document.c
webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_element.c
webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_node.c
webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_text.c
Modified: webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.c?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.c (original)
+++ webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.c Mon Oct 17 20:59:42 2005
@@ -16,9 +16,26 @@
*/
#include "guththila_xml_stream_writer.h"
-
+#include <apr.h>
+#include <apr_pools.h>
+#include <apr_hash.h>
+#include <apr_tables.h>
#include <apr_strings.h>
-
+
+static apr_pool_t *guththila_apr_pool; /* a memory pool to be used for this module */
+
+struct guththila_xml_stream_writer
+{
+ FILE* writer;
+ char* encoding;
+ int prefix_defaulting;
+ apr_array_header_t *element_stack; /*stack of element names (apr array is FILO)*/
+ apr_hash_t* namespace_hash; /*hash map with key:namespace and value:prefix */
+ apr_hash_t* prefix_hash; /*hash map with key:prefix and value:namespace*/
+ int in_start_element;
+ int empty_element;
+};
+
guththila_xml_stream_writer_t* guththila_create_xml_stream_writer(FILE* writer, char* encoding, int prefix_defaulting)
{
apr_status_t status;
Modified: webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.h
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.h?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.h (original)
+++ webservices/axis2/trunk/c/modules/xml/guththila/src/guththila_xml_stream_writer.h Mon Oct 17 20:59:42 2005
@@ -21,33 +21,19 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
-#include <apr.h>
-#include <apr_pools.h>
-#include <apr_hash.h>
-#include <apr_tables.h>
#include "guththila_errno.h"
#define GUTHTHILA_DEFAULT_NS_PREFIX ""
-static apr_pool_t *guththila_apr_pool; /* a memory pool to be used for this module */
-
+
/**
* guththila_xml_stream_writer_t - Stream Writer Structure
*/
+typedef struct guththila_xml_stream_writer guththila_xml_stream_writer_t;
+
-typedef struct
-{
- FILE* writer;
- char* encoding;
- int prefix_defaulting;
- apr_array_header_t *element_stack; /*stack of element names (apr array is FILO)*/
- apr_hash_t* namespace_hash; /*hash map with key:namespace and value:prefix */
- apr_hash_t* prefix_hash; /*hash map with key:prefix and value:namespace*/
- int in_start_element;
- int empty_element;
-} guththila_xml_stream_writer_t;
guththila_xml_stream_writer_t* guththila_create_xml_stream_writer(FILE* writer, char* encoding, int is_prefix_defaulting);
Modified: webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_comment.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_comment.c?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_comment.c (original)
+++ webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_comment.c Mon Oct 17 20:59:42 2005
@@ -18,72 +18,82 @@
#include <string.h>
#include <axis2_errno.h>
-axis2_om_comment_t *axis2_om_comment_create(const char *value,axis2_om_node_t *cnode)
+/**
+ * free a axis2_comment struct
+ * @param comment pointer to the axis2_commnet
+ *
+ */
+axis2_status_t axis2_om_comment_impl_free(axis2_environment_t *environment, axis2_om_comment_t *comment);
+
+axis2_om_comment_t *axis2_om_comment_create(axis2_environment_t *environment, const axis2_char_t *value, axis2_om_node_t **node)
{
- axis2_om_node_t *node = NULL;
+ *node = NULL;
axis2_om_comment_t *comment = NULL;
-
- node = axis2_om_node_create();
+
if (!node)
{
- fprintf(stderr, "%d Error", AXIS2_ERROR_OM_MEMORY_ALLOCATION);
- return NULL;
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return NULL;
}
- comment = (axis2_om_comment_t *) malloc(sizeof(axis2_om_comment_t));
- if (!comment)
+
+ *node = axis2_om_node_create(environment);
+ if (!*node)
{
- free(node);
- fprintf(stderr, "%d Error", AXIS2_ERROR_OM_MEMORY_ALLOCATION);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
return NULL;
}
- comment->value = strdup(value);
- if (!comment->value)
+
+ comment = (axis2_om_comment_t *) axis2_malloc(environment->allocator, sizeof(axis2_om_comment_t));
+ if (!comment)
{
- fprintf(stderr, "%d Error", AXIS2_ERROR_OM_MEMORY_ALLOCATION);
+ axis2_om_node_free(environment, *node);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
}
-
- node->data_element = comment;
- node->element_type =AXIS2_OM_COMMENT;
- cnode = node;
+
+ comment->value = NULL;
+
+ if (value)
+ {
+ comment->value = axis2_strdup(environment->string, value);
+ if (!comment->value)
+ {
+ axis2_om_node_free(environment, *node);
+ axis2_free(environment->allocator, comment);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
+ }
+ }
+
+ (*node)->data_element = comment;
+ (*node)->node_type = AXIS2_OM_COMMENT;
+
+ /* operations */
+ comment->ops = NULL;
+ comment->ops = (axis2_om_comment_ops_t*) axis2_malloc(environment->allocator, sizeof(axis2_om_comment_ops_t));
+ if (!comment->ops)
+ {
+ axis2_om_node_free(environment, *node);
+ axis2_free(environment->allocator, comment);
+ axis2_free(environment->allocator, comment->value);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
+ }
+
+ comment->ops->axis2_om_comment_ops_free = axis2_om_comment_impl_free;
+
return comment;
}
-void axis2_om_comment_free(axis2_om_comment_t * comment)
+axis2_status_t axis2_om_comment_impl_free(axis2_environment_t *environment, axis2_om_comment_t *comment)
{
if (comment)
{
if (comment->value)
{
- free(comment->value);
+ axis2_free(environment->allocator, comment->value);
}
- free(comment);
- }
-}
-
-char *axis2_om_comment_get_value(axis2_om_node_t * comment_node)
-{
- if (!comment_node || comment_node->element_type !=AXIS2_OM_COMMENT)
- {
- return NULL;
- }
- return ((axis2_om_comment_t *) (comment_node->data_element))->value;
-}
-
-void axis2_om_comment_set_value(axis2_om_node_t * comment_node,
- const char *value)
-{
- axis2_om_comment_t *comment = NULL;
-
- if (!comment_node || comment_node->element_type !=AXIS2_OM_COMMENT)
- {
- return;
- }
- comment = ((axis2_om_comment_t *) (comment_node->data_element));
-
- if (comment->value)
- {
- free(comment->value);
+ axis2_free(environment->allocator, comment);
}
- comment->value = strdup(value);
}
Modified: webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_document.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_document.c?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_document.c (original)
+++ webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_document.c Mon Oct 17 20:59:42 2005
@@ -16,153 +16,214 @@
#include <axis2_om_document.h>
-#include <stdlib.h>
-#include <axis2_error.h>
-#include <axis2_defines.h>
#include <axis2_om_stax_builder.h>
-axis2_om_document_t *axis2_om_document_create(axis2_om_node_t * root_ele,axis2_om_stax_builder_t * builder)
+axis2_status_t axis2_om_document_impl_free(axis2_environment_t *environment, axis2_om_document_t * document);
+axis2_status_t axis2_om_document_impl_add_child(axis2_environment_t *environment, axis2_om_document_t *document,
+ axis2_om_node_t *child);
+axis2_status_t axis2_om_document_impl_build_next(axis2_environment_t *environment, axis2_om_document_t *document);
+axis2_om_node_t *axis2_om_document_impl_get_root_element(axis2_environment_t *environment, axis2_om_document_t *document);
+axis2_om_node_t *axis2_om_document_impl_get_next_sibling(axis2_environment_t *environment, axis2_om_document_t *document);
+axis2_om_node_t *axis2_om_document_impl_get_first_child(axis2_environment_t *environment, axis2_om_document_t *document);
+axis2_om_node_t *axis2_om_document_impl_get_next_child(axis2_environment_t *environment, axis2_om_document_t *document);
+
+axis2_om_document_t *axis2_om_document_create(axis2_environment_t *environment, axis2_om_node_t * root, axis2_om_stax_builder_t * builder)
{
- axis2_om_document_t *doc = (axis2_om_document_t *) malloc(sizeof(axis2_om_document_t));
- if (!doc)
+ axis2_om_document_t *document = (axis2_om_document_t *) axis2_malloc(environment->allocator, sizeof(axis2_om_document_t));
+
+ if (!document)
+ {
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
+ }
+ document->builder = builder;
+ document->root_element = root;
+ document->first_child = NULL;
+ document->last_child = NULL;
+
+ document->char_set_encoding = NULL;
+ document->char_set_encoding = (axis2_char_t*) axis2_strdup(environment->string, CHAR_SET_ENCODING);
+
+ if (!document->char_set_encoding)
{
- /*fprintf(stderr,"%d Error",AXIS2_ERROR_NO_MEMORY);*/
+ axis2_free(environment->allocator, document);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
return NULL;
}
- doc->builder = builder;
- doc->root_element = root_ele;
- doc->first_child = NULL;
- doc->last_child = NULL;
- doc->char_set_encoding = CHAR_SET_ENCODING;
- doc->xml_version = XML_VERSION;
- doc->done = AXIS2_FALSE;
+
+ document->xml_version = NULL;
+ document->xml_version = (axis2_char_t*) axis2_strdup(environment->string, XML_VERSION);
+ if (!document->xml_version)
+ {
+ axis2_free(environment->allocator, document);
+ axis2_free(environment->allocator, document->char_set_encoding);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
+ }
+
+ document->done = AXIS2_FALSE;
+
if(builder)
{
- builder->document=doc;
+ builder->document = document;
}
- return doc;
+
+ /* operations */
+ document->ops = NULL;
+ document->ops = (axis2_om_document_ops_t*) axis2_malloc(environment->allocator, sizeof(axis2_om_document_ops_t));
+
+ if (!document->ops)
+ {
+ axis2_free(environment->allocator, document);
+ axis2_free(environment->allocator, document->char_set_encoding);
+ axis2_free(environment->allocator, document->xml_version);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
+ }
+
+ document->ops->axis2_om_document_ops_free = axis2_om_document_impl_free;
+ document->ops->axis2_om_document_ops_add_child = axis2_om_document_impl_add_child;
+ document->ops->axis2_om_document_ops_build_next = axis2_om_document_impl_build_next;
+ document->ops->axis2_om_document_ops_get_root_element = axis2_om_document_impl_get_root_element;
+ document->ops->axis2_om_document_ops_get_next_sibling = axis2_om_document_impl_get_next_sibling;
+ document->ops->axis2_om_document_ops_get_first_child = axis2_om_document_impl_get_first_child;
+ document->ops->axis2_om_document_ops_get_next_child = axis2_om_document_impl_get_next_child;
+ return document;
}
-void axis2_free_om_document(axis2_om_document_t * doc)
+axis2_status_t axis2_om_document_impl_free(axis2_environment_t *environment, axis2_om_document_t * document)
{
- if(doc)
+ if(document)
{
- if(doc->char_set_encoding)
- free(doc->char_set_encoding);
- if(doc->xml_version)
- free(doc->xml_version);
- /* */
-
- free(doc);
+ if(document->char_set_encoding)
+ axis2_free(environment->allocator, document->char_set_encoding);
+ if(document->xml_version)
+ axis2_free(environment->allocator, document->xml_version);
+
+ (document->root_element)->ops->axis2_om_node_ops_free(environment, document->root_element);
+
+ axis2_free(environment->allocator, document);
}
+ return AXIS2_SUCCESS;
}
-void axis2_om_document_set_char_set_encoding(axis2_om_document_t *document,
- const char *char_set_encoding)
+axis2_status_t axis2_om_document_impl_add_child(axis2_environment_t *environment, axis2_om_document_t *document,
+ axis2_om_node_t *child)
{
- if (document)
+ if (!document || ! child)
{
- if (document->char_set_encoding)
- {
- free(document->char_set_encoding);
- }
- document->char_set_encoding = strdup(char_set_encoding);
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return AXIS2_FAILURE;
}
-}
-
-void axis2_om_document_add_child(axis2_om_document_t * document,
- axis2_om_node_t * child)
-{
- if(!(document->root_element) && child)
+
+ if(!(document->root_element) && child)
{
document->root_element = child;
+ return AXIS2_SUCCESS;
}
if(document->root_element && child)
{
- axis2_om_node_add_child(document->root_element,child);
+ return axis2_om_node_add_child(environment, document->root_element,child);
}
+ return AXIS2_FAILURE;
+
}
-
-void axis2_om_document_set_xmlversion(axis2_om_document_t *document,const char *xmlversion)
-{
- if(document)
- {
- if(document->xml_version)
- {
- free(document->xml_version);
- }
- document->xml_version = strdup(xmlversion);
- }
-}
-
-
-void axis2_om_document_build_next(axis2_om_document_t *document)
+axis2_status_t axis2_om_document_impl_build_next(axis2_environment_t *environment, axis2_om_document_t *document)
{
- /* printf("next");*/
- axis2_stax_om_builder_next(document->builder);
+ return axis2_om_stax_builder_next(document->builder);
}
-axis2_om_node_t *axis2_om_document_get_root_element(axis2_om_document_t *document)
+axis2_om_node_t *axis2_om_document_impl_get_root_element(axis2_environment_t *environment, axis2_om_document_t *document)
{
+ axis2_status_t status = AXIS2_SUCCESS;
if(document && document->root_element)
{
return document->root_element;
}
else
{
- while(!document->root_element)
- axis2_om_document_build_next(document);
+ status = (document)->ops->axis2_om_document_ops_build_next(environment, document);
+ if (document->root_element)
+ return document->root_element;
+ else
+ {
+ if (status != AXIS2_SUCCESS)
+ environment->error->errorno = status;
+ return NULL;
+ }
}
-
- return document->root_element;
-
}
-axis2_om_node_t *axis2_om_document_get_next_sibling(axis2_om_document_t *document)
+axis2_om_node_t *axis2_om_document_impl_get_next_sibling(axis2_environment_t *environment, axis2_om_document_t *document)
{
- axis2_om_node_t *lastchild =document->builder->lastnode;
+ axis2_om_node_t *lastchild = NULL;
if(document && document->builder && document->builder->lastnode)
{
-
+ lastchild = document->builder->lastnode;
if(!(lastchild->parent))
{
- /* if parent is null there can't be siblings */
- return NULL;
+ return NULL; /* if parent is null there can't be siblings */
}
while( !(lastchild->next_sibling) && !(lastchild->parent->done))
- axis2_om_document_build_next(document);
+ axis2_om_document_build_next(environment, document);
+ return lastchild->next_sibling;
}
- return lastchild->next_sibling;
+ return NULL;
}
-axis2_om_node_t *axis2_om_document_get_first_child(axis2_om_document_t *document)
+axis2_om_node_t *axis2_om_document_impl_get_first_child(axis2_environment_t *environment, axis2_om_document_t *document)
{
axis2_om_node_t *current_child = NULL;
+ axis2_status_t status = AXIS2_SUCCESS;
current_child = document->builder->lastnode;
if(current_child)
{
while(!(current_child->first_child)&& !(current_child->done))
{
- axis2_om_document_build_next(document);
+ status = axis2_om_document_build_next(environment, document);
}
- if(current_child->first_child)
- return current_child->first_child;
+
+ if(current_child->first_child)
+ return current_child->first_child;
else
+ {
+ if (status != AXIS2_SUCCESS)
+ environment->error->errorno = status;
return NULL;
-
+ }
}
-
+ return NULL;
}
-axis2_om_node_t *axis2_om_document_get_child(axis2_om_document_t *document)
+axis2_om_node_t *axis2_om_document_impl_get_next_child(axis2_environment_t *environment, axis2_om_document_t *document)
{
- return document->builder->lastnode;
+ axis2_om_node_t *current_child = NULL;
+ axis2_status_t status = AXIS2_SUCCESS;
+ current_child = document->builder->lastnode;
+ if(current_child && current_child->parent->first_child)
+ {
+ status = axis2_om_document_build_next(environment, document);
+
+ if(current_child->last_child)
+ return current_child->last_child;
+ else
+ {
+ if (status != AXIS2_SUCCESS)
+ environment->error->errorno = status;
+ return NULL;
+ }
+ }
+ else
+ {
+ environment->error->errorno = AXIS2_ERROR_INVALID_ITERATOR_STATE;
+ return NULL;
+ }
}
Modified: webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_element.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_element.c?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_element.c (original)
+++ webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_element.c Mon Oct 17 20:59:42 2005
@@ -14,54 +14,107 @@
* limitations under the License.
*/
-#include <axis2_errno.h>
#include <axis2_om_element.h>
#include <axis2_om_attribute.h>
#include <axis2_om_namespace.h>
-#include <stdlib.h>
-static apr_pool_t *om_pool;
+
+axis2_om_namespace_t *
+axis2_om_element_impl_find_namespace (axis2_environment_t *environment, axis2_om_node_t
+ *node, const axis2_char_t *uri,
+ const axis2_char_t *prefix);
+axis2_status_t axis2_om_element_impl_declare_namespace(axis2_environment_t *environment, axis2_om_element_t *element, axis2_om_namespace_t *ns);
+axis2_om_namespace_t *
+axis2_om_element_impl_find_namespace_with_qname (axis2_environment_t *environment, axis2_om_node_t * element,
+ axis2_qname_t * qname);
+axis2_status_t axis2_om_element_impl_add_attribute(axis2_environment_t *environment, struct axis2_om_element *element, axis2_om_attribute_t *attribute);
+axis2_om_attribute_t *axis2_om_element_impl_get_attribute(axis2_environment_t *environment, struct axis2_om_element *element, axis2_qname_t *qname);
+axis2_status_t axis2_om_element_impl_free(axis2_environment_t *environment, struct axis2_om_element *element);
+axis2_status_t axis2_om_element_impl_serialize_start_part(axis2_environment_t *environment, axis2_om_element_t *element, axis2_om_output_t* om_output);
+axis2_status_t axis2_om_element_impl_serialize_end_part(axis2_environment_t *environment, axis2_om_element_t *element, axis2_om_output_t* om_output);
+
axis2_om_element_t *
-axis2_om_element_create (axis2_om_node_t * parent,const char *localname,
- axis2_om_namespace_t * ns,axis2_om_node_t **element_node)
+axis2_om_element_create (axis2_environment_t *environment, axis2_om_node_t * parent,const axis2_char_t *localname,
+ axis2_om_namespace_t * ns, axis2_om_node_t **node)
{
- //axis2_om_node_t *node;
axis2_om_element_t *element;
- if (!localname)
+ if (!localname || !node)
{
- fprintf (stderr, "Localname can't be null");
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
return NULL;
}
- (*element_node) = axis2_om_node_create ();
- if (!(*element_node))
+ (*node) = axis2_om_node_create(environment);
+ if (!(*node))
{
- fprintf (stderr, "%d Error", AXIS2_ERROR_OM_MEMORY_ALLOCATION);
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
return NULL;
}
- element = (axis2_om_element_t *) malloc (sizeof (axis2_om_element_t));
+ element = (axis2_om_element_t *) axis2_malloc (environment->allocator, sizeof (axis2_om_element_t));
if (!element)
{
- axis2_om_node_free ((*element_node));
+ axis2_om_node_free (environment, (*node));
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
return NULL;
}
element->ns = NULL;
- element->localname = strdup (localname);
- element->pns_counter = 0;
+ element->localname = NULL;
element->attributes = NULL;
element->namespaces = NULL;
+
+ element->localname = (char*)axis2_strdup (environment->string, localname);
+ if (!element->localname)
+ {
+ axis2_free(environment->allocator, element);
+ axis2_om_node_free (environment, (*node));
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
+ }
+
if (parent)
{
- (*element_node)->parent = parent;
- axis2_om_node_add_child (parent, (*element_node));
+ (*node)->parent = parent;
+ axis2_om_node_add_child (environment, parent, (*node));
+ }
+
+ (*node)->done = AXIS2_FALSE;
+ (*node)->node_type = AXIS2_OM_ELEMENT;
+ (*node)->data_element = element;
+
+ if (ns)
+ {
+ element->ns = axis2_om_element_impl_find_namespace (environment, *node, ns->uri, ns->prefix);
+ if (!(element->ns))
+ {
+ if (axis2_om_element_impl_declare_namespace(environment, element, ns) == AXIS2_SUCCESS)
+ element->ns = ns;
+ }
+ }
+
+ element->ops = NULL;
+ element->ops = (axis2_om_element_ops_t*) axis2_malloc(environment->allocator, sizeof(axis2_om_element_ops_t));
+
+ if (!element->ops)
+ {
+ axis2_free(environment->allocator, element->localname);
+ axis2_free(environment->allocator, element);
+ axis2_om_node_free (environment, (*node));
+ environment->error->errorno = AXIS2_ERROR_NO_MEMORY;
+ return NULL;
}
- (*element_node)->done = TRUE;
- (*element_node)->element_type = AXIS2_OM_ELEMENT;
- (*element_node)->data_element = element;
- axis2_om_element_set_namespace ((*element_node), ns);
+
+ /* operations */
+ element->ops->axis2_om_element_ops_find_namespace = axis2_om_element_impl_find_namespace;
+ element->ops->axis2_om_element_ops_declare_namespace = axis2_om_element_impl_declare_namespace;
+ element->ops->axis2_om_element_ops_find_namespace_with_qname = axis2_om_element_impl_find_namespace_with_qname;
+ element->ops->axis2_om_element_ops_add_attribute = axis2_om_element_impl_add_attribute;
+ element->ops->axis2_om_element_ops_get_attribute = axis2_om_element_impl_get_attribute;
+ element->ops->axis2_om_element_ops_free = axis2_om_element_impl_free;
+ element->ops->axis2_om_element_ops_serialize_start_part = axis2_om_element_impl_serialize_start_part;
+ element->ops->axis2_om_element_ops_serialize_end_part = axis2_om_element_impl_serialize_end_part;
return element;
@@ -70,186 +123,166 @@
/* create an om_element using qname and parent */
axis2_om_element_t *
-axis2_om_element_create_with_qname (axis2_om_node_t * parent,
- axis2_qname_t * qname,axis2_om_node_t **element_node)
+axis2_om_element_create_with_qname (axis2_environment_t *environment, axis2_om_node_t * parent,
+ axis2_qname_t * qname,axis2_om_node_t **node)
{
- axis2_om_element_t *element;
- axis2_om_node_t *node = NULL;;
- if (!qname)
+ axis2_om_element_t *element = NULL;
+
+ if (!qname || !(*node))
{
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
return NULL; /* can't create an element */
}
- element = axis2_om_element_create (parent,qname->localpart, NULL,node);
- if (node)
- {
- ((axis2_om_element_t *) (node->data_element))->ns =
- axis2_om_element_handle_namespace_with_qname (node, qname);
+
+ /* TODO:handle namespace in the following */
+ element = axis2_om_element_create (environment, parent,qname->localpart, NULL,node);
+ if (*node)
+ {
+ if (((axis2_om_element_t *) ((*node)->data_element))->ns)
+ {
+ axis2_om_namespace_t *ns = ((axis2_om_element_t *) ((*node)->data_element))->ns;
+ element->ns = axis2_om_element_impl_find_namespace (environment, *node, ns->uri, ns->prefix);
+ if (!(element->ns))
+ {
+ if (axis2_om_element_impl_declare_namespace(environment, element, ns) == AXIS2_SUCCESS)
+ element->ns = ns;
+ }
+ }
}
- (*element_node) = node;
+
return element;
}
-axis2_om_element_t *
-axis2_om_element_create_with_builder (axis2_om_node_t * parent,
- const char *localname,axis2_om_namespace_t * ns
- ,axis2_om_stax_builder_t * builder,axis2_om_node_t **element_node)
+axis2_om_namespace_t *
+axis2_om_element_impl_find_namespace (axis2_environment_t *environment, axis2_om_node_t
+ *node, const axis2_char_t *uri,
+ const axis2_char_t *prefix)
{
- axis2_om_node_t *node;
- axis2_om_element_t *element;
- if (!localname)
- {
- fprintf (stderr, "Localname can't be null");
- return NULL;
- }
-
- node = axis2_om_node_create ();
+ void *ns = NULL;
+ axis2_hash_index_t *hashindex;
+ axis2_om_element_t *element = NULL;
+
if (!node)
{
- fprintf (stderr, "%d Error", AXIS2_ERROR_OM_MEMORY_ALLOCATION);
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
return NULL;
}
- element = (axis2_om_element_t *) malloc (sizeof (axis2_om_element_t));
-
- if (!element)
+ if (!(node->data_element)
+ || node->node_type != AXIS2_OM_ELEMENT)
{
- axis2_om_node_free (node);
+ /* wrong element type or null node */
+ environment->error->errorno = AXIS2_ERROR_INVALID_NODE_TYPE;
return NULL;
}
- element->localname = strdup (localname);
- element->attributes = NULL;
- element->pns_counter = 0;
- element->namespaces = NULL;
- element->ns = NULL;
-
- node->builder = builder;
- node->data_element = element;
- node->done = FALSE;
- node->element_type = AXIS2_OM_ELEMENT;
- if (parent)
+ element = (axis2_om_element_t *) (node->data_element);
+ if (!prefix || axis2_strcmp (environment->string, prefix, "") == 0)
{
- node->parent = parent;
- axis2_om_node_add_child (parent, node);
- }
- axis2_om_element_set_namespace (node, ns);
- (*element_node) = node;
- return element;
-}
-
-axis2_om_namespace_t *
-axis2_om_element_find_namespace (axis2_om_node_t
- * element_node, const char *uri,
- const char *prefix)
-{
- axis2_om_namespace_t *ns = NULL;
-
- if (!element_node)
- {
- return NULL;
- }
- if (!(element_node->data_element)
- || element_node->element_type != AXIS2_OM_ELEMENT)
- {
- /* wrong element type or null node */
- return NULL;
+ for (hashindex = axis2_hash_first (environment, element->namespaces);
+ hashindex; hashindex = axis2_hash_next (hashindex))
+ {
+ axis2_hash_this (hashindex, NULL, NULL, &ns);
+ if (ns && axis2_strcmp (environment->string, ((axis2_om_namespace_t *) (ns))->uri, uri) == 0)
+ {
+ return (axis2_om_namespace_t*) (ns);
+ }
+ }
}
-
- ns = axis2_om_element_find_declared_namespace (element_node, uri, prefix);
- if (!ns)
+ ns = axis2_hash_get (element->namespaces, prefix, AXIS2_HASH_KEY_STRING);
+
+ if (ns)
{
return ns;
}
- if ((element_node->parent != NULL) &&
- (element_node->parent->element_type == AXIS2_OM_ELEMENT))
+ else if ((node->parent != NULL) &&
+ (node->parent->node_type == AXIS2_OM_ELEMENT))
{
- axis2_om_element_find_namespace (element_node->parent, uri, prefix);
+ return axis2_om_element_impl_find_namespace (environment, node->parent, uri, prefix);
}
+
return NULL;
}
/* declare a namespace for this om element */
-axis2_om_namespace_t *
-axis2_om_element_declare_namespace (axis2_om_node_t *
- element_node, axis2_om_namespace_t * ns)
+axis2_status_t axis2_om_element_impl_declare_namespace(axis2_environment_t *environment, axis2_om_element_t *element, axis2_om_namespace_t *ns)
{
- apr_status_t status;
- axis2_om_element_t *element = NULL;
- if (!element_node || !ns || !element_node->data_element
- || element_node->element_type != AXIS2_OM_ELEMENT)
+
+ if (!element || !ns)
{
- return NULL;
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return AXIS2_FAILURE;
}
- element = (axis2_om_element_t *) (element_node->data_element);
-
if (!element->namespaces)
{
- if (!om_pool)
- {
- status = apr_pool_create (&om_pool, NULL);
- }
-
- element->namespaces = apr_hash_make (om_pool);
+ element->namespaces = axis2_hash_make (environment);
+ if (!(element->namespaces))
+ return AXIS2_FAILURE;
}
- apr_hash_set (element->namespaces, ns->prefix, APR_HASH_KEY_STRING, ns);
+ if (ns->prefix)
+ axis2_hash_set (element->namespaces, ns->prefix, AXIS2_HASH_KEY_STRING, ns);
+ else
+ axis2_hash_set (element->namespaces, "default", AXIS2_HASH_KEY_STRING, ns);
- return ns;
+ return AXIS2_SUCCESS;
}
-axis2_om_namespace_t *
+/*axis2_om_namespace_t *
axis2_om_element_declare_namespace_with_ns_uri_prefix (axis2_om_node_t *
- element_node,
- const char *uri,
- const char *prefix)
+ element,
+ const axis2_char_t *uri,
+ const axis2_char_t *prefix)
{
axis2_om_namespace_t *nsp = NULL;
nsp = axis2_om_namespace_create (uri, prefix);
if (nsp)
{
- return axis2_om_element_declare_namespace (element_node, nsp);
+ return axis2_om_element_declare_namespace (element, nsp);
}
return NULL;
}
+*/
/*
* checks for the namespace in the current om element
* can be used to retrive a prefix of a known namespace uri
*
*/
-axis2_om_namespace_t *
-axis2_om_element_find_declared_namespace (axis2_om_node_t * element_node,
- const char *uri, const char *prefix)
+/*axis2_om_namespace_t *
+axis2_om_element_find_declared_namespace (axis2_om_node_t * element,
+ const axis2_char_t *uri, const axis2_char_t *prefix)
{
void *ns = NULL;
- apr_hash_index_t *hashindex;
+ axis2_hash_index_t *hashindex;
axis2_om_element_t *element = NULL;
- if (!element_node || !ns
- || element_node->element_type != AXIS2_OM_ELEMENT)
+ if (!element || !ns
+ || element->element_type != AXIS2_OM_ELEMENT)
{
return NULL;
}
- element = (axis2_om_element_t *) (element_node->data_element);
+ element = (axis2_om_element_t *) (element->data_element);
if (!prefix || strcmp (prefix, "") == 0)
{
- for (hashindex = apr_hash_first (om_pool, element->namespaces);
- hashindex; hashindex = apr_hash_next (hashindex))
+ for (hashindex = axis2_hash_first (om_pool, element->namespaces);
+ hashindex; hashindex = axis2_hash_next (hashindex))
{
- apr_hash_this (hashindex, NULL, NULL, &ns);
+ axis2_hash_this (hashindex, NULL, NULL, &ns);
if (strcmp (((axis2_om_namespace_t *) (ns))->uri, uri))
{
return (axis2_om_namespace_t *) (ns);
}
}
}
- ns = apr_hash_get (element->namespaces, prefix, APR_HASH_KEY_STRING);
+ ns = axis2_hash_get (element->namespaces, prefix, APR_HASH_KEY_STRING);
return (axis2_om_namespace_t *) ns;
}
+*/
/*
* This will find a namespace with the given uri and prefix, in the scope of the docuemnt.
@@ -259,99 +292,80 @@
-static axis2_om_namespace_t *
-axis2_om_element_handle_namespace_with_qname (axis2_om_node_t * element_node,
+axis2_om_namespace_t *
+axis2_om_element_impl_find_namespace_with_qname (axis2_environment_t *environment, axis2_om_node_t * element,
axis2_qname_t * qname)
{
- axis2_om_namespace_t *pns = NULL;
- char *ns_uri = qname->ns_uri;
- if (ns_uri != NULL)
+ if (!element || !qname)
{
- pns =
- axis2_om_element_find_namespace (element_node, ns_uri,
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return NULL;
+ }
+
+ if (qname->namespace_uri)
+ {
+ return axis2_om_element_impl_find_namespace (environment, element, qname->namespace_uri,
qname->prefix);
- /**
- * What is left now is
- * 1. nsURI = null & parent != null, but ns = null
- * 2. nsURI != null, (parent doesn't have an ns with given URI), but ns = null
- */
- if (pns == NULL)
- {
- if (qname->prefix)
- {
- pns =
- axis2_om_element_declare_namespace_with_ns_uri_prefix
- (element_node, ns_uri, qname->prefix);
- }
- }
}
- return NULL;
+ else
+ {
+ return NULL;
+ }
}
+/*
static axis2_om_namespace_t *
axis2_om_element_handle_namespace (axis2_om_node_t
- * element_node, axis2_om_namespace_t * ns)
+ * element, axis2_om_namespace_t * ns)
{
axis2_om_namespace_t *ns1 = NULL;
- if (!ns || !element_node)
+ if (!ns || !element)
{
return NULL;
}
- ns1 = axis2_om_element_find_namespace (element_node, ns->uri, ns->prefix);
+ ns1 = axis2_om_element_find_namespace (element, ns->uri, ns->prefix);
if (!ns1)
{
- ns1 = axis2_om_element_declare_namespace (element_node, ns);
+ ns1 = axis2_om_element_declare_namespace (element, ns);
}
return ns1;
}
+*/
-
-axis2_om_attribute_t *
-axis2_om_element_add_attribute (axis2_om_node_t * element_node,
- axis2_om_attribute_t * attr)
+axis2_status_t axis2_om_element_impl_add_attribute(axis2_environment_t *environment, struct axis2_om_element *element, axis2_om_attribute_t *attribute)
{
- apr_status_t status;
axis2_qname_t *qname = NULL;
- axis2_om_element_t *element = NULL;
-
- if (!element_node || element_node->element_type != AXIS2_OM_ELEMENT)
+
+ if (!element || !attribute)
{
- return NULL;
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return AXIS2_FAILURE;
}
- element = (axis2_om_element_t *) (element_node->data_element);
-
+
if (!(element->attributes))
{
- if (!om_pool)
- {
- status = apr_pool_create (&om_pool, NULL);
- }
- element->attributes = apr_hash_make (om_pool);
+ element->attributes = axis2_hash_make (environment);
+ if (!(element->attributes))
+ return AXIS2_FAILURE;
}
- qname = axis2_om_attribute_get_qname (attr);
+ qname = axis2_om_attribute_get_qname (environment, attribute);
+ if (qname)
+ axis2_hash_set (element->attributes, qname, sizeof (axis2_qname_t), attribute);
- apr_hash_set (element->attributes, qname, sizeof (axis2_qname_t), attr);
-
- return attr;
+ return ((qname)?AXIS2_SUCCESS:AXIS2_FAILURE);
}
-axis2_om_attribute_t *
-axis2_om_element_get_attribute (axis2_om_node_t * element_node,
- axis2_qname_t * qname)
+axis2_om_attribute_t *axis2_om_element_impl_get_attribute(axis2_environment_t *environment, struct axis2_om_element *element, axis2_qname_t *qname)
{
- char *key = NULL;
- axis2_om_element_t *element = NULL;
- if (!element_node || !qname
- || element_node->element_type != AXIS2_OM_ELEMENT)
+ if (!element || !qname)
{
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
return NULL;
}
- element = (axis2_om_element_t *) (element_node->data_element);
-
- return (axis2_om_attribute_t
- *) (apr_hash_get (element->attributes, qname,
+
+ return (axis2_om_attribute_t*) (axis2_hash_get (element->attributes, qname,
sizeof (axis2_qname_t)));
}
@@ -359,32 +373,33 @@
* The node passed to the method should have the data element as of type OM_ELEMENT
*/
-axis2_om_attribute_t *
-axis2_om_element_add_attribute_with_namespace (axis2_om_node_t * element_node,
- const char *attribute_name,
- const char *value,
+/*axis2_om_attribute_t *
+axis2_om_element_add_attribute_with_namespace (axis2_om_node_t * element,
+ const axis2_char_t *attribute_name,
+ const axis2_char_t *value,
axis2_om_namespace_t * ns)
{
axis2_om_namespace_t *namespace1 = NULL;
- if (!element_node || element_node->element_type != AXIS2_OM_ELEMENT)
+ if (!element || element->element_type != AXIS2_OM_ELEMENT)
{
return NULL;
}
if (ns)
{
- namespace1 = axis2_om_element_find_namespace (element_node, ns->uri,
+ namespace1 = axis2_om_element_find_namespace (element, ns->uri,
ns->prefix);
if (namespace1 == NULL)
{
return NULL;
}
}
- return axis2_om_element_add_attribute (element_node,
+ return axis2_om_element_add_attribute (element,
axis2_om_attribute_create
(attribute_name, value, ns));
}
+*/
-
+/*
void
axis2_om_element_set_namespace (axis2_om_node_t * node,
axis2_om_namespace_t * ns)
@@ -397,43 +412,52 @@
((axis2_om_element_t *) (node->data_element))->ns = nsp;
nsp = NULL;
}
+*/
-
-void
-axis2_free_om_element (axis2_om_element_t * element)
+axis2_status_t axis2_om_element_ops_free(axis2_environment_t *environment, struct axis2_om_element *element)
{
+ if (!element)
+ {
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return AXIS2_FAILURE;
+ }
+
if (element)
{
if (element->localname)
{
- free (element->localname);
+ axis2_free (environment->allocator, element->localname);
}
if (element->ns)
{
- axis2_om_namespace_free (element->ns);
+ /* it is the responsibility of the element where the namespace is declared to free it*/
}
if (element->attributes)
{
-
+ /* TODO: free attributes*/
+ /*need to eterate and free individual attributes*/
}
if (element->namespaces)
{
-
+ /*TODO: free namespaces*/
+ /*need to eterate and free individual namespaces*/
}
- free (element);
+ axis2_free (environment->allocator, element->ops);
+ axis2_free (environment->allocator, element);
}
+ return AXIS2_SUCCESS;
}
-void
-axis2_om_element_set_localname (axis2_om_node_t * element_node,
- const char *localname)
+/*void
+axis2_om_element_set_localname (axis2_om_node_t * element,
+ const axis2_char_t *localname)
{
axis2_om_element_t *element = NULL;
- if (!element_node || element_node->element_type != AXIS2_OM_ELEMENT)
+ if (!element || element->element_type != AXIS2_OM_ELEMENT)
{
return;
}
- element = (axis2_om_element_t *) (element_node->data_element);
+ element = (axis2_om_element_t *) (element->data_element);
if (element->localname)
{
@@ -442,45 +466,50 @@
element->localname = strdup (localname);
}
-char *
-axis2_om_element_get_localname (axis2_om_node_t * element_node)
+axis2_char_t *
+axis2_om_element_get_localname (axis2_om_node_t * element)
{
- if (!element_node || element_node->element_type != AXIS2_OM_ELEMENT)
+ if (!element || element->element_type != AXIS2_OM_ELEMENT)
{
return NULL;
}
- return ((axis2_om_element_t *) (element_node->data_element))->localname;
+ return ((axis2_om_element_t *) (element->data_element))->localname;
}
+*/
-int
-axis2_om_element_serialize_start_part (axis2_om_element_t * element_node,
- axis2_om_output_t * om_output)
+axis2_status_t axis2_om_element_impl_serialize_start_part(axis2_environment_t *environment, axis2_om_element_t *element, axis2_om_output_t* om_output)
{
int status = AXIS2_SUCCESS;
- // TODO : handle null pointer errors
- if (element_node->ns && element_node->ns->uri && element_node->ns->prefix)
- status = axis2_om_output_write (om_output, AXIS2_OM_ELEMENT, 3,
- element_node->localname, element_node->ns->uri,
- element_node->ns->prefix);
- else if (element_node->ns && element_node->ns->uri)
- status = axis2_om_output_write (om_output, AXIS2_OM_ELEMENT, 2,
- element_node->localname,
- element_node->ns->uri);
+ if (!element || !om_output)
+ {
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return AXIS2_FAILURE;
+ }
+
+
+ if (element->ns && element->ns->uri && element->ns->prefix)
+ status = axis2_om_output_write (environment, om_output, AXIS2_OM_ELEMENT, 3,
+ element->localname, element->ns->uri,
+ element->ns->prefix);
+ else if (element->ns && element->ns->uri)
+ status = axis2_om_output_write (environment, om_output, AXIS2_OM_ELEMENT, 2,
+ element->localname,
+ element->ns->uri);
else
- status = axis2_om_output_write (om_output, AXIS2_OM_ELEMENT, 1,
- element_node->localname);
+ status = axis2_om_output_write (environment, om_output, AXIS2_OM_ELEMENT, 1,
+ element->localname);
- // serialize attributes
- if (element_node->attributes)
+ /* serialize attributes */
+ if (element->attributes)
{
- apr_hash_index_t *hi;
+ axis2_hash_index_t *hi;
void *val;
- for (hi = apr_hash_first(om_pool, element_node->attributes); hi; hi = apr_hash_next(hi))
+ for (hi = axis2_hash_first(environment, element->attributes); hi; hi = axis2_hash_next(hi))
{
- apr_hash_this(hi, NULL, NULL, &val);
+ axis2_hash_this(hi, NULL, NULL, &val);
if (val)
- status = axis2_om_attribute_serialize( (axis2_om_attribute_t*)val, om_output);
+ status = axis2_om_attribute_serialize(environment, (axis2_om_attribute_t*)val, om_output);
else
{
status = AXIS2_FAILURE;
@@ -488,17 +517,17 @@
}
}
- // serialize namespaces
- if (element_node->namespaces)
+ /* serialize namespaces */
+ if (element->namespaces)
{
- apr_hash_index_t *hi;
+ axis2_hash_index_t *hi;
void *val;
- for (hi = apr_hash_first(om_pool, element_node->namespaces); hi; hi = apr_hash_next(hi))
+ for (hi = axis2_hash_first(environment, element->namespaces); hi; hi = axis2_hash_next(hi))
{
- apr_hash_this(hi, NULL, NULL, &val);
+ axis2_hash_this(hi, NULL, NULL, &val);
if (val)
- status = axis2_om_namespace_serialize( (axis2_om_namespace_t*)val, om_output);
+ status = axis2_om_namespace_serialize(environment, (axis2_om_namespace_t*)val, om_output);
else
{
status = AXIS2_FAILURE;
@@ -509,12 +538,16 @@
return status;
}
-int
-axis2_om_element_serialize_end_part (axis2_om_element_t * element_node,
- axis2_om_output_t * om_output)
+axis2_status_t axis2_om_element_impl_serialize_end_part(axis2_environment_t *environment, axis2_om_element_t *element, axis2_om_output_t* om_output)
{
int status = AXIS2_SUCCESS;
- // TODO : handle null pointer errors
- status = axis2_om_output_write (om_output, AXIS2_OM_ELEMENT, 0);
+
+ if (!om_output)
+ {
+ environment->error->errorno = AXIS2_ERROR_INVALID_NULL_PARAMETER;
+ return AXIS2_FAILURE;
+ }
+
+ status = axis2_om_output_write (environment, om_output, AXIS2_OM_ELEMENT, 0);
return status;
}
Modified: webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_node.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_node.c?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_node.c (original)
+++ webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_node.c Mon Oct 17 20:59:42 2005
@@ -277,7 +277,7 @@
if(parent_node && parent_node->first_child && !(parent_node->current_child))
{
- environment->error->errorno = AXIS2_ERROR_INVALID_OPERATION;
+ environment->error->errorno = AXIS2_ERROR_INVALID_ITERATOR_STATE;
return NULL;
}
if(parent_node->current_child->next_sibling)
@@ -336,5 +336,3 @@
*/
return AXIS2_SUCCESS;
}
-
-
Modified: webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_text.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_text.c?rev=326023&r1=326022&r2=326023&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_text.c (original)
+++ webservices/axis2/trunk/c/modules/xml/om/src/axis2_om_text.c Mon Oct 17 20:59:42 2005
@@ -37,7 +37,7 @@
return NULL;
}
- *node = axis2_om_node_create();
+ *node = axis2_om_node_create(environment);
if (!(*node))
{
@@ -56,21 +56,21 @@
om_text->value = NULL;
if (value)
- om_text->value = (axis2_char_t*) axis2_strdup(environment->allocator, value);
+ om_text->value = (axis2_char_t*) axis2_strdup(environment->string, value);
/* om_text->attribute = NULL; */
om_text->content_id = NULL;
om_text->mime_type = NULL;
(*node)->data_element = om_text;
- (*node)->element_type = AXIS2_OM_TEXT;
+ (*node)->node_type = AXIS2_OM_TEXT;
(*node)->done = AXIS2_FALSE;
- if(parent && parent->element_type == AXIS2_OM_ELEMENT)
+ if(parent && parent->node_type == AXIS2_OM_ELEMENT)
{
(*node)->parent = parent;
- axis2_om_node_add_child(parent,*node);
+ axis2_om_node_add_child(environment, parent,*node);
}
/* operations */