axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r413605 [7/10] - in /webservices/axis2/trunk/c/axiom: include/ src/attachments/ src/om/ src/soap/ src/util/ test/om/ test/soap/ test/unit/ test/unit/om/
Date Mon, 12 Jun 2006 08:23:02 GMT
Modified: webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c Mon Jun 12 01:22:58 2006
@@ -14,55 +14,55 @@
  * limitations under the License.
  */
 
-#include <axis2_om_stax_builder.h>
-#include <axis2_om_element.h>
-#include <axis2_om_text.h>
-#include <axis2_om_processing_instruction.h>
-#include <axis2_om_comment.h>
+#include <axiom_stax_builder.h>
+#include <axiom_element.h>
+#include <axiom_text.h>
+#include <axiom_processing_instruction.h>
+#include <axiom_comment.h>
 #include <axis2_string.h>
 #include <axis2_xml_writer.h>
-#include <axis2_om_doctype.h>
-#include "axis2_om_node_internal.h"
-#include "axis2_om_stax_builder_internal.h"
+#include <axiom_doctype.h>
+#include "axiom_node_internal.h"
+#include "axiom_stax_builder_internal.h"
 /**************************** function prototypes *****************************/
 
-axis2_om_node_t * AXIS2_CALL 
-axis2_om_stax_builder_next (axis2_om_stax_builder_t *builder,
+axiom_node_t * AXIS2_CALL 
+axiom_stax_builder_next (axiom_stax_builder_t *builder,
                             const axis2_env_t *env);
                                  
 axis2_status_t AXIS2_CALL 
-axis2_om_stax_builder_discard_current_element (axis2_om_stax_builder_t *builder,
+axiom_stax_builder_discard_current_element (axiom_stax_builder_t *builder,
                                                const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL 
-axis2_om_stax_builder_free(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_free(axiom_stax_builder_t *builder,
                            const axis2_env_t *env);
 
                                             
-axis2_om_document_t* AXIS2_CALL
-axis2_om_stax_builder_get_document (axis2_om_stax_builder_t *builder,
+axiom_document_t* AXIS2_CALL
+axiom_stax_builder_get_document (axiom_stax_builder_t *builder,
                                     const axis2_env_t *env);
                                             
 axis2_bool_t  AXIS2_CALL
-axis2_om_stax_builder_is_complete(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_is_complete(axiom_stax_builder_t *builder,
                                    const axis2_env_t *env);
                                                                                                
 int AXIS2_CALL 
-axis2_om_stax_builder_next_with_token(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_next_with_token(axiom_stax_builder_t *builder,
                                           const axis2_env_t *env);                                                                                                                                                                             
                                        
-/********************************* axis2_om_stax_builder_impl_t struct ********/
-typedef struct axis2_om_stax_builder_impl_t
+/********************************* axiom_stax_builder_impl_t struct ********/
+typedef struct axiom_stax_builder_impl_t
 {
-    axis2_om_stax_builder_t om_stax_builder;
+    axiom_stax_builder_t om_stax_builder;
     /** pull parser instance used by the builder */
     axis2_xml_reader_t *parser;
     /** last node the builder found */
-    axis2_om_node_t *lastnode;
+    axiom_node_t *lastnode;
     
-    axis2_om_node_t *root_node;
+    axiom_node_t *root_node;
     /** document associated with the builder */
-    axis2_om_document_t *document;
+    axiom_document_t *document;
     /** done building the document? */
     axis2_bool_t done;
     /** parser was accessed? */
@@ -74,25 +74,25 @@
     
     int element_level;
         
-}axis2_om_stax_builder_impl_t;
+}axiom_stax_builder_impl_t;
 
 /************************************** Macro *********************************/            
 
-#define AXIS2_INTF_TO_IMPL(builder) ((axis2_om_stax_builder_impl_t*)builder)
+#define AXIS2_INTF_TO_IMPL(builder) ((axiom_stax_builder_impl_t*)builder)
 
 /******************************************************************************/
 
                                        
-AXIS2_EXTERN axis2_om_stax_builder_t * AXIS2_CALL
-axis2_om_stax_builder_create (const axis2_env_t *env,
+AXIS2_EXTERN axiom_stax_builder_t * AXIS2_CALL
+axiom_stax_builder_create (const axis2_env_t *env,
                               axis2_xml_reader_t *parser)
 {
-    axis2_om_stax_builder_impl_t *builder = NULL;
+    axiom_stax_builder_impl_t *builder = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, parser, NULL);
     
-    builder = (axis2_om_stax_builder_impl_t *)AXIS2_MALLOC (
-                env->allocator, sizeof(axis2_om_stax_builder_impl_t));
+    builder = (axiom_stax_builder_impl_t *)AXIS2_MALLOC (
+                env->allocator, sizeof(axiom_stax_builder_impl_t));
 
     if (!builder)
     {
@@ -110,7 +110,7 @@
     builder->root_node = NULL;
     builder->element_level = 0;
   
-    builder->document = axis2_om_document_create(env, NULL, &(builder->om_stax_builder));
+    builder->document = axiom_document_create(env, NULL, &(builder->om_stax_builder));
     if(!builder->document)
     {
         AXIS2_FREE(env->allocator, builder);
@@ -119,9 +119,9 @@
   
     /* ops */
     builder->om_stax_builder.ops = NULL;
-    builder->om_stax_builder.ops = (axis2_om_stax_builder_ops_t *) AXIS2_MALLOC(
+    builder->om_stax_builder.ops = (axiom_stax_builder_ops_t *) AXIS2_MALLOC(
                                         env->allocator, 
-                                        sizeof(axis2_om_stax_builder_ops_t));
+                                        sizeof(axiom_stax_builder_ops_t));
 
     if (!builder->om_stax_builder.ops)
     {
@@ -132,21 +132,21 @@
     }
 
     builder->om_stax_builder.ops->next = 
-            axis2_om_stax_builder_next;
+            axiom_stax_builder_next;
     builder->om_stax_builder.ops->discard_current_element = 
-            axis2_om_stax_builder_discard_current_element;
+            axiom_stax_builder_discard_current_element;
         
    builder->om_stax_builder.ops->free = 
-           axis2_om_stax_builder_free;
+           axiom_stax_builder_free;
 
     builder->om_stax_builder.ops->get_document = 
-            axis2_om_stax_builder_get_document;
+            axiom_stax_builder_get_document;
     
     builder->om_stax_builder.ops->next_with_token =
-            axis2_om_stax_builder_next_with_token;                       
+            axiom_stax_builder_next_with_token;                       
             
     builder->om_stax_builder.ops->is_complete =
-            axis2_om_stax_builder_is_complete;
+            axiom_stax_builder_is_complete;
                                                
    
     return &(builder->om_stax_builder);
@@ -154,20 +154,20 @@
 
 
 axis2_status_t
-axis2_om_stax_builder_process_attributes (axis2_om_stax_builder_t *om_builder,
+axiom_stax_builder_process_attributes (axiom_stax_builder_t *om_builder,
                                           const axis2_env_t *env,
-                                          axis2_om_node_t *element_node)
+                                          axiom_node_t *element_node)
 {
     int i = 0;
     int attribute_count;
-    axis2_om_attribute_t *attribute = NULL;
-    axis2_om_namespace_t *ns = NULL;
+    axiom_attribute_t *attribute = NULL;
+    axiom_namespace_t *ns = NULL;
     axis2_char_t *uri = NULL;
     axis2_char_t *prefix = NULL;
     axis2_char_t *attr_name = NULL;
     axis2_char_t *attr_value = NULL;
     
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     axis2_status_t status = AXIS2_SUCCESS;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -179,7 +179,7 @@
                                builder_impl->parser,env);
     for (i=1; i <= attribute_count ; i++)
     {
-        axis2_om_element_t *temp_ele =  NULL;
+        axiom_element_t *temp_ele =  NULL;
         
         uri =  AXIS2_XML_READER_GET_ATTRIBUTE_NAMESPACE_BY_NUMBER(
                        builder_impl->parser, env, i);
@@ -190,17 +190,17 @@
         {
             if (axis2_strcmp (uri, "") != 0)
             {
-                axis2_om_element_t *om_ele = NULL;
-                om_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(element_node,env);
+                axiom_element_t *om_ele = NULL;
+                om_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(element_node,env);
                 if(om_ele)
                 {
-                    ns = AXIS2_OM_ELEMENT_FIND_NAMESPACE ( om_ele ,
+                    ns = AXIOM_ELEMENT_FIND_NAMESPACE ( om_ele ,
                         env , element_node, uri, prefix);
         
         /* newly added to handle "xml:*" attributes" (AXIS2_STRCMP(prefix, "xml") == 0) && */
                     if(!ns)
                     {
-                        ns = axis2_om_namespace_create(env, uri, prefix);
+                        ns = axiom_namespace_create(env, uri, prefix);
                     }
                 }                        
             }
@@ -213,14 +213,14 @@
                                  builder_impl->parser, env, i);
         if(NULL != attr_name)
         {   
-            attribute = axis2_om_attribute_create (env, attr_name, attr_value, ns);
+            attribute = axiom_attribute_create (env, attr_name, attr_value, ns);
             if(!attribute)
                 return AXIS2_FAILURE;
             
-            temp_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(element_node,env);
+            temp_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(element_node,env);
             if(NULL != temp_ele)
             {
-                status = AXIS2_OM_ELEMENT_ADD_ATTRIBUTE (temp_ele, env, attribute, element_node);
+                status = AXIOM_ELEMENT_ADD_ATTRIBUTE (temp_ele, env, attribute, element_node);
             }
         }                        
         if(uri)
@@ -238,13 +238,13 @@
 }
 
 
-axis2_om_node_t *
-axis2_om_stax_builder_create_om_text (axis2_om_stax_builder_t * om_stax_builder,
+axiom_node_t *
+axiom_stax_builder_create_om_text (axiom_stax_builder_t * om_stax_builder,
                                       const axis2_env_t *env)
 {
     axis2_char_t *temp_value = NULL;
-    axis2_om_node_t *node = NULL;
-    axis2_om_stax_builder_impl_t *builder = NULL;
+    axiom_node_t *node = NULL;
+    axiom_stax_builder_impl_t *builder = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     builder = AXIS2_INTF_TO_IMPL(om_stax_builder);
@@ -263,19 +263,19 @@
         return NULL;
     }
   
-    if (AXIS2_OM_NODE_IS_COMPLETE(builder->lastnode, env))
+    if (AXIOM_NODE_IS_COMPLETE(builder->lastnode, env))
     {
-        axis2_om_text_create (env, 
-                              AXIS2_OM_NODE_GET_PARENT(builder->lastnode, env),
+        axiom_text_create (env, 
+                              AXIOM_NODE_GET_PARENT(builder->lastnode, env),
                               temp_value, &node);
   
     }
     else
     {
-        axis2_om_text_create (env, builder->lastnode, temp_value, &node);
+        axiom_text_create (env, builder->lastnode, temp_value, &node);
     }
 
-    axis2_om_node_set_complete(node , env, AXIS2_TRUE);
+    axiom_node_set_complete(node , env, AXIS2_TRUE);
     builder->lastnode = node;
     
     AXIS2_XML_READER_XML_FREE(builder->parser , env, temp_value);
@@ -284,13 +284,13 @@
 
 
 axis2_status_t AXIS2_CALL
-axis2_om_stax_builder_discard_current_element (axis2_om_stax_builder_t *om_stax_builder,
+axiom_stax_builder_discard_current_element (axiom_stax_builder_t *om_stax_builder,
                                                const axis2_env_t *env)
 {
-    axis2_om_node_t *element = NULL;
-    axis2_om_node_t *prev_node = NULL;
-    axis2_om_node_t *parent = NULL;
-    axis2_om_stax_builder_impl_t *builder = NULL;
+    axiom_node_t *element = NULL;
+    axiom_node_t *prev_node = NULL;
+    axiom_node_t *parent = NULL;
+    axiom_stax_builder_impl_t *builder = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
@@ -298,7 +298,7 @@
     
     element = builder->lastnode;
 
-    if (AXIS2_OM_NODE_IS_COMPLETE(element, env) || !(builder->cache))
+    if (AXIOM_NODE_IS_COMPLETE(element, env) || !(builder->cache))
     {
         AXIS2_ERROR_SET(env->error,
                 AXIS2_ERROR_INVALID_BUILDER_STATE_CANNOT_DISCARD, AXIS2_FAILURE);
@@ -312,21 +312,21 @@
         while (AXIS2_XML_READER_NEXT (builder->parser, env)
                 != AXIS2_XML_READER_END_ELEMENT);
     }
-    while (!(AXIS2_OM_NODE_IS_COMPLETE(element, env)));
+    while (!(AXIOM_NODE_IS_COMPLETE(element, env)));
 
     /*All children of this element is pulled now */
 
-    prev_node = AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(element, env);
+    prev_node = AXIOM_NODE_GET_PREVIOUS_SIBLING(element, env);
     if (prev_node)
     {
-        AXIS2_OM_NODE_FREE_TREE(AXIS2_OM_NODE_GET_NEXT_SIBLING(prev_node, env), env);
-        axis2_om_node_set_next_sibling(prev_node, env, NULL);        
+        AXIOM_NODE_FREE_TREE(AXIOM_NODE_GET_NEXT_SIBLING(prev_node, env), env);
+        axiom_node_set_next_sibling(prev_node, env, NULL);        
     }
     else
     {
-        parent = AXIS2_OM_NODE_GET_PARENT(element, env);
-        AXIS2_OM_NODE_FREE_TREE(AXIS2_OM_NODE_GET_FIRST_CHILD(parent, env), env);
-        axis2_om_node_set_first_child(parent, env, NULL);
+        parent = AXIOM_NODE_GET_PARENT(element, env);
+        AXIOM_NODE_FREE_TREE(AXIOM_NODE_GET_FIRST_CHILD(parent, env), env);
+        axiom_node_set_first_child(parent, env, NULL);
         builder->lastnode = parent;
     }
     builder->cache = AXIS2_TRUE;
@@ -335,21 +335,21 @@
 }
 
 axis2_status_t
-axis2_om_stax_builder_process_namespaces (axis2_om_stax_builder_t *om_stax_builder,
+axiom_stax_builder_process_namespaces (axiom_stax_builder_t *om_stax_builder,
                                           const axis2_env_t *env,
-                                          axis2_om_node_t *node,
+                                          axiom_node_t *node,
                                           int is_soap_element)
 {
     axis2_status_t status = AXIS2_SUCCESS;
     int namespace_count = 0;
-    axis2_om_namespace_t *om_ns = NULL;
-    axis2_om_namespace_t *temp_ns = NULL;
+    axiom_namespace_t *om_ns = NULL;
+    axiom_namespace_t *temp_ns = NULL;
     /* temp values */
     axis2_char_t *temp_prefix = NULL;
     axis2_char_t *temp_ns_prefix = NULL;
     axis2_char_t *temp_ns_uri    = NULL;
     
-    axis2_om_stax_builder_impl_t *builder = NULL;
+    axiom_stax_builder_impl_t *builder = NULL;
     int i=0;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -369,40 +369,40 @@
         {
             /** default namespace case */
             /** !temp_ns_prefix is for guththila */         
-             axis2_om_element_t *om_ele = NULL;
-             om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env);
+             axiom_element_t *om_ele = NULL;
+             om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(node, env);
             
-             om_ns = axis2_om_namespace_create ( env, temp_ns_uri, "");
+             om_ns = axiom_namespace_create ( env, temp_ns_uri, "");
              if(!om_ns || !om_ele)
                  return AXIS2_FAILURE;
              
-             status = AXIS2_OM_ELEMENT_DECLARE_NAMESPACE( om_ele, env, node, om_ns);
+             status = AXIOM_ELEMENT_DECLARE_NAMESPACE( om_ele, env, node, om_ns);
             
-             temp_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(om_ele, env, temp_ns_uri, NULL);
+             temp_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(om_ele, env, temp_ns_uri, NULL);
              /*
              if(temp_ns)
              {
-                AXIS2_OM_ELEMENT_SET_NAMESPACE (om_ele, env, om_ns, node); 
+                AXIOM_ELEMENT_SET_NAMESPACE (om_ele, env, om_ns, node); 
              } 
              */                
              if(!temp_ns)
              {
-                AXIS2_OM_NAMESPACE_FREE(om_ns, env);
+                AXIOM_NAMESPACE_FREE(om_ns, env);
                 om_ns = NULL;
              }
         }
         else
         {       
-            axis2_om_element_t *om_ele = NULL;
-            om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env);
+            axiom_element_t *om_ele = NULL;
+            om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(node, env);
             
-            om_ns = axis2_om_namespace_create ( env, temp_ns_uri, temp_ns_prefix );
+            om_ns = axiom_namespace_create ( env, temp_ns_uri, temp_ns_prefix );
             if(!om_ns || !om_ele)
                 return AXIS2_FAILURE;
             
-            status = AXIS2_OM_ELEMENT_DECLARE_NAMESPACE(om_ele, env, node, om_ns);
+            status = AXIOM_ELEMENT_DECLARE_NAMESPACE(om_ele, env, node, om_ns);
            /*        
-            temp_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(om_ele, 
+            temp_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(om_ele, 
                             env, temp_ns_uri,temp_ns_prefix);
            */
         }        
@@ -418,16 +418,16 @@
     temp_prefix = AXIS2_XML_READER_GET_PREFIX ( builder->parser, env);
     if (temp_prefix)
     {
-        om_ns = AXIS2_OM_ELEMENT_FIND_NAMESPACE (
-                    (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env),
+        om_ns = AXIOM_ELEMENT_FIND_NAMESPACE (
+                    (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(node, env),
                     env, node, NULL, temp_prefix);
        
         if (om_ns)
         {
-            axis2_om_element_t *om_ele = NULL;
-            om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env);
+            axiom_element_t *om_ele = NULL;
+            om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(node, env);
             if(om_ele)
-                AXIS2_OM_ELEMENT_SET_NAMESPACE (om_ele, env, om_ns, node);
+                AXIOM_ELEMENT_SET_NAMESPACE (om_ele, env, om_ns, node);
         }
         else
         {
@@ -442,13 +442,13 @@
     return status;
 }
 
-axis2_om_node_t *
-axis2_om_stax_builder_create_om_element (axis2_om_stax_builder_t *om_stax_builder,
+axiom_node_t *
+axiom_stax_builder_create_om_element (axiom_stax_builder_t *om_stax_builder,
                                          const axis2_env_t *env)
 {
-    axis2_om_node_t *element_node = NULL;
-    axis2_om_element_t *om_ele = NULL;
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_node_t *element_node = NULL;
+    axiom_element_t *om_ele = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     axis2_char_t *temp_localname = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -468,57 +468,57 @@
     
     if (!(builder_impl->lastnode))
     {
-        om_ele = axis2_om_element_create (env , NULL, temp_localname, NULL, &element_node);
+        om_ele = axiom_element_create (env , NULL, temp_localname, NULL, &element_node);
         if(!om_ele)
             return NULL;
             
         builder_impl->root_node = element_node;
                 
-        axis2_om_node_set_builder(element_node, env, om_stax_builder);        
+        axiom_node_set_builder(element_node, env, om_stax_builder);        
    
         if(builder_impl->document)        
         {
-            axis2_om_node_set_document(element_node, env, builder_impl->document);
-            AXIS2_OM_DOCUMENT_SET_ROOT_ELEMENT(builder_impl->document, env, element_node);
+            axiom_node_set_document(element_node, env, builder_impl->document);
+            AXIOM_DOCUMENT_SET_ROOT_ELEMENT(builder_impl->document, env, element_node);
         }
     }
-    else if(AXIS2_OM_NODE_IS_COMPLETE(builder_impl->lastnode, env))
+    else if(AXIOM_NODE_IS_COMPLETE(builder_impl->lastnode, env))
     {   
-        axis2_om_element_t *om_ele = NULL;
+        axiom_element_t *om_ele = NULL;
         
-        om_ele = axis2_om_element_create (env, 
-                    AXIS2_OM_NODE_GET_PARENT(builder_impl->lastnode, env),
+        om_ele = axiom_element_create (env, 
+                    AXIOM_NODE_GET_PARENT(builder_impl->lastnode, env),
                     temp_localname, NULL, &element_node);
         if(!om_ele)
             return NULL;
             
         if(element_node)
         {
-            axis2_om_node_set_next_sibling(builder_impl->lastnode, env, element_node);                                 
-            axis2_om_node_set_previous_sibling(element_node , env, builder_impl->lastnode);
-            axis2_om_node_set_document(element_node, env, builder_impl->document); 
-            axis2_om_node_set_builder(element_node, env, om_stax_builder);
+            axiom_node_set_next_sibling(builder_impl->lastnode, env, element_node);                                 
+            axiom_node_set_previous_sibling(element_node , env, builder_impl->lastnode);
+            axiom_node_set_document(element_node, env, builder_impl->document); 
+            axiom_node_set_builder(element_node, env, om_stax_builder);
         }            
     }
     else
     {
-        axis2_om_element_t *om_ele = NULL;
-        om_ele = axis2_om_element_create ( env, builder_impl->lastnode,
+        axiom_element_t *om_ele = NULL;
+        om_ele = axiom_element_create ( env, builder_impl->lastnode,
                                  temp_localname, NULL, &element_node);
         if(element_node)
         {
-            axis2_om_node_set_first_child(builder_impl->lastnode , env, element_node);                     
-            axis2_om_node_set_parent(element_node , env, builder_impl->lastnode);
-            axis2_om_node_set_document(element_node, env, builder_impl->document); 
-            axis2_om_node_set_builder(element_node, env, om_stax_builder);
+            axiom_node_set_first_child(builder_impl->lastnode , env, element_node);                     
+            axiom_node_set_parent(element_node , env, builder_impl->lastnode);
+            axiom_node_set_document(element_node, env, builder_impl->document); 
+            axiom_node_set_builder(element_node, env, om_stax_builder);
         }            
     }
     if(temp_localname)
         AXIS2_XML_READER_XML_FREE(builder_impl->parser , env, temp_localname);
 
     /** order of processing namespaces first is important */
-    axis2_om_stax_builder_process_namespaces ( om_stax_builder, env, element_node, 0);
-    axis2_om_stax_builder_process_attributes ( om_stax_builder, env, element_node);
+    axiom_stax_builder_process_namespaces ( om_stax_builder, env, element_node, 0);
+    axiom_stax_builder_process_attributes ( om_stax_builder, env, element_node);
 
     builder_impl->lastnode = element_node;
    
@@ -526,12 +526,12 @@
 }
 
 
-axis2_om_node_t *
-axis2_om_stax_builder_create_om_comment (axis2_om_stax_builder_t *builder,
+axiom_node_t *
+axiom_stax_builder_create_om_comment (axiom_stax_builder_t *builder,
                                          const axis2_env_t *env)
 {
-    axis2_om_node_t *comment_node = NULL;
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_node_t *comment_node = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     axis2_char_t *comment_value = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     builder_impl = AXIS2_INTF_TO_IMPL(builder);
@@ -549,22 +549,22 @@
         AXIS2_XML_READER_XML_FREE(builder_impl->parser , env, comment_value);
         return NULL;   
     }
-    else if (AXIS2_OM_NODE_IS_COMPLETE(builder_impl->lastnode, env))
+    else if (AXIOM_NODE_IS_COMPLETE(builder_impl->lastnode, env))
     {
-        axis2_om_comment_create (env, 
-                AXIS2_OM_NODE_GET_PARENT(builder_impl->lastnode, env),
+        axiom_comment_create (env, 
+                AXIOM_NODE_GET_PARENT(builder_impl->lastnode, env),
                 comment_value , &comment_node);
        
-       axis2_om_node_set_next_sibling(builder_impl->lastnode, env, comment_node);                                 
-        axis2_om_node_set_previous_sibling(comment_node , env, builder_impl->lastnode);
+       axiom_node_set_next_sibling(builder_impl->lastnode, env, comment_node);                                 
+        axiom_node_set_previous_sibling(comment_node , env, builder_impl->lastnode);
     }
     else
     {
-        axis2_om_comment_create( env, builder_impl->lastnode,
+        axiom_comment_create( env, builder_impl->lastnode,
                                  comment_value ,&comment_node);
         
-        axis2_om_node_set_first_child(builder_impl->lastnode , env, comment_node);                     
-        axis2_om_node_set_parent(comment_node , env, builder_impl->lastnode);
+        axiom_node_set_first_child(builder_impl->lastnode , env, comment_node);                     
+        axiom_node_set_parent(comment_node , env, builder_impl->lastnode);
     }
     
     builder_impl->element_level++;
@@ -578,12 +578,12 @@
 }
 
 
-axis2_om_node_t * 
-axis2_om_stax_builder_create_om_doctype (axis2_om_stax_builder_t * builder,
+axiom_node_t * 
+axiom_stax_builder_create_om_doctype (axiom_stax_builder_t * builder,
                                          const axis2_env_t *env)
 {
-    axis2_om_stax_builder_impl_t *builder_impl;
-    axis2_om_node_t *doctype_node = NULL;
+    axiom_stax_builder_impl_t *builder_impl;
+    axiom_node_t *doctype_node = NULL;
     axis2_char_t *doc_value = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -594,10 +594,10 @@
         return NULL;
     if(!(builder_impl->lastnode))
     {
-        axis2_om_doctype_create(env, NULL, doc_value, &doctype_node);
+        axiom_doctype_create(env, NULL, doc_value, &doctype_node);
         if(builder_impl->document)
         {            
-            AXIS2_OM_DOCUMENT_SET_ROOT_ELEMENT(builder_impl->document, 
+            AXIOM_DOCUMENT_SET_ROOT_ELEMENT(builder_impl->document, 
                                         env, doctype_node);
         }            
     }
@@ -607,12 +607,12 @@
 }
 
  
-axis2_om_node_t * 
-axis2_om_stax_builder_create_om_processing_instruction (axis2_om_stax_builder_t *builder,
+axiom_node_t * 
+axiom_stax_builder_create_om_processing_instruction (axiom_stax_builder_t *builder,
                                                         const axis2_env_t *env)
 {
-    axis2_om_node_t *pi_node = NULL;
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_node_t *pi_node = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     axis2_char_t *target = NULL;
     axis2_char_t *value  = NULL;
     
@@ -635,22 +635,22 @@
         AXIS2_XML_READER_XML_FREE(builder_impl->parser , env, value);
         return NULL;
     }
-    else if (AXIS2_OM_NODE_IS_COMPLETE(builder_impl->lastnode, env) ||
-     (AXIS2_OM_NODE_GET_NODE_TYPE(builder_impl->lastnode, env) == AXIS2_OM_TEXT))
+    else if (AXIOM_NODE_IS_COMPLETE(builder_impl->lastnode, env) ||
+     (AXIOM_NODE_GET_NODE_TYPE(builder_impl->lastnode, env) == AXIOM_TEXT))
     {
-        axis2_om_processing_instruction_create(env,
-                        AXIS2_OM_NODE_GET_PARENT(builder_impl->lastnode, env),
+        axiom_processing_instruction_create(env,
+                        AXIOM_NODE_GET_PARENT(builder_impl->lastnode, env),
                         target, value, &pi_node);
                  
-        axis2_om_node_set_next_sibling(builder_impl->lastnode, env, pi_node);                                 
-        axis2_om_node_set_previous_sibling(pi_node , env, builder_impl->lastnode);
+        axiom_node_set_next_sibling(builder_impl->lastnode, env, pi_node);                                 
+        axiom_node_set_previous_sibling(pi_node , env, builder_impl->lastnode);
     }
     else
     {
-        axis2_om_processing_instruction_create( env, builder_impl->lastnode,
+        axiom_processing_instruction_create( env, builder_impl->lastnode,
                                  target, value, &pi_node);
-        axis2_om_node_set_first_child(builder_impl->lastnode , env, pi_node);                     
-        axis2_om_node_set_parent(pi_node , env, builder_impl->lastnode);
+        axiom_node_set_first_child(builder_impl->lastnode , env, pi_node);                     
+        axiom_node_set_parent(pi_node , env, builder_impl->lastnode);
     }
     
     builder_impl->element_level++;
@@ -665,11 +665,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_om_stax_builder_end_element (axis2_om_stax_builder_t *om_stax_builder,
+axiom_stax_builder_end_element (axiom_stax_builder_t *om_stax_builder,
                                    const axis2_env_t *env)
 {
-    axis2_om_node_t *parent = NULL;
-    axis2_om_stax_builder_impl_t *builder = NULL;
+    axiom_node_t *parent = NULL;
+    axiom_stax_builder_impl_t *builder = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE );
     builder = AXIS2_INTF_TO_IMPL(om_stax_builder);
@@ -678,23 +678,23 @@
     
     if (builder->lastnode)
     {
-        if (AXIS2_OM_NODE_IS_COMPLETE((builder->lastnode), env))
+        if (AXIOM_NODE_IS_COMPLETE((builder->lastnode), env))
         {
-            parent = AXIS2_OM_NODE_GET_PARENT((builder->lastnode), env);
+            parent = AXIOM_NODE_GET_PARENT((builder->lastnode), env);
             if (parent)
             {
-                axis2_om_node_set_complete(parent, env, AXIS2_TRUE);
+                axiom_node_set_complete(parent, env, AXIS2_TRUE);
                 builder->lastnode= parent;
             }
         }
         else
         {
-            axis2_om_node_set_complete((builder->lastnode), env, AXIS2_TRUE);
+            axiom_node_set_complete((builder->lastnode), env, AXIS2_TRUE);
         }
     }
     if(builder->root_node)
     {
-        if(AXIS2_OM_NODE_IS_COMPLETE(builder->root_node , env))
+        if(AXIOM_NODE_IS_COMPLETE(builder->root_node , env))
         {
             builder->done = AXIS2_TRUE;
         }   
@@ -703,13 +703,13 @@
 }
 
 
-axis2_om_node_t * AXIS2_CALL
-axis2_om_stax_builder_next (axis2_om_stax_builder_t *om_stax_builder,
+axiom_node_t * AXIS2_CALL
+axiom_stax_builder_next (axiom_stax_builder_t *om_stax_builder,
                             const axis2_env_t *env)
 {
     int token = 0;
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
-    axis2_om_node_t *node = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
+    axiom_node_t *node = NULL;
     AXIS2_ENV_CHECK(env, NULL);
 
     builder_impl = AXIS2_INTF_TO_IMPL(om_stax_builder);
@@ -743,16 +743,16 @@
             break;
         
         case AXIS2_XML_READER_START_ELEMENT:
-           node = axis2_om_stax_builder_create_om_element (
+           node = axiom_stax_builder_create_om_element (
                         om_stax_builder, env); 
             break;
         
         case AXIS2_XML_READER_EMPTY_ELEMENT:
-            node = axis2_om_stax_builder_create_om_element (
+            node = axiom_stax_builder_create_om_element (
                         om_stax_builder, env);
         
         case AXIS2_XML_READER_END_ELEMENT:
-            axis2_om_stax_builder_end_element (om_stax_builder, env);
+            axiom_stax_builder_end_element (om_stax_builder, env);
             break;
         
         
@@ -761,7 +761,7 @@
             break;
         
         case AXIS2_XML_READER_CHARACTER:
-            node = axis2_om_stax_builder_create_om_text(om_stax_builder, env);
+            node = axiom_stax_builder_create_om_text(om_stax_builder, env);
             break;
                 
         case AXIS2_XML_READER_ENTITY_REFERENCE:
@@ -769,16 +769,16 @@
         
         case AXIS2_XML_READER_COMMENT:
             
-             node = axis2_om_stax_builder_create_om_comment(om_stax_builder, env);
-                axis2_om_stax_builder_end_element (om_stax_builder, env);
+             node = axiom_stax_builder_create_om_comment(om_stax_builder, env);
+                axiom_stax_builder_end_element (om_stax_builder, env);
         
             break;
         
         case AXIS2_XML_READER_PROCESSING_INSTRUCTION:
             
-            node = axis2_om_stax_builder_create_om_processing_instruction(
+            node = axiom_stax_builder_create_om_processing_instruction(
                                         om_stax_builder , env );
-            axis2_om_stax_builder_end_element (om_stax_builder, env);
+            axiom_stax_builder_end_element (om_stax_builder, env);
           
             break;
         
@@ -786,7 +786,7 @@
             break;
         
         case AXIS2_XML_READER_DOCUMENT_TYPE:
-        /* node = axis2_om_stax_builder_create_om_doctype(om_stax_builder, env);
+        /* node = axiom_stax_builder_create_om_doctype(om_stax_builder, env);
         */          
         break;
         
@@ -800,10 +800,10 @@
 
 
 axis2_status_t 
-AXIS2_CALL axis2_om_stax_builder_free(axis2_om_stax_builder_t *builder,
+AXIS2_CALL axiom_stax_builder_free(axiom_stax_builder_t *builder,
                                       const axis2_env_t *env)
 {
-    axis2_om_stax_builder_impl_t *builder_impl =  NULL;
+    axiom_stax_builder_impl_t *builder_impl =  NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     if(!builder)
         return AXIS2_FAILURE;
@@ -817,14 +817,14 @@
     }
     if(builder_impl->document)
     {
-        AXIS2_OM_DOCUMENT_FREE(builder_impl->document, env);
+        AXIOM_DOCUMENT_FREE(builder_impl->document, env);
         builder_impl->document = NULL;
     }
     else
     {
         if(NULL != builder_impl->root_node )
         {
-            AXIS2_OM_NODE_FREE_TREE(builder_impl->root_node, env);
+            AXIOM_NODE_FREE_TREE(builder_impl->root_node, env);
             builder_impl->root_node = NULL;
         }
     }
@@ -838,8 +838,8 @@
 }
 
 
-axis2_om_document_t* AXIS2_CALL
-axis2_om_stax_builder_get_document (axis2_om_stax_builder_t *builder,
+axiom_document_t* AXIS2_CALL
+axiom_stax_builder_get_document (axiom_stax_builder_t *builder,
                                     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,NULL);
@@ -851,7 +851,7 @@
 */
 
 AXIS2_EXTERN int AXIS2_CALL
-axis2_om_stax_builder_get_current_event(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_get_current_event(axiom_stax_builder_t *builder,
                                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, -1);
@@ -861,8 +861,8 @@
 /**
  This is an internal function 
 */
-AXIS2_EXTERN axis2_om_node_t* AXIS2_CALL
-axis2_om_stax_builder_get_lastnode(axis2_om_stax_builder_t *builder,
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
+axiom_stax_builder_get_lastnode(axiom_stax_builder_t *builder,
                                     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
@@ -873,10 +873,10 @@
 This is an internal function 
 */
 axis2_bool_t AXIS2_CALL
-axis2_om_stax_builder_is_complete(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_is_complete(axiom_stax_builder_t *builder,
                                    const axis2_env_t *env)
 {
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
     builder_impl = AXIS2_INTF_TO_IMPL(builder);
     return builder_impl->done;    
@@ -885,11 +885,11 @@
 This is an internal function to be used by soap builder only
 */
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_om_stax_builder_set_lastnode(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_set_lastnode(axiom_stax_builder_t *builder,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *om_node)
+                                    axiom_node_t *om_node)
 {
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     AXIS2_PARAM_CHECK(env->error, om_node, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, builder, AXIS2_FAILURE);
     
@@ -901,10 +901,10 @@
 internal function for soap builder only
 */
 AXIS2_EXTERN int AXIS2_CALL
-axis2_om_stax_builder_get_element_level(axis2_om_stax_builder_t* builder,
+axiom_stax_builder_get_element_level(axiom_stax_builder_t* builder,
                                         const axis2_env_t *env)
 {
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     AXIS2_PARAM_CHECK(env->error, builder, -1);
     builder_impl = AXIS2_INTF_TO_IMPL(builder);
     return builder_impl->element_level;    
@@ -913,11 +913,11 @@
 internal function for soap builder only
 */
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_om_stax_builder_set_element_level(axis2_om_stax_builder_t* builder,
+axiom_stax_builder_set_element_level(axiom_stax_builder_t* builder,
                                         const axis2_env_t *env,
                                         int element_level)
 {
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     AXIS2_PARAM_CHECK(env->error, builder, AXIS2_FAILURE);
     
     builder_impl = AXIS2_INTF_TO_IMPL(builder);
@@ -926,14 +926,14 @@
 } 
 
 int AXIS2_CALL 
-axis2_om_stax_builder_next_with_token(axis2_om_stax_builder_t *builder,
+axiom_stax_builder_next_with_token(axiom_stax_builder_t *builder,
                                           const axis2_env_t *env)
 {
 
     int token = 0;
     void *val = NULL;
     
-    axis2_om_stax_builder_impl_t *builder_impl = NULL;
+    axiom_stax_builder_impl_t *builder_impl = NULL;
     
     if(!builder) return -1;
     
@@ -966,7 +966,7 @@
         break;
         
         case AXIS2_XML_READER_START_ELEMENT:
-            val = axis2_om_stax_builder_create_om_element (
+            val = axiom_stax_builder_create_om_element (
                         builder, env); 
             if(!val)    
                 return -1;
@@ -974,12 +974,12 @@
             break;
         
         case AXIS2_XML_READER_EMPTY_ELEMENT:
-            val = axis2_om_stax_builder_create_om_element (
+            val = axiom_stax_builder_create_om_element (
                         builder, env);
             if(!val)
                return -1;
         case AXIS2_XML_READER_END_ELEMENT:
-            axis2_om_stax_builder_end_element (builder, env);
+            axiom_stax_builder_end_element (builder, env);
             break;
         
         
@@ -988,7 +988,7 @@
             break;
         
         case AXIS2_XML_READER_CHARACTER:
-            val = axis2_om_stax_builder_create_om_text(builder, env);
+            val = axiom_stax_builder_create_om_text(builder, env);
             if(!val)
                 return -1;
             break;
@@ -997,18 +997,18 @@
             break;
         
         case AXIS2_XML_READER_COMMENT:
-            val = axis2_om_stax_builder_create_om_comment(builder, env);
+            val = axiom_stax_builder_create_om_comment(builder, env);
             if(!val)
                 return -1;
-            axis2_om_stax_builder_end_element (builder, env);
+            axiom_stax_builder_end_element (builder, env);
             break;
         
         case AXIS2_XML_READER_PROCESSING_INSTRUCTION:
-            val = axis2_om_stax_builder_create_om_processing_instruction(
+            val = axiom_stax_builder_create_om_processing_instruction(
                                         builder , env );
             if(!val)
                 return -1;
-            axis2_om_stax_builder_end_element (builder, env);
+            axiom_stax_builder_end_element (builder, env);
             break;
         
         case AXIS2_XML_READER_CDATA:

Modified: webservices/axis2/trunk/c/axiom/src/om/om_text.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_text.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_text.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_text.c Mon Jun 12 01:22:58 2006
@@ -14,107 +14,107 @@
  * limitations under the License.
  */
 
-#include <axis2_om_text.h>
-#include <axis2_om_output.h>
+#include <axiom_text.h>
+#include <axiom_output.h>
 #include <axis2_string.h>
-#include "axis2_om_node_internal.h"
+#include "axiom_node_internal.h"
 #include <axis2_xml_writer.h>
-#include <axis2_om_output.h>
-#include <axis2_om_attribute.h>
-#include <axis2_om_namespace.h>
+#include <axiom_output.h>
+#include <axiom_attribute.h>
+#include <axiom_namespace.h>
 #include <axis2_base64.h>
 
 /* ops */
 axis2_status_t AXIS2_CALL
-axis2_om_text_free (axis2_om_text_t * om_text,
+axiom_text_free (axiom_text_t * om_text,
                     const axis2_env_t *env);
                     
                                        
 axis2_status_t AXIS2_CALL 
-axis2_om_text_serialize (axis2_om_text_t * om_text,
+axiom_text_serialize (axiom_text_t * om_text,
                          const axis2_env_t *env,
-                         axis2_om_output_t * om_output);
+                         axiom_output_t * om_output);
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_value(axis2_om_text_t *om_text,
+axiom_text_get_value(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_value(axis2_om_text_t *om_text,
+axiom_text_set_value(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_char_t *value);                                                 
 /*Following are for MTOM*/                                             
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_mime_type(axis2_om_text_t *om_text,
+axiom_text_get_mime_type(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_mime_type(axis2_om_text_t *om_text,
+axiom_text_set_mime_type(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_char_t *mime_type);
 
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_optimize(axis2_om_text_t *om_text,
+axiom_text_set_optimize(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_bool_t optimize);
                         
 axis2_bool_t AXIS2_CALL
-axis2_om_text_get_optimize(axis2_om_text_t *om_text,
+axiom_text_get_optimize(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
 axis2_bool_t AXIS2_CALL
-axis2_om_text_get_is_binary(axis2_om_text_t *om_text,
+axiom_text_get_is_binary(axiom_text_t *om_text,
                         const axis2_env_t *env);
                         
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_is_binary(axis2_om_text_t *om_text,
+axiom_text_set_is_binary(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_bool_t is_binary);
                         
 const axis2_char_t* AXIS2_CALL
-axis2_om_text_get_localname(axis2_om_text_t *om_text,
+axiom_text_get_localname(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_content_id(axis2_om_text_t *om_text,
+axiom_text_get_content_id(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_content_id(axis2_om_text_t *om_text,
+axiom_text_set_content_id(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_char_t *content_id);                        
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize_start_part(axis2_om_text_t *om_text,
+axiom_text_serialize_start_part(axiom_text_t *om_text,
                         const axis2_env_t *env,
-                        axis2_om_output_t *om_output_t);
+                        axiom_output_t *om_output_t);
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize_attribute(axis2_om_text_t *om_text,
+axiom_text_serialize_attribute(axiom_text_t *om_text,
                         const axis2_env_t *env,
-                        axis2_om_output_t *om_output, 
-                        axis2_om_attribute_t *om_attribute);
+                        axiom_output_t *om_output, 
+                        axiom_attribute_t *om_attribute);
                         
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize_namespace(axis2_om_text_t *om_text,
+axiom_text_serialize_namespace(axiom_text_t *om_text,
                         const axis2_env_t *env,
-                        const axis2_om_namespace_t *om_namespace, 
-                        axis2_om_output_t *om_output);
+                        const axiom_namespace_t *om_namespace, 
+                        axiom_output_t *om_output);
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_text(axis2_om_text_t *om_text,
+axiom_text_get_text(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
 axis2_data_handler_t *AXIS2_CALL
-axis2_om_text_get_data_handler(axis2_om_text_t *om_text,
+axiom_text_get_data_handler(axiom_text_t *om_text,
                         const axis2_env_t *env);
 
-/********************* axis2_om_text_impl_struct ***************/
+/********************* axiom_text_impl_struct ***************/
 
-typedef struct axis2_om_text_impl_t
+typedef struct axiom_text_impl_t
 {
-    axis2_om_text_t om_text;
+    axiom_text_t om_text;
     /** Text value */
     axis2_char_t *value;
     /** The following fields are for MTOM */
@@ -123,39 +123,39 @@
     const axis2_char_t *localname;
     axis2_bool_t is_binary;
     axis2_char_t *content_id;
-    axis2_om_attribute_t *om_attribute;    
-    axis2_om_namespace_t *ns;
+    axiom_attribute_t *om_attribute;    
+    axiom_namespace_t *ns;
     axis2_data_handler_t *data_handler;
-}axis2_om_text_impl_t;
+}axiom_text_impl_t;
 
 
 /*********************** Macro ***********************************/
 
-#define AXIS2_INTF_TO_IMPL(text) ((axis2_om_text_impl_t*)text)
+#define AXIS2_INTF_TO_IMPL(text) ((axiom_text_impl_t*)text)
 
 /*****************************************************************/
 
 
-AXIS2_EXTERN axis2_om_text_t* AXIS2_CALL
-axis2_om_text_create (const axis2_env_t *env,
-                      axis2_om_node_t * parent,
+AXIS2_EXTERN axiom_text_t* AXIS2_CALL
+axiom_text_create (const axis2_env_t *env,
+                      axiom_node_t * parent,
                       const axis2_char_t * value,
-                      axis2_om_node_t **node)
+                      axiom_node_t **node)
 {
 
-    axis2_om_text_impl_t *om_text = NULL;
+    axiom_text_impl_t *om_text = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, node, NULL);
 
-    *node = axis2_om_node_create (env);
+    *node = axiom_node_create (env);
 
     if (!(*node))
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    om_text = (axis2_om_text_impl_t *) AXIS2_MALLOC (env->allocator,
-                                          sizeof (axis2_om_text_impl_t));
+    om_text = (axiom_text_impl_t *) AXIS2_MALLOC (env->allocator,
+                                          sizeof (axiom_text_impl_t));
     if (!om_text)
     {
         AXIS2_FREE (env->allocator, *node);
@@ -174,24 +174,24 @@
     om_text->data_handler = NULL;
     om_text->mime_type = NULL;
 
-    om_text->ns = axis2_om_namespace_create(env, "http://www.w3.org/2004/08/xop/include", "xop");
+    om_text->ns = axiom_namespace_create(env, "http://www.w3.org/2004/08/xop/include", "xop");
 
     if (value)
         om_text->value = (axis2_char_t *) AXIS2_STRDUP(value,env);
 
-    axis2_om_node_set_data_element((*node), env, om_text);
-    axis2_om_node_set_node_type((*node), env, AXIS2_OM_TEXT);
-    axis2_om_node_set_complete((*node), env, AXIS2_FALSE);
+    axiom_node_set_data_element((*node), env, om_text);
+    axiom_node_set_node_type((*node), env, AXIOM_TEXT);
+    axiom_node_set_complete((*node), env, AXIS2_FALSE);
 
-    if (parent && AXIS2_OM_NODE_GET_NODE_TYPE(parent, env) == AXIS2_OM_ELEMENT)
+    if (parent && AXIOM_NODE_GET_NODE_TYPE(parent, env) == AXIOM_ELEMENT)
     {
-        AXIS2_OM_NODE_ADD_CHILD (parent, env, (*node));
+        AXIOM_NODE_ADD_CHILD (parent, env, (*node));
     }
 
     /* ops */
     om_text->om_text.ops = NULL;
-    om_text->om_text.ops = (axis2_om_text_ops_t *) AXIS2_MALLOC(env->allocator,
-                                              sizeof (axis2_om_text_ops_t));
+    om_text->om_text.ops = (axiom_text_ops_t *) AXIS2_MALLOC(env->allocator,
+                                              sizeof (axiom_text_ops_t));
 
     if (!om_text->om_text.ops)
     {
@@ -202,30 +202,30 @@
         return NULL;
     }
 
-    om_text->om_text.ops->free = axis2_om_text_free;
-    om_text->om_text.ops->serialize = axis2_om_text_serialize;
-    om_text->om_text.ops->set_value = axis2_om_text_set_value;
-    om_text->om_text.ops->get_value = axis2_om_text_get_value;
-    om_text->om_text.ops->get_data_handler = axis2_om_text_get_data_handler;
-    om_text->om_text.ops->get_content_id = axis2_om_text_get_content_id;
-    om_text->om_text.ops->set_optimize = axis2_om_text_set_optimize;
-    om_text->om_text.ops->set_is_binary = axis2_om_text_set_is_binary;
+    om_text->om_text.ops->free = axiom_text_free;
+    om_text->om_text.ops->serialize = axiom_text_serialize;
+    om_text->om_text.ops->set_value = axiom_text_set_value;
+    om_text->om_text.ops->get_value = axiom_text_get_value;
+    om_text->om_text.ops->get_data_handler = axiom_text_get_data_handler;
+    om_text->om_text.ops->get_content_id = axiom_text_get_content_id;
+    om_text->om_text.ops->set_optimize = axiom_text_set_optimize;
+    om_text->om_text.ops->set_is_binary = axiom_text_set_is_binary;
     
     return &(om_text->om_text);
 }
 
-AXIS2_EXTERN axis2_om_text_t* AXIS2_CALL
-axis2_om_text_create_with_data_handler (const axis2_env_t *env,
-                      axis2_om_node_t * parent,
+AXIS2_EXTERN axiom_text_t* AXIS2_CALL
+axiom_text_create_with_data_handler (const axis2_env_t *env,
+                      axiom_node_t * parent,
                       axis2_data_handler_t* data_handler,
-                      axis2_om_node_t **node)
+                      axiom_node_t **node)
 {
 
-    axis2_om_text_impl_t *om_text_impl = NULL;
+    axiom_text_impl_t *om_text_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, data_handler, NULL);
 
-    om_text_impl = (axis2_om_text_impl_t*)axis2_om_text_create(env, parent, NULL, node);
+    om_text_impl = (axiom_text_impl_t*)axiom_text_create(env, parent, NULL, node);
     if (!om_text_impl)
         return NULL;
     om_text_impl->optimize = AXIS2_TRUE;
@@ -235,10 +235,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_free (axis2_om_text_t * om_text,
+axiom_text_free (axiom_text_t * om_text,
                     const axis2_env_t *env)
 {
-    axis2_om_text_impl_t *text_impl = NULL;
+    axiom_text_impl_t *text_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
     text_impl = AXIS2_INTF_TO_IMPL(om_text);
@@ -250,7 +250,7 @@
 
     if (NULL != text_impl->ns)
     {
-        AXIS2_OM_NAMESPACE_FREE(text_impl->ns, env);
+        AXIOM_NAMESPACE_FREE(text_impl->ns, env);
         text_impl->ns = NULL;
     }
     
@@ -271,12 +271,12 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize (axis2_om_text_t *om_text,
+axiom_text_serialize (axiom_text_t *om_text,
                          const axis2_env_t *env,
-                         axis2_om_output_t *om_output)
+                         axiom_output_t *om_output)
 {
     int status = AXIS2_SUCCESS;
-    axis2_om_text_impl_t *om_text_impl = NULL;
+    axiom_text_impl_t *om_text_impl = NULL;
     axis2_char_t *attribute_value = NULL;
     axis2_char_t *text = NULL;
     axis2_xml_writer_t *om_output_xml_writer = NULL;
@@ -285,37 +285,37 @@
     AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
     om_text_impl = AXIS2_INTF_TO_IMPL(om_text);
 
-    if(!axis2_om_text_get_is_binary(om_text, env))
+    if(!axiom_text_get_is_binary(om_text, env))
     {
         if (AXIS2_INTF_TO_IMPL(om_text)->value)
-            status = axis2_om_output_write (om_output, env,
-                                        AXIS2_OM_TEXT, 1,
+            status = axiom_output_write (om_output, env,
+                                        AXIOM_TEXT, 1,
                                         AXIS2_INTF_TO_IMPL(om_text)->value);
     }
     else
     {
-        om_output_xml_writer = AXIS2_OM_OUTPUT_GET_XML_WRITER(om_output, env);
+        om_output_xml_writer = AXIOM_OUTPUT_GET_XML_WRITER(om_output, env);
         if(om_text_impl->optimize)
         {
-            if(axis2_om_text_get_content_id(om_text, env) == NULL)
+            if(axiom_text_get_content_id(om_text, env) == NULL)
             {
-                axis2_char_t *content_id = AXIS2_OM_OUTPUT_GET_NEXT_CONTENT_ID(om_output, env);
+                axis2_char_t *content_id = AXIOM_OUTPUT_GET_NEXT_CONTENT_ID(om_output, env);
                 if (content_id)
                     om_text_impl->content_id = AXIS2_STRDUP(content_id, env);
             }    
             attribute_value = AXIS2_STRDUP("cid:", env);
             attribute_value = AXIS2_STRACAT(attribute_value, om_text_impl->content_id, env);
             /*send binary as MTOM optimised*/
-            om_text_impl->om_attribute = axis2_om_attribute_create(env, "href", attribute_value, NULL);
-            axis2_om_text_serialize_start_part(om_text, env, om_output);
+            om_text_impl->om_attribute = axiom_attribute_create(env, "href", attribute_value, NULL);
+            axiom_text_serialize_start_part(om_text, env, om_output);
             
-            axis2_om_output_write_optimized(om_output, env, om_text);            
+            axiom_output_write_optimized(om_output, env, om_text);            
             
-            axis2_om_output_write (om_output, env, AXIS2_OM_ELEMENT, 0);
+            axiom_output_write (om_output, env, AXIOM_ELEMENT, 0);
         }
         else
         {
-            text = axis2_om_text_get_text(om_text, env);
+            text = axiom_text_get_text(om_text, env);
             AXIS2_XML_WRITER_WRITE_CHARACTERS(om_output_xml_writer, env, text);
         }
     }
@@ -323,7 +323,7 @@
 }
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_value(axis2_om_text_t *om_text,
+axiom_text_get_value(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,NULL);
@@ -331,11 +331,11 @@
 }                        
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_value(axis2_om_text_t *om_text,
+axiom_text_set_value(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_char_t *value)
 {
-    axis2_om_text_impl_t *text_impl = NULL;
+    axiom_text_impl_t *text_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
@@ -361,7 +361,7 @@
 /*Following has been implemented for the MTOM support*/
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_mime_type(axis2_om_text_t *om_text,
+axiom_text_get_mime_type(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,NULL);
@@ -369,7 +369,7 @@
 }                        
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_mime_type(axis2_om_text_t *om_text,
+axiom_text_set_mime_type(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_char_t *mime_type)
 {
@@ -383,7 +383,7 @@
 
 
 axis2_bool_t AXIS2_CALL
-axis2_om_text_get_optimize(axis2_om_text_t *om_text,
+axiom_text_get_optimize(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,AXIS2_FAILURE);
@@ -391,7 +391,7 @@
 }                        
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_optimize(axis2_om_text_t *om_text,
+axiom_text_set_optimize(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_bool_t optimize)
 {
@@ -403,7 +403,7 @@
 
 
 axis2_bool_t AXIS2_CALL
-axis2_om_text_get_is_binary(axis2_om_text_t *om_text,
+axiom_text_get_is_binary(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,AXIS2_FAILURE);
@@ -411,7 +411,7 @@
 }                        
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_is_binary(axis2_om_text_t *om_text,
+axiom_text_set_is_binary(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_bool_t is_binary)
 {
@@ -422,7 +422,7 @@
 }
 
 const axis2_char_t* AXIS2_CALL
-axis2_om_text_get_localname(axis2_om_text_t *om_text,
+axiom_text_get_localname(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,NULL);
@@ -430,7 +430,7 @@
 }                        
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_content_id(axis2_om_text_t *om_text,
+axiom_text_get_content_id(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,NULL);
@@ -438,7 +438,7 @@
 }                        
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_set_content_id(axis2_om_text_t *om_text,
+axiom_text_set_content_id(axiom_text_t *om_text,
                         const axis2_env_t *env,
                         const axis2_char_t *content_id)
 {
@@ -451,65 +451,65 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize_start_part(axis2_om_text_t *om_text,
+axiom_text_serialize_start_part(axiom_text_t *om_text,
                         const axis2_env_t *env,
-                        axis2_om_output_t *om_output)
+                        axiom_output_t *om_output)
 {
-    axis2_om_text_impl_t *om_text_impl = NULL;
+    axiom_text_impl_t *om_text_impl = NULL;
     axis2_char_t *namespace_uri = NULL;
     axis2_char_t *prefix = NULL;
     const axis2_char_t *local_name = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     om_text_impl = AXIS2_INTF_TO_IMPL(om_text);
-    local_name = axis2_om_text_get_localname(om_text, env);    
+    local_name = axiom_text_get_localname(om_text, env);    
     
     if (om_text_impl->ns != NULL)
     {
-        namespace_uri = AXIS2_OM_NAMESPACE_GET_URI(om_text_impl->ns, env);
+        namespace_uri = AXIOM_NAMESPACE_GET_URI(om_text_impl->ns, env);
         if (namespace_uri != NULL) 
         {
-            prefix = AXIS2_OM_NAMESPACE_GET_PREFIX(om_text_impl->ns, env);
+            prefix = AXIOM_NAMESPACE_GET_PREFIX(om_text_impl->ns, env);
 
             if(prefix != NULL)
             {
-                axis2_om_output_write (om_output, env, AXIS2_OM_ELEMENT, 3,
+                axiom_output_write (om_output, env, AXIOM_ELEMENT, 3,
                             local_name, namespace_uri, prefix);
             }
             else
             {
-                axis2_om_output_write (om_output, env, AXIS2_OM_ELEMENT, 2,
+                axiom_output_write (om_output, env, AXIOM_ELEMENT, 2,
                             local_name, namespace_uri);
             }
         }
         else
         {
-            axis2_om_output_write (om_output, env, AXIS2_OM_ELEMENT, 1,
+            axiom_output_write (om_output, env, AXIOM_ELEMENT, 1,
                             local_name);
         }            
     }
     else
     {
-        axis2_om_output_write (om_output, env, AXIS2_OM_TEXT, 1,
+        axiom_output_write (om_output, env, AXIOM_TEXT, 1,
                             local_name);
     }
     if (om_text_impl->om_attribute)
-        AXIS2_OM_ATTRIBUTE_SERIALIZE(om_text_impl->om_attribute, env, om_output);
+        AXIOM_ATTRIBUTE_SERIALIZE(om_text_impl->om_attribute, env, om_output);
     if (om_text_impl->ns)
-        AXIS2_OM_NAMESPACE_SERIALIZE(om_text_impl->ns, env, om_output);
+        AXIOM_NAMESPACE_SERIALIZE(om_text_impl->ns, env, om_output);
     
     return AXIS2_SUCCESS;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize_attribute(axis2_om_text_t *om_text,
+axiom_text_serialize_attribute(axiom_text_t *om_text,
                         const axis2_env_t *env,
-                        axis2_om_output_t *om_output, 
-                        axis2_om_attribute_t *om_attribute)
+                        axiom_output_t *om_output, 
+                        axiom_attribute_t *om_attribute)
 {
     axis2_xml_writer_t *xml_writer = NULL;
-    axis2_om_namespace_t *om_namespace = NULL;
+    axiom_namespace_t *om_namespace = NULL;
     
-    axis2_om_text_impl_t *om_text_impl = NULL;
+    axiom_text_impl_t *om_text_impl = NULL;
     axis2_char_t *namespace_uri = NULL;
     axis2_char_t *prefix = NULL;
     axis2_char_t *attribute_local_name = NULL;
@@ -519,17 +519,17 @@
     
     xml_writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
             AXIS2_XML_PARSER_TYPE_BUFFER);
-    om_namespace = axis2_om_namespace_create(env, "" , "");
+    om_namespace = axiom_namespace_create(env, "" , "");
     om_text_impl = AXIS2_INTF_TO_IMPL(om_text);
 
-    namespace_uri = AXIS2_OM_NAMESPACE_GET_URI(om_text_impl->ns, env);
-    attribute_local_name = AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(om_attribute, env);
+    namespace_uri = AXIOM_NAMESPACE_GET_URI(om_text_impl->ns, env);
+    attribute_local_name = AXIOM_ATTRIBUTE_GET_LOCALNAME(om_attribute, env);
     
 
     if (om_namespace != NULL) 
     {
-        prefix = AXIS2_OM_NAMESPACE_GET_PREFIX(om_text_impl->ns, env);    
-        attribute_value = AXIS2_OM_ATTRIBUTE_GET_VALUE(om_attribute, env);
+        prefix = AXIOM_NAMESPACE_GET_PREFIX(om_text_impl->ns, env);    
+        attribute_value = AXIOM_ATTRIBUTE_GET_VALUE(om_attribute, env);
         if (prefix != NULL) 
         {
             AXIS2_XML_WRITER_WRITE_ATTRIBUTE(xml_writer, env, attribute_local_name, attribute_value);
@@ -539,18 +539,18 @@
     } else {
         AXIS2_XML_WRITER_WRITE_ATTRIBUTE(xml_writer, env, attribute_local_name, attribute_value);
     }
-    AXIS2_OM_NAMESPACE_FREE(om_namespace, env);
+    AXIOM_NAMESPACE_FREE(om_namespace, env);
     return AXIS2_SUCCESS;    
 }
 
 axis2_status_t AXIS2_CALL
-axis2_om_text_serialize_namespace(axis2_om_text_t *om_text,
+axiom_text_serialize_namespace(axiom_text_t *om_text,
                         const axis2_env_t *env,
-                        const axis2_om_namespace_t *om_namespace, 
-                        axis2_om_output_t *om_output)
+                        const axiom_namespace_t *om_namespace, 
+                        axiom_output_t *om_output)
 {
     axis2_xml_writer_t *xml_writer = NULL;
-    axis2_om_text_impl_t *om_text_impl = NULL;
+    axiom_text_impl_t *om_text_impl = NULL;
     axis2_char_t *namespace_uri = NULL;
     axis2_char_t *namespace_prefix = NULL;
     
@@ -558,13 +558,13 @@
     
     xml_writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
                AXIS2_XML_PARSER_TYPE_BUFFER);
-    om_namespace = axis2_om_namespace_create(env, "" , "");
+    om_namespace = axiom_namespace_create(env, "" , "");
     om_text_impl = AXIS2_INTF_TO_IMPL(om_text);
 
     if (om_namespace != NULL) 
     {
-        namespace_uri = AXIS2_OM_NAMESPACE_GET_URI(om_text_impl->ns, env);
-        namespace_prefix = AXIS2_OM_NAMESPACE_GET_PREFIX(om_text_impl->ns, env);    
+        namespace_uri = AXIOM_NAMESPACE_GET_URI(om_text_impl->ns, env);
+        namespace_prefix = AXIOM_NAMESPACE_GET_PREFIX(om_text_impl->ns, env);    
         AXIS2_XML_WRITER_WRITE_NAMESPACE(xml_writer, env, namespace_prefix, namespace_uri);
         AXIS2_XML_WRITER_SET_PREFIX(xml_writer, env, namespace_prefix, namespace_uri);  
     }
@@ -572,10 +572,10 @@
 }
 
 axis2_char_t* AXIS2_CALL
-axis2_om_text_get_text(axis2_om_text_t *om_text,
+axiom_text_get_text(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
-    axis2_om_text_impl_t *om_text_impl = NULL;
+    axiom_text_impl_t *om_text_impl = NULL;
     AXIS2_ENV_CHECK(env,NULL);
 
     om_text_impl = AXIS2_INTF_TO_IMPL(om_text);
@@ -611,7 +611,7 @@
 }
 
 axis2_data_handler_t *AXIS2_CALL
-axis2_om_text_get_data_handler(axis2_om_text_t *om_text,
+axiom_text_get_data_handler(axiom_text_t *om_text,
                         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env,NULL);

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_body.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_body.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_body.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_body.h Mon Jun 12 01:22:58 2006
@@ -40,7 +40,7 @@
 axis2_status_t AXIS2_CALL
 axis2_soap_body_set_base_node(axis2_soap_body_t *body,
                               const axis2_env_t *env,
-                              axis2_om_node_t *om_node);  
+                              axiom_node_t *om_node);  
 axis2_status_t AXIS2_CALL 
 axis2_soap_body_set_builder(axis2_soap_body_t *body,
                             const axis2_env_t *env,

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_envelope.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_envelope.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_envelope.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_envelope.h Mon Jun 12 01:22:58 2006
@@ -42,7 +42,7 @@
 axis2_status_t AXIS2_CALL
 axis2_soap_envelope_set_base_node(axis2_soap_envelope_t *envelope,
                                   const axis2_env_t *env,
-                                  axis2_om_node_t *om_node);  
+                                  axiom_node_t *om_node);  
   
 axis2_status_t AXIS2_CALL 
 axis2_soap_envelope_set_body(axis2_soap_envelope_t *envelope,

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault.h Mon Jun 12 01:22:58 2006
@@ -61,7 +61,7 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap_fault_set_base_node(axis2_soap_fault_t *fault,
                                const axis2_env_t *env,
-                               axis2_om_node_t *node);
+                               axiom_node_t *node);
 
 axis2_status_t AXIS2_CALL 
 axis2_soap_fault_set_builder(axis2_soap_fault_t *fault,

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_code.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_code.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_code.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_code.h Mon Jun 12 01:22:58 2006
@@ -49,7 +49,7 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap_fault_code_set_base_node(axis2_soap_fault_code_t *fault_code,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *node);
+                                    axiom_node_t *node);
 axis2_status_t AXIS2_CALL
 axis2_soap_fault_code_set_builder(axis2_soap_fault_code_t *fault_code,
                                   const axis2_env_t *env,

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_detail.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_detail.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_detail.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_detail.h Mon Jun 12 01:22:58 2006
@@ -43,7 +43,7 @@
 axis2_soap_fault_detail_set_base_node
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env,
-                         axis2_om_node_t *node);
+                         axiom_node_t *node);
     
 AXIS2_EXTERN axis2_soap_fault_detail_t * AXIS2_CALL
 axis2_soap_fault_detail_create(const axis2_env_t *env);    

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_node.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_node.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_node.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_node.h Mon Jun 12 01:22:58 2006
@@ -42,7 +42,7 @@
 axis2_soap_fault_node_set_base_node
                           (axis2_soap_fault_node_t *fault_node,
                            const axis2_env_t *env,
-                           axis2_om_node_t *node);
+                           axiom_node_t *node);
 
 AXIS2_EXTERN axis2_soap_fault_node_t * AXIS2_CALL
 axis2_soap_fault_node_create(const axis2_env_t *env);

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_reason.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_reason.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_reason.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_reason.h Mon Jun 12 01:22:58 2006
@@ -48,7 +48,7 @@
 axis2_soap_fault_reason_set_base_node
                                 (axis2_soap_fault_reason_t *fault_reason,
                                  const axis2_env_t *env,
-                                 axis2_om_node_t *node);   
+                                 axiom_node_t *node);   
     
 axis2_status_t AXIS2_CALL 
 axis2_soap_fault_reason_set_soap_fault_text

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_role.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_role.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_role.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_role.h Mon Jun 12 01:22:58 2006
@@ -42,7 +42,7 @@
 axis2_soap_fault_role_set_base_node
                             (axis2_soap_fault_role_t *fault_role,
                              const axis2_env_t *env,
-                             axis2_om_node_t *node);
+                             axiom_node_t *node);
     
 AXIS2_EXTERN axis2_soap_fault_role_t * AXIS2_CALL
 axis2_soap_fault_role_create(const axis2_env_t *env);

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_sub_code.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_sub_code.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_sub_code.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_sub_code.h Mon Jun 12 01:22:58 2006
@@ -53,7 +53,7 @@
 axis2_soap_fault_sub_code_set_base_node
                              (axis2_soap_fault_sub_code_t *fault_sub_code,
                               const axis2_env_t *env,
-                              axis2_om_node_t *node);
+                              axiom_node_t *node);
 
 axis2_status_t AXIS2_CALL
 axis2_soap_fault_sub_code_set_builder(

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_text.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_text.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_text.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_text.h Mon Jun 12 01:22:58 2006
@@ -41,7 +41,7 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap_fault_text_set_base_node(axis2_soap_fault_text_t *fault_text,
                                       const axis2_env_t *env,
-                                      axis2_om_node_t *node);
+                                      axiom_node_t *node);
 
 AXIS2_EXTERN axis2_soap_fault_text_t * AXIS2_CALL
 axis2_soap_fault_text_create(const axis2_env_t *env);

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_value.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_value.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_value.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_fault_value.h Mon Jun 12 01:22:58 2006
@@ -41,7 +41,7 @@
 axis2_status_t AXIS2_CALL
 axis2_soap_fault_value_set_base_node(axis2_soap_fault_value_t *fault_value,
                                   const axis2_env_t *env,
-                                  axis2_om_node_t *node);
+                                  axiom_node_t *node);
 
 AXIS2_EXTERN axis2_soap_fault_value_t * AXIS2_CALL
 axis2_soap_fault_value_create(const axis2_env_t *env);    

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header.h Mon Jun 12 01:22:58 2006
@@ -41,7 +41,7 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap_header_set_base_node(axis2_soap_header_t *header,
                                 const axis2_env_t *env,
-                                axis2_om_node_t *node);
+                                axiom_node_t *node);
 
 axis2_status_t AXIS2_CALL 
 axis2_soap_header_set_soap_version(axis2_soap_header_t *header,

Modified: webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header_block.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header_block.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header_block.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/_axis2_soap_header_block.h Mon Jun 12 01:22:58 2006
@@ -47,7 +47,7 @@
 axis2_soap_header_block_set_base_node
                         (axis2_soap_header_block_t *header_block,
                          const axis2_env_t *env,
-                         axis2_om_node_t *node);
+                         axiom_node_t *node);
     
 AXIS2_EXTERN axis2_soap_header_block_t * AXIS2_CALL
 axis2_soap_header_block_create(const axis2_env_t *env);

Modified: webservices/axis2/trunk/c/axiom/src/soap/axis2_soap11_builder_helper.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/axis2_soap11_builder_helper.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/axis2_soap11_builder_helper.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/axis2_soap11_builder_helper.h Mon Jun 12 01:22:58 2006
@@ -52,7 +52,7 @@
         axis2_status_t (AXIS2_CALL *handle_event)
                     (axis2_soap11_builder_helper_t *builder_helper,
                      const axis2_env_t *env,
-                     axis2_om_node_t *om_element_node,
+                     axiom_node_t *om_element_node,
                      int element_level);
     };                                                      
 
@@ -71,7 +71,7 @@
 AXIS2_EXTERN axis2_soap11_builder_helper_t* AXIS2_CALL
 axis2_soap11_builder_helper_create(const axis2_env_t *env, 
                                    axis2_soap_builder_t *soap_builder,
-                                   axis2_om_stax_builder_t *om_builder);
+                                   axiom_stax_builder_t *om_builder);
     
 /******************** Macros **************************************************/
     

Modified: webservices/axis2/trunk/c/axiom/src/soap/axis2_soap12_builder_helper.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/axis2_soap12_builder_helper.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/axis2_soap12_builder_helper.h (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/axis2_soap12_builder_helper.h Mon Jun 12 01:22:58 2006
@@ -51,7 +51,7 @@
         axis2_status_t (AXIS2_CALL *handle_event)
                     (axis2_soap12_builder_helper_t *builder_helper,
                      const axis2_env_t *env,
-                     axis2_om_node_t *om_element_node,
+                     axiom_node_t *om_element_node,
                      int element_level);
     };                                                      
 

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap11_builder_helper.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap11_builder_helper.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap11_builder_helper.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap11_builder_helper.c Mon Jun 12 01:22:58 2006
@@ -15,7 +15,7 @@
  */
  
  #include "axis2_soap11_builder_helper.h"
- #include <axis2_om_stax_builder.h>
+ #include <axiom_stax_builder.h>
  #include <axis2_soap_builder.h>
  #include <axis2_soap_const.h>
  #include "_axis2_soap_fault_code.h"
@@ -26,8 +26,8 @@
  #include "_axis2_soap_fault_detail.h"
  #include <axis2_soap_fault_text.h>
  #include "_axis2_soap_fault_role.h"
- #include <axis2_om_stax_builder_internal.h>
- #include <axis2_om_node_internal.h>
+ #include <axiom_stax_builder_internal.h>
+ #include <axiom_node_internal.h>
  
 typedef struct axis2_soap11_builder_helper_impl_t
 {
@@ -39,9 +39,9 @@
     
     axis2_bool_t fault_string_present;
     
-    axis2_om_stax_builder_t *om_builder;
+    axiom_stax_builder_t *om_builder;
     
-    axis2_om_node_t *last_processed_node;
+    axiom_node_t *last_processed_node;
     
 }axis2_soap11_builder_helper_impl_t;
  
@@ -59,7 +59,7 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap11_builder_helper_handle_event (axis2_soap11_builder_helper_t *builder_helper,
                              const axis2_env_t *env,
-                             axis2_om_node_t *om_element_node,
+                             axiom_node_t *om_element_node,
                              int element_level);
                              
 static axis2_status_t 
@@ -71,7 +71,7 @@
 AXIS2_EXTERN axis2_soap11_builder_helper_t* AXIS2_CALL
 axis2_soap11_builder_helper_create(const axis2_env_t *env, 
                                    axis2_soap_builder_t *soap_builder,
-                                   axis2_om_stax_builder_t *om_builder)
+                                   axiom_stax_builder_t *om_builder)
 {
     axis2_soap11_builder_helper_impl_t *builder_helper_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -136,11 +136,11 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap11_builder_helper_handle_event (axis2_soap11_builder_helper_t *builder_helper,
                              const axis2_env_t *env,
-                             axis2_om_node_t *om_element_node,
+                             axiom_node_t *om_element_node,
                              int element_level)
 {
     axis2_soap11_builder_helper_impl_t *builder_helper_impl = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     axis2_char_t *ele_localname = NULL;
     axis2_soap_envelope_t *soap_envelope = NULL;
     axis2_soap_body_t *soap_body = NULL;
@@ -150,9 +150,9 @@
     AXIS2_PARAM_CHECK(env->error, om_element_node, AXIS2_FAILURE);
     builder_helper_impl = AXIS2_INTF_TO_IMPL(builder_helper);
       
-    om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(om_element_node, env);
+    om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(om_element_node, env);
     
-    ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+    ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
     if(!ele_localname)
     {
         return AXIS2_FAILURE;
@@ -182,8 +182,8 @@
     {
         axis2_soap_fault_code_t *fault_code = NULL;
         axis2_soap_fault_value_t *fault_value = NULL;
-        axis2_om_node_t *fault_value_node = NULL;
-        axis2_om_element_t *fault_value_ele  = NULL;
+        axiom_node_t *fault_value_node = NULL;
+        axiom_element_t *fault_value_ele  = NULL;
         
         if(AXIS2_STRCMP(ele_localname, AXIS2_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME) == 0)
         {   
@@ -205,7 +205,7 @@
             
             axis2_soap_fault_code_set_builder (fault_code, env, builder_helper_impl->soap_builder);
             
-            AXIS2_OM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME);
+            AXIOM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME);
                         
             fault_value = axis2_soap_fault_value_create_with_code(env, fault_code);
             if(!fault_value)
@@ -215,10 +215,10 @@
             if(!fault_value_node)
                 return AXIS2_FAILURE;
                 
-            fault_value_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+            fault_value_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                                 fault_value_node, env);
 
-            axis2_om_stax_builder_set_lastnode(builder_helper_impl->om_builder,
+            axiom_stax_builder_set_lastnode(builder_helper_impl->om_builder,
                                                 env, fault_value_node); 
             
             status = axis2_soap11_builder_helper_process_text(builder_helper, env);
@@ -226,11 +226,11 @@
             {
                 return AXIS2_FAILURE;
             }
-            axis2_om_stax_builder_set_lastnode(builder_helper_impl->om_builder,
+            axiom_stax_builder_set_lastnode(builder_helper_impl->om_builder,
                                                 env, om_element_node); 
-            axis2_om_node_set_complete(om_element_node, env, AXIS2_TRUE); 
+            axiom_node_set_complete(om_element_node, env, AXIS2_TRUE); 
             
-            axis2_om_stax_builder_set_element_level(builder_helper_impl->om_builder, 
+            axiom_stax_builder_set_element_level(builder_helper_impl->om_builder, 
                     env, (element_level-1));
             builder_helper_impl->fault_code_present = AXIS2_TRUE;                        
         }
@@ -239,7 +239,7 @@
             
             axis2_soap_fault_reason_t *fault_reason = NULL;
             axis2_soap_fault_text_t *fault_text = NULL;
-            axis2_om_node_t *fault_text_node = NULL;
+            axiom_node_t *fault_text_node = NULL;
             int status = AXIS2_SUCCESS;
             if(builder_helper_impl->fault_code_present)
             {
@@ -247,7 +247,7 @@
                     builder_helper_impl->soap_builder, env, AXIS2_FALSE);
             }
             
-            AXIS2_OM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME);
+            AXIOM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME);
             
             fault_reason = axis2_soap_fault_reason_create(env);
             if(!fault_reason)
@@ -266,17 +266,17 @@
                 return AXIS2_FAILURE;
                 
             /* TODO process namespace data */
-            axis2_om_stax_builder_set_lastnode(builder_helper_impl->om_builder, env, fault_text_node);
+            axiom_stax_builder_set_lastnode(builder_helper_impl->om_builder, env, fault_text_node);
             
             status = axis2_soap11_builder_helper_process_text(builder_helper, env);
             if(status == AXIS2_FAILURE)
                 return AXIS2_FAILURE;
             
-            axis2_om_stax_builder_set_lastnode(builder_helper_impl->om_builder, env, om_element_node);
+            axiom_stax_builder_set_lastnode(builder_helper_impl->om_builder, env, om_element_node);
             
-            axis2_om_node_set_complete(om_element_node, env, AXIS2_TRUE);
+            axiom_node_set_complete(om_element_node, env, AXIS2_TRUE);
             
-            axis2_om_stax_builder_set_element_level(builder_helper_impl->om_builder, 
+            axiom_stax_builder_set_element_level(builder_helper_impl->om_builder, 
                 env , (element_level -1));
          
             builder_helper_impl->fault_string_present = AXIS2_TRUE;   
@@ -288,7 +288,7 @@
             if(!fault_role)
                 return AXIS2_FAILURE;
             
-            AXIS2_OM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME);
+            AXIOM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME);
 
             axis2_soap_fault_role_set_base_node (fault_role, env, om_element_node);
             
@@ -307,7 +307,7 @@
             if(!fault_detail)
                 return AXIS2_FAILURE;
                 
-            AXIS2_OM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME);
+            AXIOM_ELEMENT_SET_LOCALNAME(om_ele, env, AXIS2_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME);
             
             axis2_soap_fault_detail_set_base_node(fault_detail, env, om_element_node);
             
@@ -320,16 +320,16 @@
     }
     else if(element_level == 5)
     {
-        axis2_om_node_t *parent_node = NULL;
-        axis2_om_element_t *parent_element = NULL;
+        axiom_node_t *parent_node = NULL;
+        axiom_element_t *parent_element = NULL;
         axis2_char_t *parent_localname = NULL;
 
-        parent_node = AXIS2_OM_NODE_GET_PARENT(om_element_node, env);
+        parent_node = AXIOM_NODE_GET_PARENT(om_element_node, env);
         if(!parent_node)
             return AXIS2_FAILURE;                
-        parent_element = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+        parent_element = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                             om_element_node, env);
-        parent_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(parent_element, env);
+        parent_localname = AXIOM_ELEMENT_GET_LOCALNAME(parent_element, env);
         
         if(!parent_localname)
             return AXIS2_FAILURE;
@@ -352,7 +352,7 @@
 
     builder_helper_impl = AXIS2_INTF_TO_IMPL(builder_helper);
 
-    token = AXIS2_OM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_helper_impl->om_builder, env);
+    token = AXIOM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_helper_impl->om_builder, env);
 
     if(token == -1)
         return AXIS2_FAILURE;
@@ -366,7 +366,7 @@
             return AXIS2_FAILURE;                
         
         }
-        token = AXIS2_OM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_helper_impl->om_builder, env);    
+        token = AXIOM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_helper_impl->om_builder, env);    
         if(token == -1)
             return AXIS2_FAILURE;
     }



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message