You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by da...@apache.org on 2006/06/12 10:23:02 UTC

svn commit: r413605 [8/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/

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap12_builder_helper.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap12_builder_helper.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap12_builder_helper.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap12_builder_helper.c Mon Jun 12 01:22:58 2006
@@ -80,7 +80,7 @@
 axis2_soap12_builder_helper_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);
                              
 /******************** function implementations ********************************/
@@ -163,13 +163,13 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap12_builder_helper_handle_event (axis2_soap12_builder_helper_t *builder_helper,
                              const axis2_env_t *env,
-                             axis2_om_node_t *om_ele_node,
+                             axiom_node_t *om_ele_node,
                              int element_level)
 {
     axis2_soap12_builder_helper_impl_t *builder_helper_impl = NULL;
     
     axis2_char_t* ele_localname = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     
     axis2_soap_body_t *soap_body = NULL;
     axis2_soap_fault_t *soap_fault = NULL;
@@ -179,11 +179,11 @@
     AXIS2_PARAM_CHECK(env->error, om_ele_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_ele_node, env);
+    om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(om_ele_node, env);
     if(!om_ele)
         return AXIS2_FAILURE;
         
-    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;
     
@@ -416,18 +416,18 @@
     }
     else if(element_level == 5)
     {
-        axis2_om_node_t *parent_node = NULL;
-        axis2_om_element_t *parent_ele = NULL;
+        axiom_node_t *parent_node = NULL;
+        axiom_element_t *parent_ele = NULL;
         axis2_char_t *parent_localname = NULL;
-        parent_node = AXIS2_OM_NODE_GET_PARENT(om_ele_node, env);
+        parent_node = AXIOM_NODE_GET_PARENT(om_ele_node, env);
         if(!parent_node)
             return AXIS2_FAILURE;
        
-        parent_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(parent_node, env);
+        parent_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(parent_node, env);
         if(!parent_ele)
             return AXIS2_FAILURE;
 
-        parent_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(parent_ele, env);
+        parent_localname = AXIOM_ELEMENT_GET_LOCALNAME(parent_ele, env);
         if(!parent_localname)
             return AXIS2_FAILURE;
             
@@ -533,7 +533,7 @@
                     
                 AXIS2_SOAP_FAULT_REASON_ADD_SOAP_FAULT_TEXT (fault_reason, env, soap_fault_text);
                 /*****************
-                AXIS2_OM_NODE_SET_BUILD_STATUS(om_ele_node, env, AXIS2_FALSE);
+                AXIOM_NODE_SET_BUILD_STATUS(om_ele_node, env, AXIS2_FALSE);
                 ******************/
                 builder_helper_impl->reason_processing = AXIS2_FALSE;
                 
@@ -566,19 +566,19 @@
                 
     }else if(element_level > 5)
     {
-        axis2_om_node_t *parent_node = NULL;
-        axis2_om_element_t *parent_ele = NULL;
+        axiom_node_t *parent_node = NULL;
+        axiom_element_t *parent_ele = NULL;
         axis2_char_t *parent_localname = NULL;
         
-        parent_node = AXIS2_OM_NODE_GET_PARENT(om_ele_node, env);
+        parent_node = AXIOM_NODE_GET_PARENT(om_ele_node, env);
         if(!parent_node)
             return AXIS2_FAILURE;
                
-        parent_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(parent_node, env);
+        parent_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(parent_node, env);
         if(!parent_ele)
             return AXIS2_FAILURE;
             
-        parent_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(parent_ele, env);   
+        parent_localname = AXIOM_ELEMENT_GET_LOCALNAME(parent_ele, env);   
         if(!parent_localname)
             return AXIS2_FAILURE;
 

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_body.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_body.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_body.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_body.c Mon Jun 12 01:22:58 2006
@@ -25,7 +25,7 @@
  {
     axis2_soap_body_t soap_body;
     
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     
     axis2_bool_t has_fault;
     
@@ -60,7 +60,7 @@
                           const axis2_env_t *env,
                           axis2_soap_fault_t *soap_fault);
                           
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_body_get_base_node(axis2_soap_body_t *body,
                               const axis2_env_t *env);
                               
@@ -74,7 +74,7 @@
 axis2_status_t AXIS2_CALL
 axis2_soap_body_add_child(axis2_soap_body_t *body,
                           const axis2_env_t *env,
-                          axis2_om_node_t *child);
+                          axiom_node_t *child);
                           
 int AXIS2_CALL
 axis2_soap_body_get_soap_version(axis2_soap_body_t *body,
@@ -149,10 +149,10 @@
 {
     axis2_soap_body_impl_t *body_impl = NULL;
     axis2_soap_body_t *body = NULL;
-    axis2_om_element_t *ele = NULL;
-    axis2_om_node_t *parent_node = NULL;
-    axis2_om_element_t *parent_ele =  NULL;
-    axis2_om_namespace_t *om_ns = NULL;
+    axiom_element_t *ele = NULL;
+    axiom_node_t *parent_node = NULL;
+    axiom_element_t *parent_ele =  NULL;
+    axiom_namespace_t *om_ns = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, envelope, NULL);
@@ -172,7 +172,7 @@
         AXIS2_SOAP_BODY_FREE(body, env);
         return NULL;        
     }
-    parent_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    parent_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                         parent_node, env);
 
     if(!parent_ele)
@@ -181,9 +181,9 @@
         return NULL;        
     }  
     
-    om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
+    om_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
 
-    ele = axis2_om_element_create(env, parent_node, 
+    ele = axiom_element_create(env, parent_node, 
                                   AXIS2_SOAP_BODY_LOCAL_NAME, om_ns, 
                                   &(body_impl->om_ele_node));
     if (!ele)
@@ -245,7 +245,7 @@
     else{
         if(NULL != body_impl->soap_builder )
         {
-            while(!(body_impl->soap_fault) && !(AXIS2_OM_NODE_IS_COMPLETE(body_impl->om_ele_node, env)))
+            while(!(body_impl->soap_fault) && !(AXIOM_NODE_IS_COMPLETE(body_impl->om_ele_node, env)))
             {
                 status = AXIS2_SOAP_BUILDER_NEXT(body_impl->soap_builder, env);
                 if(status == AXIS2_FAILURE)
@@ -282,7 +282,7 @@
     }
     else if(NULL != body_impl->soap_builder )
     {
-        while(!(body_impl->soap_fault) && !(AXIS2_OM_NODE_IS_COMPLETE(body_impl->om_ele_node, env)))
+        while(!(body_impl->soap_fault) && !(AXIOM_NODE_IS_COMPLETE(body_impl->om_ele_node, env)))
         {
             int status = AXIS2_SUCCESS;
             status = AXIS2_SOAP_BUILDER_NEXT(body_impl->soap_builder, env);
@@ -307,7 +307,7 @@
                           axis2_soap_fault_t *soap_fault)
 {
     axis2_soap_body_impl_t *body_impl = NULL;
-    axis2_om_node_t *fault_node = NULL;
+    axiom_node_t *fault_node = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, soap_fault, AXIS2_FAILURE);
     body_impl = AXIS2_INTF_TO_IMPL(body);
@@ -322,7 +322,7 @@
     if(fault_node)
     {
         body_impl->soap_fault = soap_fault;
-        AXIS2_OM_NODE_ADD_CHILD(fault_node , env, (body_impl->om_ele_node));
+        AXIOM_NODE_ADD_CHILD(fault_node , env, (body_impl->om_ele_node));
         body_impl->has_fault = AXIS2_TRUE;
         return AXIS2_SUCCESS;
     }
@@ -330,7 +330,7 @@
 }
 */
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_body_get_base_node(axis2_soap_body_t *body,
                                 const axis2_env_t *env)
 {
@@ -341,13 +341,13 @@
 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 *node)
+                              axiom_node_t *node)
 {
    axis2_soap_body_impl_t *body_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
    body_impl = AXIS2_INTF_TO_IMPL(body);
-   if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+   if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
    {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
@@ -380,7 +380,7 @@
     soap_body_impl = AXIS2_INTF_TO_IMPL(body);
     if(soap_body_impl->om_ele_node && soap_body_impl->soap_builder)
     {
-        while(AXIS2_OM_NODE_IS_COMPLETE(soap_body_impl->om_ele_node, env) != AXIS2_TRUE)
+        while(AXIOM_NODE_IS_COMPLETE(soap_body_impl->om_ele_node, env) != AXIS2_TRUE)
         {
             status = AXIS2_SOAP_BUILDER_NEXT(soap_body_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -419,7 +419,7 @@
 axis2_status_t AXIS2_CALL
 axis2_soap_body_add_child(axis2_soap_body_t *body,
                           const axis2_env_t *env,
-                          axis2_om_node_t *child)
+                          axiom_node_t *child)
 {
     axis2_soap_body_impl_t *body_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -428,7 +428,7 @@
     body_impl = AXIS2_INTF_TO_IMPL(body);
     if(NULL != body_impl->om_ele_node)
     {
-        return AXIS2_OM_NODE_ADD_CHILD(body_impl->om_ele_node, env, child);
+        return AXIOM_NODE_ADD_CHILD(body_impl->om_ele_node, env, child);
     }
     return AXIS2_FAILURE;
 }                          
@@ -437,20 +437,20 @@
                                  const axis2_env_t *env)
 {
     axis2_soap_body_impl_t *body_impl = NULL;
-    axis2_om_element_t *body_ele = NULL;
-    axis2_om_namespace_t *om_ns = NULL;
+    axiom_element_t *body_ele = NULL;
+    axiom_namespace_t *om_ns = NULL;
     axis2_char_t *uri           = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     body_impl = AXIS2_INTF_TO_IMPL(body);
     if(!body_impl->om_ele_node)
         return AXIS2_FAILURE;
-    body_ele = AXIS2_OM_NODE_GET_DATA_ELEMENT(body_impl->om_ele_node, env);
+    body_ele = AXIOM_NODE_GET_DATA_ELEMENT(body_impl->om_ele_node, env);
     if(!body_ele)
         return AXIS2_FAILURE;
-    om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(body_ele, env, body_impl->om_ele_node);
+    om_ns = AXIOM_ELEMENT_GET_NAMESPACE(body_ele, env, body_impl->om_ele_node);
     if(!om_ns)
         return AXIS2_FAILURE;
-    uri = AXIS2_OM_NAMESPACE_GET_URI(om_ns, env);
+    uri = AXIOM_NAMESPACE_GET_URI(om_ns, env);
     if(NULL != uri)
     {
         if(AXIS2_STRCMP(uri, AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) == 0)

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_builder.c Mon Jun 12 01:22:58 2006
@@ -23,7 +23,7 @@
  #include <axis2_soap_const.h>
  #include "_axis2_soap_body.h"
  #include "_axis2_soap_header_block.h"
- #include <axis2_om_stax_builder_internal.h>
+ #include <axiom_stax_builder_internal.h>
  #include "_axis2_soap_fault.h"
  /*********************** impl struct *****************************************/
  
@@ -31,7 +31,7 @@
  {
     axis2_soap_builder_t soap_builder;
     
-    axis2_om_stax_builder_t *om_builder;
+    axiom_stax_builder_t *om_builder;
     
     axis2_soap_message_t *soap_message;
     
@@ -55,7 +55,7 @@
     
     void *builder_helper;
     
-    axis2_om_namespace_t *envelope_ns;
+    axiom_namespace_t *envelope_ns;
     
     int soap_version;
     
@@ -91,7 +91,7 @@
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env);
                                 
-axis2_om_document_t* AXIS2_CALL 
+axiom_document_t* AXIS2_CALL 
 axis2_soap_builder_get_document
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env);
@@ -100,7 +100,7 @@
 axis2_soap_builder_next(axis2_soap_builder_t *builder,
                               const axis2_env_t *env);
                                     
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 axis2_soap_builder_get_document_element
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env); 
@@ -109,14 +109,14 @@
 axis2_soap_builder_create_om_element
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env,
-                                 axis2_om_node_t *current_node,
+                                 axiom_node_t *current_node,
                                  int current_event);
                                  
 axis2_status_t AXIS2_CALL
 axis2_soap_builder_process_namespace_data
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env,
-                                 axis2_om_node_t *om_node,
+                                 axiom_node_t *om_node,
                                  int is_soap_element);
 
 static axis2_status_t
@@ -127,16 +127,16 @@
 static axis2_status_t
 axis2_soap_builder_construct_node(axis2_soap_builder_t *builder,
                                 const axis2_env_t *env,
-                                axis2_om_node_t *parent,
-                                axis2_om_node_t *element_node,
+                                axiom_node_t *parent,
+                                axiom_node_t *element_node,
                                 axis2_bool_t is_soap_envelope);
 
 static axis2_status_t
 axis2_soap_builder_construct_node_for_empty_element
                                (axis2_soap_builder_t *builder,
                                 const axis2_env_t *env,
-                                axis2_om_node_t *parent,
-                                axis2_om_node_t *element_node);
+                                axiom_node_t *parent,
+                                axiom_node_t *element_node);
 
 static axis2_status_t 
 axis2_soap_builder_parse_headers(axis2_soap_builder_t *builder,
@@ -172,7 +172,7 @@
 
 AXIS2_EXTERN axis2_soap_builder_t * AXIS2_CALL
 axis2_soap_builder_create(const axis2_env_t *env,
-                                axis2_om_stax_builder_t *builder,
+                                axiom_stax_builder_t *builder,
                                 const axis2_char_t *soap_version)
 {
     axis2_soap_builder_impl_t *builder_impl = NULL;
@@ -279,7 +279,7 @@
     }
     if(NULL != builder_impl->om_builder)
     {
-        AXIS2_OM_STAX_BUILDER_FREE(builder_impl->om_builder, env);
+        AXIOM_STAX_BUILDER_FREE(builder_impl->om_builder, env);
         builder_impl->om_builder = NULL;
     }
     if(NULL != builder->ops)
@@ -309,7 +309,7 @@
         return NULL;
     
     while(!(builder_impl->soap_envelope) && 
-        !AXIS2_OM_STAX_BUILDER_IS_COMPLETE(builder_impl->om_builder, env))
+        !AXIOM_STAX_BUILDER_IS_COMPLETE(builder_impl->om_builder, env))
     {
        status = axis2_soap_builder_next(builder, env); 
             if(status == AXIS2_FAILURE)
@@ -319,7 +319,7 @@
     return builder_impl->soap_envelope;
 }
                                 
-axis2_om_document_t* AXIS2_CALL 
+axiom_document_t* AXIS2_CALL 
 axis2_soap_builder_get_document
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env)
@@ -331,7 +331,7 @@
     builder_impl = AXIS2_INTF_TO_IMPL(builder);
     if(builder_impl->om_builder)
     {
-        return AXIS2_OM_STAX_BUILDER_GET_DOCUMENT(builder_impl->om_builder, env);
+        return AXIOM_STAX_BUILDER_GET_DOCUMENT(builder_impl->om_builder, env);
     }
     else
         return NULL;
@@ -342,9 +342,9 @@
                               const axis2_env_t *env)
 {
     axis2_soap_builder_impl_t *builder_impl = NULL;
-    axis2_om_node_t *lastnode = NULL;
+    axiom_node_t *lastnode = NULL;
     int current_event = AXIS2_MAX_EVENT;
-    axis2_om_node_t *current_node =  NULL;
+    axiom_node_t *current_node =  NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     if(!builder)
@@ -357,7 +357,7 @@
     if(!(builder_impl->om_builder))
         return AXIS2_FAILURE;
    
-    lastnode = axis2_om_stax_builder_get_lastnode(builder_impl->om_builder, env);
+    lastnode = axiom_stax_builder_get_lastnode(builder_impl->om_builder, env);
     
     if(!lastnode)
     {
@@ -367,7 +367,7 @@
     {
         builder_impl->last_node_status = AXIS2_BUILDER_LAST_NODE_NOT_NULL;
     }
-    current_event = AXIS2_OM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_impl->om_builder, env);
+    current_event = AXIOM_STAX_BUILDER_NEXT_WITH_TOKEN(builder_impl->om_builder, env);
     if(current_event == -1)
     {
         builder_impl->done = AXIS2_TRUE;
@@ -376,7 +376,7 @@
     if(current_event == AXIS2_XML_READER_EMPTY_ELEMENT ||
         current_event ==  AXIS2_XML_READER_START_ELEMENT)
     {
-      current_node = axis2_om_stax_builder_get_lastnode(builder_impl->om_builder, env);
+      current_node = axiom_stax_builder_get_lastnode(builder_impl->om_builder, env);
       if(current_node) 
           status = axis2_soap_builder_create_om_element(builder, env, current_node, current_event);
       else
@@ -386,7 +386,7 @@
     return status;
 }
                                     
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 axis2_soap_builder_get_document_element
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env)
@@ -408,7 +408,7 @@
 axis2_soap_builder_create_om_element
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env,
-                                 axis2_om_node_t *current_node,
+                                 axiom_node_t *current_node,
                                  int current_event)
 {
     axis2_soap_builder_impl_t *builder_impl = NULL;
@@ -426,12 +426,12 @@
     else
     {
        int element_level = 0;
-       axis2_om_node_t *parent_node = NULL;
-       parent_node = AXIS2_OM_NODE_GET_PARENT(current_node, env);
+       axiom_node_t *parent_node = NULL;
+       parent_node = AXIOM_NODE_GET_PARENT(current_node, env);
        if(!builder_impl->om_builder)
            return  AXIS2_FAILURE;
        
-       element_level = axis2_om_stax_builder_get_element_level(
+       element_level = axiom_stax_builder_get_element_level(
                         builder_impl->om_builder, env);
        if(parent_node && element_level == 1 && current_event == AXIS2_XML_READER_EMPTY_ELEMENT)
        {
@@ -450,16 +450,16 @@
 static axis2_status_t
 axis2_soap_builder_construct_node(axis2_soap_builder_t *builder,
                                 const axis2_env_t *env,
-                                axis2_om_node_t *parent,
-                                axis2_om_node_t *om_element_node,
+                                axiom_node_t *parent,
+                                axiom_node_t *om_element_node,
                                 axis2_bool_t is_soap_envelope)
 {
     axis2_soap_builder_impl_t *builder_impl = NULL;
     
-    axis2_om_element_t *parent_ele  = NULL;
+    axiom_element_t *parent_ele  = NULL;
     axis2_char_t *parent_localname = NULL;
     
-    axis2_om_element_t *om_element = NULL;
+    axiom_element_t *om_element = NULL;
     const axis2_char_t *ele_localname = NULL;
     
     int element_level = 0;
@@ -474,26 +474,26 @@
     if(!builder_impl->om_builder)
         return AXIS2_FAILURE;
     /** get element level of this om element */
-    element_level = axis2_om_stax_builder_get_element_level(
+    element_level = axiom_stax_builder_get_element_level(
                         builder_impl->om_builder, env);
     /* get om element struct from node */
-    om_element = (axis2_om_element_t *)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(om_element_node, env);
+    om_element = (axiom_element_t *)
+                AXIOM_NODE_GET_DATA_ELEMENT(om_element_node, env);
     if(!om_element)
         return AXIS2_FAILURE;
     /* get element localname */    
-    ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_element, env);
+    ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_element, env);
     if(!ele_localname)
         return AXIS2_FAILURE;
    
     /* start: handle MTOM stuff */
     if (AXIS2_STRCMP(ele_localname, AXIS2_XOP_INCLUDE) == 0)
     {
-        axis2_om_namespace_t *ns = NULL;
-        ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_element, env, om_element_node);
+        axiom_namespace_t *ns = NULL;
+        ns = AXIOM_ELEMENT_GET_NAMESPACE(om_element, env, om_element_node);
         if (ns)
         {
-            axis2_char_t *uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
+            axis2_char_t *uri = AXIOM_NAMESPACE_GET_URI(ns, env);
             if (uri)
             {
                 if (AXIS2_STRCMP(uri, AXIS2_XOP_NAMESPACE_URI) == 0)
@@ -503,7 +503,7 @@
                     if (qname)
                     {
                         axis2_char_t *id = NULL;
-                        id = AXIS2_OM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, qname);                        
+                        id = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, qname);                        
                         if (id)
                         {
                             axis2_char_t *pos = NULL;
@@ -519,9 +519,9 @@
                                         (void*)id, AXIS2_HASH_KEY_STRING);
                                     if (data_handler)
                                     {
-                                        axis2_om_text_t *data_text = NULL;
-                                        axis2_om_node_t *data_om_node = NULL;
-                                        data_text = axis2_om_text_create_with_data_handler(
+                                        axiom_text_t *data_text = NULL;
+                                        axiom_node_t *data_om_node = NULL;
+                                        data_text = axiom_text_create_with_data_handler(
                                             env, om_element_node, data_handler, &data_om_node);
                                     }
                                 }
@@ -537,9 +537,9 @@
     if(parent)
     {
         /** a parent node exist , so not soap envelope element */
-        parent_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(parent, env);
+        parent_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(parent, env);
         if(parent_ele)
-            parent_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(parent_ele, env);
+            parent_localname = AXIOM_ELEMENT_GET_LOCALNAME(parent_ele, env);
     }
     if(!parent && is_soap_envelope)
     {   
@@ -667,7 +667,7 @@
     {
             axis2_soap_body_t *soap_body = NULL;
             axis2_soap_fault_t *soap_fault = NULL;
-            axis2_om_namespace_t *env_ns = NULL;
+            axiom_namespace_t *env_ns = NULL;
             
             env_ns = AXIS2_SOAP_ENVELOPE_GET_NAMESPACE(builder_impl->soap_envelope, env);
             if(!env_ns)
@@ -691,14 +691,14 @@
             builder_impl->processing_mandatory_fault_elements = AXIS2_TRUE; 
             
             if(AXIS2_STRCMP(AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, 
-                AXIS2_OM_NAMESPACE_GET_URI(env_ns , env)) == 0)
+                AXIOM_NAMESPACE_GET_URI(env_ns , env)) == 0)
             {
                 builder_impl->builder_helper = axis2_soap12_builder_helper_create(env, builder);
                 if(!(builder_impl->builder_helper))
                     return AXIS2_FAILURE;
             }
             else if(AXIS2_STRCMP(AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, 
-                AXIS2_OM_NAMESPACE_GET_URI(env_ns , env)) == 0)
+                AXIOM_NAMESPACE_GET_URI(env_ns , env)) == 0)
             {   
                 builder_impl->builder_helper = axis2_soap11_builder_helper_create(env, builder, builder_impl->om_builder);                 if(!(builder_impl->builder_helper))
                     return AXIS2_FAILURE;
@@ -729,11 +729,11 @@
 axis2_soap_builder_process_namespace_data
                                 (axis2_soap_builder_t *builder,
                                  const axis2_env_t *env,
-                                 axis2_om_node_t *om_node,
+                                 axiom_node_t *om_node,
                                  int is_soap_element)
 {
-    axis2_om_element_t *om_ele = NULL;
-    axis2_om_namespace_t *om_ns = NULL;
+    axiom_element_t *om_ele = NULL;
+    axiom_namespace_t *om_ns = NULL;
     axis2_char_t *ns_uri = NULL;
   
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -744,15 +744,15 @@
     if(!is_soap_element)
         return AXIS2_SUCCESS;
     
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(om_node, env) == AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(om_node, env) == AXIOM_ELEMENT)
     {
-        om_ele = (axis2_om_element_t *) AXIS2_OM_NODE_GET_DATA_ELEMENT(om_node, env);
+        om_ele = (axiom_element_t *) AXIOM_NODE_GET_DATA_ELEMENT(om_node, env);
         if(om_ele)
         {
-            om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, om_node);
+            om_ns = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, om_node);
             if(om_ns)
             {
-                ns_uri = AXIS2_OM_NAMESPACE_GET_URI(om_ns, env);
+                ns_uri = AXIOM_NAMESPACE_GET_URI(om_ns, env);
                 if(ns_uri && 
                     (AXIS2_STRCMP(ns_uri, AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) != 0) &&
                     (AXIS2_STRCMP(ns_uri, AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) != 0))
@@ -774,9 +774,9 @@
                       const axis2_char_t* soap_version_uri_from_transport)
 {
     axis2_soap_builder_impl_t *builder_impl = NULL;
-    axis2_om_namespace_t *om_ns = NULL;
-    axis2_om_node_t *envelope_node = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_namespace_t *om_ns = NULL;
+    axiom_node_t *envelope_node = NULL;
+    axiom_element_t *om_ele = NULL;
     axis2_char_t *ns_uri = NULL;
     
     AXIS2_PARAM_CHECK(env->error, soap_version_uri_from_transport, AXIS2_FAILURE);    
@@ -801,15 +801,15 @@
     if(!envelope_node)
         return AXIS2_FAILURE;
         
-    om_ele = (axis2_om_element_t *) AXIS2_OM_NODE_GET_DATA_ELEMENT(envelope_node, env);
+    om_ele = (axiom_element_t *) AXIOM_NODE_GET_DATA_ELEMENT(envelope_node, env);
     if(!om_ele)
         return AXIS2_FAILURE;
         
-    om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, envelope_node);
+    om_ns = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, envelope_node);
     if(!om_ns)
         return AXIS2_FAILURE;
         
-    ns_uri = AXIS2_OM_NAMESPACE_GET_URI(om_ns, env);
+    ns_uri = AXIOM_NAMESPACE_GET_URI(om_ns, env);
     
     if(ns_uri != NULL)
     {        
@@ -853,7 +853,7 @@
               const axis2_env_t *env)
 {
     axis2_soap_builder_impl_t *builder_impl = NULL;
-    axis2_om_node_t *om_node = NULL;
+    axiom_node_t *om_node = NULL;
     axis2_soap_header_t *soap_header = NULL;
     int status = AXIS2_SUCCESS;
     if(!builder)
@@ -872,7 +872,7 @@
     {
         om_node = AXIS2_SOAP_HEADER_GET_BASE_NODE(soap_header, env);
         if(om_node)
-        {        while(!AXIS2_OM_NODE_IS_COMPLETE(om_node, env))
+        {        while(!AXIOM_NODE_IS_COMPLETE(om_node, env))
                 {
                     status = axis2_soap_builder_next(builder, env);
                     if(status == AXIS2_FAILURE)
@@ -880,7 +880,7 @@
                 }
                 /*HACK: to fix AXIS2C-129 - Samisa*/
                 /*
-                axis2_om_stax_builder_set_element_level(
+                axiom_stax_builder_set_element_level(
                         builder_impl->om_builder, env, 1);
                 */                        
         }                
@@ -950,16 +950,16 @@
 axis2_soap_builder_construct_node_for_empty_element
                                (axis2_soap_builder_t *builder,
                                 const axis2_env_t *env,
-                                axis2_om_node_t *parent,
-                                axis2_om_node_t *om_element_node)
+                                axiom_node_t *parent,
+                                axiom_node_t *om_element_node)
 {
     
     axis2_soap_builder_impl_t *builder_impl = NULL;
     
-    axis2_om_element_t *parent_ele  = NULL;
+    axiom_element_t *parent_ele  = NULL;
     axis2_char_t *parent_localname = NULL;
     
-    axis2_om_element_t *om_element = NULL;
+    axiom_element_t *om_element = NULL;
     axis2_char_t *ele_localname = NULL;
     
     int element_level = 0;
@@ -974,15 +974,15 @@
     if(!builder_impl->om_builder)
         return AXIS2_FAILURE;
 
-    element_level = axis2_om_stax_builder_get_element_level(
+    element_level = axiom_stax_builder_get_element_level(
                         builder_impl->om_builder, env);
 
-    om_element = (axis2_om_element_t *)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(om_element_node, env);
+    om_element = (axiom_element_t *)
+                AXIOM_NODE_GET_DATA_ELEMENT(om_element_node, env);
     if(!om_element)
         return AXIS2_FAILURE;
 
-    ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_element, env);
+    ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_element, env);
     if(!ele_localname)
         return AXIS2_FAILURE;
     
@@ -990,11 +990,11 @@
         return AXIS2_FAILURE;
         
 
-    parent_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(parent, env);
+    parent_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(parent, env);
     if(!parent_ele)
         return AXIS2_FAILURE;
     
-    parent_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(parent_ele, env);
+    parent_localname = AXIOM_ELEMENT_GET_LOCALNAME(parent_ele, env);
     if(!parent_localname)
         return AXIS2_FAILURE;
     

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_envelope.c Mon Jun 12 01:22:58 2006
@@ -27,14 +27,14 @@
  #include <axis2_soap_fault_role.h>
  #include <axis2_soap_fault_value.h> 
  #include <axis2_soap_fault_text.h>
- #include <axis2_om_namespace_internal.h>
+ #include <axiom_namespace_internal.h>
  /******************* impl struct *********************************************/
  
  typedef struct axis2_soap_envelope_impl_t
  {
     axis2_soap_envelope_t soap_envelope;
     /* corresponding om element node */    
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     /* soap version */
     int soap_version;
     /* soap header */
@@ -71,13 +71,13 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap_envelope_serialize(axis2_soap_envelope_t *envelope,
                                 const axis2_env_t *env,
-                                axis2_om_output_t *om_output, 
+                                axiom_output_t *om_output, 
                                 axis2_bool_t cache);
                                 
 axis2_status_t AXIS2_CALL
 axis2_soap_envelope_free(axis2_soap_envelope_t *envelope,
                             const axis2_env_t *env);
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_envelope_get_base_node(axis2_soap_envelope_t *envelope,
                              const axis2_env_t *env);
                              
@@ -86,14 +86,14 @@
 axis2_soap_envelope_get_soap_version(axis2_soap_envelope_t *envelope,
                                    const axis2_env_t *env);
                                    
-axis2_om_namespace_t* AXIS2_CALL 
+axiom_namespace_t* AXIS2_CALL 
 axis2_soap_envelope_get_namespace(axis2_soap_envelope_t *envelope,
                                   const axis2_env_t *env);
                                   
 static axis2_status_t
 check_and_set_soap_version(axis2_soap_envelope_t *env_impl, 
                            const axis2_env_t *env, 
-                           axis2_om_namespace_t *ns);
+                           axiom_namespace_t *ns);
 
 
 axis2_status_t AXIS2_CALL
@@ -160,11 +160,11 @@
 
 AXIS2_EXTERN axis2_soap_envelope_t* AXIS2_CALL
 axis2_soap_envelope_create(const axis2_env_t *env, 
-                           axis2_om_namespace_t *ns)
+                           axiom_namespace_t *ns)
 {
     axis2_soap_envelope_impl_t *envelope_impl = NULL;
     axis2_soap_envelope_t *envelope = NULL;
-    axis2_om_element_t *ele = NULL;
+    axiom_element_t *ele = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ns, NULL);
@@ -181,7 +181,7 @@
         return NULL; 
     }
      
-    ele = axis2_om_element_create(env, NULL, 
+    ele = axiom_element_create(env, NULL, 
                                   AXIS2_SOAP_ENVELOPE_LOCAL_NAME, ns, 
                                   &(envelope_impl->om_ele_node));
     if (!ele)
@@ -198,7 +198,7 @@
                                                     int soap_version,
                                                     const axis2_char_t *prefix)
 {
-    axis2_om_namespace_t *ns        = NULL;
+    axiom_namespace_t *ns        = NULL;
     const axis2_char_t *ns_prefix = NULL;
     const axis2_char_t *ns_uri    = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -224,7 +224,7 @@
         ns_prefix = prefix;
     }
     
-    ns = axis2_om_namespace_create(env, ns_uri, ns_prefix);
+    ns = axiom_namespace_create(env, ns_uri, ns_prefix);
     if(!ns)
         return NULL;
     return axis2_soap_envelope_create(env, ns);
@@ -262,7 +262,7 @@
         }
         else
         {
-            AXIS2_OM_NODE_FREE_TREE(envelope_impl->om_ele_node, env); 
+            AXIOM_NODE_FREE_TREE(envelope_impl->om_ele_node, env); 
             envelope_impl->om_ele_node = NULL;
         }
     }
@@ -272,7 +272,7 @@
     return AXIS2_SUCCESS;
 }
     
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_envelope_get_base_node(axis2_soap_envelope_t *envelope,
                                 const axis2_env_t *env)
 {
@@ -283,13 +283,13 @@
 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 *node)
+                                  axiom_node_t *node)
 {
    axis2_soap_envelope_impl_t *envelope_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
    envelope_impl = AXIS2_INTF_TO_IMPL(envelope);
-   if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+   if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
    {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
@@ -335,7 +335,7 @@
     }
     else if(envelope_impl->soap_builder)
     {
-        while(!(envelope_impl->header) && !AXIS2_OM_NODE_IS_COMPLETE(
+        while(!(envelope_impl->header) && !AXIOM_NODE_IS_COMPLETE(
                 envelope_impl->om_ele_node, env))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(envelope_impl->soap_builder, env);  
@@ -354,7 +354,7 @@
                                 axis2_char_t *name)
 {
     axis2_soap_envelope_impl_t *envelope_impl = NULL;
-    axis2_om_namespace_t *ns = NULL;
+    axiom_namespace_t *ns = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     envelope_impl = AXIS2_INTF_TO_IMPL(envelope);
     
@@ -364,7 +364,7 @@
     
     if (namespace_uri)
     {
-        ns = axis2_om_namespace_create(env, namespace_uri, NULL);
+        ns = axiom_namespace_create(env, namespace_uri, NULL);
     }
     
     return axis2_soap_header_block_create_with_parent(env, name, ns, envelope_impl->header);
@@ -385,7 +385,7 @@
     }
     else if(envelope_impl->soap_builder)
     {
-        while(!(envelope_impl->body)  && !AXIS2_OM_NODE_IS_COMPLETE(envelope_impl->om_ele_node, env))
+        while(!(envelope_impl->body)  && !AXIOM_NODE_IS_COMPLETE(envelope_impl->om_ele_node, env))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(envelope_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -400,7 +400,7 @@
 axis2_status_t AXIS2_CALL 
 axis2_soap_envelope_serialize(axis2_soap_envelope_t *envelope,
                               const axis2_env_t *env,
-                              axis2_om_output_t *om_output, 
+                              axiom_output_t *om_output, 
                               axis2_bool_t cache)
 {
     axis2_soap_envelope_impl_t *envelope_impl = NULL;
@@ -434,21 +434,21 @@
                     fault_code = AXIS2_SOAP_FAULT_GET_CODE(soap_fault, env);
                     if(fault_code)
                     {
-                        axis2_om_node_t *fault_code_om_node = NULL;
-                        axis2_om_element_t *fault_code_om_ele = NULL;
-                        axis2_om_node_t *fault_value_om_node = NULL;
-                        axis2_om_element_t *fault_value_om_ele = NULL;
+                        axiom_node_t *fault_code_om_node = NULL;
+                        axiom_element_t *fault_code_om_ele = NULL;
+                        axiom_node_t *fault_value_om_node = NULL;
+                        axiom_element_t *fault_value_om_ele = NULL;
                         axis2_soap_fault_value_t *fault_value = NULL;
                         axis2_char_t *text = NULL;
 
                         fault_code_om_node = AXIS2_SOAP_FAULT_CODE_GET_BASE_NODE(fault_code, env);
                         if(NULL != fault_code_om_node)
                         {
-                           fault_code_om_ele = (axis2_om_element_t *)
-                           AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_code_om_node, env);
+                           fault_code_om_ele = (axiom_element_t *)
+                           AXIOM_NODE_GET_DATA_ELEMENT(fault_code_om_node, env);
                            if(NULL != fault_code_om_ele)
                            {                               
-                                AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_code_om_ele, 
+                                AXIOM_ELEMENT_SET_LOCALNAME(fault_code_om_ele, 
                                     env, AXIS2_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME); 
                                 
                                 fault_value = AXIS2_SOAP_FAULT_CODE_GET_VALUE(fault_code, env);
@@ -458,17 +458,17 @@
                                     fault_value_om_node = AXIS2_SOAP_FAULT_VALUE_GET_BASE_NODE(fault_value, env);
                                     if(fault_value_om_node)
                                     {
-                                       fault_value_om_node =  AXIS2_OM_NODE_DETACH(fault_value_om_node, env);
-                                        fault_value_om_ele = (axis2_om_element_t *)
-                                        AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_value_om_node, env);
+                                       fault_value_om_node =  AXIOM_NODE_DETACH(fault_value_om_node, env);
+                                        fault_value_om_ele = (axiom_element_t *)
+                                        AXIOM_NODE_GET_DATA_ELEMENT(fault_value_om_node, env);
                                         if(fault_value_om_ele)
                                         {
-                                            text = AXIS2_OM_ELEMENT_GET_TEXT(fault_value_om_ele, env, fault_value_om_node);
+                                            text = AXIOM_ELEMENT_GET_TEXT(fault_value_om_ele, env, fault_value_om_node);
                                             if(NULL != text)
                                             {
-                                                AXIS2_OM_ELEMENT_SET_TEXT(fault_code_om_ele, env, text, fault_code_om_node);
+                                                AXIOM_ELEMENT_SET_TEXT(fault_code_om_ele, env, text, fault_code_om_node);
                                              }
-                                             AXIS2_OM_NODE_FREE_TREE(fault_value_om_node, env);
+                                             AXIOM_NODE_FREE_TREE(fault_value_om_node, env);
                                         }
                                         
                                     }
@@ -479,23 +479,23 @@
                     fault_reason = AXIS2_SOAP_FAULT_GET_REASON(soap_fault, env);
                     if(fault_reason)
                     {
-                        axis2_om_node_t *fault_reason_om_node = NULL;
-                        axis2_om_element_t *fault_reason_om_ele = NULL;
-                        axis2_om_node_t *fault_text_om_node = NULL;
-                        axis2_om_element_t *fault_text_om_ele = NULL;
+                        axiom_node_t *fault_reason_om_node = NULL;
+                        axiom_element_t *fault_reason_om_ele = NULL;
+                        axiom_node_t *fault_text_om_node = NULL;
+                        axiom_element_t *fault_text_om_ele = NULL;
                         axis2_soap_fault_text_t *fault_text = NULL;
                         axis2_char_t *text =  NULL;                        
                     
                         fault_reason_om_node = AXIS2_SOAP_FAULT_REASON_GET_BASE_NODE(fault_reason, env);
                         if(fault_reason_om_node)
                         {
-                            fault_reason_om_ele  = (axis2_om_element_t *)
-                                AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_reason_om_node, env);
+                            fault_reason_om_ele  = (axiom_element_t *)
+                                AXIOM_NODE_GET_DATA_ELEMENT(fault_reason_om_node, env);
                         
                             if(fault_reason_om_ele)
                             {
                                 
-                                AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_reason_om_ele, 
+                                AXIOM_ELEMENT_SET_LOCALNAME(fault_reason_om_ele, 
                                     env, AXIS2_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME);
                         
                                 fault_text = 
@@ -505,18 +505,18 @@
                                     fault_text_om_node = AXIS2_SOAP_FAULT_TEXT_GET_BASE_NODE(fault_text, env);
                                     if(fault_text_om_node)
                                     {
-                                        fault_text_om_node = AXIS2_OM_NODE_DETACH(fault_text_om_node, env);                                                        fault_text_om_ele  = (axis2_om_element_t *)
-                                        AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_text_om_node, env);
+                                        fault_text_om_node = AXIOM_NODE_DETACH(fault_text_om_node, env);                                                        fault_text_om_ele  = (axiom_element_t *)
+                                        AXIOM_NODE_GET_DATA_ELEMENT(fault_text_om_node, env);
                                         if(fault_text_om_ele)
                                         {
-                                            text = AXIS2_OM_ELEMENT_GET_TEXT(fault_text_om_ele, env, fault_text_om_node);
+                                            text = AXIOM_ELEMENT_GET_TEXT(fault_text_om_ele, env, fault_text_om_node);
                                             if(NULL != text)
                                             {
-                                                AXIS2_OM_ELEMENT_SET_TEXT( fault_reason_om_ele, 
+                                                AXIOM_ELEMENT_SET_TEXT( fault_reason_om_ele, 
                                                     env, text, fault_reason_om_node);   
                                             }   
                                         }                     
-                                        AXIS2_OM_NODE_FREE_TREE(fault_text_om_node, env);
+                                        AXIOM_NODE_FREE_TREE(fault_text_om_node, env);
                                     }
                                 }
                             }
@@ -526,17 +526,17 @@
                     fault_role = AXIS2_SOAP_FAULT_GET_ROLE(soap_fault, env);
                     if(fault_role)
                     {
-                        axis2_om_node_t *fault_role_om_node = NULL;
-                        axis2_om_element_t *fault_role_om_ele = NULL;
+                        axiom_node_t *fault_role_om_node = NULL;
+                        axiom_element_t *fault_role_om_ele = NULL;
                         
                         fault_role_om_node = AXIS2_SOAP_FAULT_ROLE_GET_BASE_NODE(fault_role, env);
                         if(fault_role_om_node)
                         {
-                            fault_role_om_ele = (axis2_om_element_t *)
-                                AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_role_om_node, env);
+                            fault_role_om_ele = (axiom_element_t *)
+                                AXIOM_NODE_GET_DATA_ELEMENT(fault_role_om_node, env);
                             if(fault_role_om_ele)
                             {
-                                AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_role_om_ele, env, 
+                                AXIOM_ELEMENT_SET_LOCALNAME(fault_role_om_ele, env, 
                                     AXIS2_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME);
                             }                                
                         }
@@ -545,16 +545,16 @@
                     fault_detail = AXIS2_SOAP_FAULT_GET_DETAIL(soap_fault, env);
                     if(fault_detail)
                     {
-                        axis2_om_node_t *fault_detail_om_node = NULL;
-                        axis2_om_element_t *fault_detail_om_ele = NULL;
+                        axiom_node_t *fault_detail_om_node = NULL;
+                        axiom_element_t *fault_detail_om_ele = NULL;
                         fault_detail_om_node = AXIS2_SOAP_FAULT_DETAIL_GET_BASE_NODE(fault_detail, env);
                         if(fault_detail_om_node)
                         {
-                            fault_detail_om_ele = (axis2_om_element_t *)
-                                AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_detail_om_node, env);
+                            fault_detail_om_ele = (axiom_element_t *)
+                                AXIOM_NODE_GET_DATA_ELEMENT(fault_detail_om_node, env);
                             if(fault_detail_om_ele)
                             {
-                            AXIS2_OM_ELEMENT_SET_LOCALNAME(fault_detail_om_ele, 
+                            AXIOM_ELEMENT_SET_LOCALNAME(fault_detail_om_ele, 
                                 env, AXIS2_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME);
                             }
                         }
@@ -567,8 +567,8 @@
        These should be set to om output before calling the serialize function
        Otherwise default values will be written
     */
-    AXIS2_OM_OUTPUT_WRITE_XML_VERSION_ENCODING(om_output, env);
-    return AXIS2_OM_NODE_SERIALIZE(envelope_impl->om_ele_node, env, om_output);
+    AXIOM_OUTPUT_WRITE_XML_VERSION_ENCODING(om_output, env);
+    return AXIOM_NODE_SERIALIZE(envelope_impl->om_ele_node, env, om_output);
 }
 
 axis2_status_t AXIS2_CALL 
@@ -613,7 +613,7 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_om_namespace_t* AXIS2_CALL 
+axiom_namespace_t* AXIS2_CALL 
 axis2_soap_envelope_get_namespace(axis2_soap_envelope_t *envelope,
                                   const axis2_env_t *env)
 {
@@ -623,13 +623,13 @@
     
     if (envelope_impl->om_ele_node)
     {
-        axis2_om_element_t *ele = NULL;
-        if (AXIS2_OM_NODE_GET_NODE_TYPE(envelope_impl->om_ele_node, env) == AXIS2_OM_ELEMENT)
+        axiom_element_t *ele = NULL;
+        if (AXIOM_NODE_GET_NODE_TYPE(envelope_impl->om_ele_node, env) == AXIOM_ELEMENT)
         {
-            ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(envelope_impl->om_ele_node, env);
+            ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(envelope_impl->om_ele_node, env);
             if (ele)
             {
-                return AXIS2_OM_ELEMENT_GET_NAMESPACE(ele, env, envelope_impl->om_ele_node);
+                return AXIOM_ELEMENT_GET_NAMESPACE(ele, env, envelope_impl->om_ele_node);
             }
         }
     }
@@ -656,12 +656,12 @@
     axis2_soap_envelope_t *soap_env = NULL;
     axis2_soap_header_t *soap_header = NULL;
     axis2_soap_body_t *soap_body = NULL;
-    axis2_om_namespace_t *om_ns = NULL;
+    axiom_namespace_t *om_ns = NULL;
     axis2_soap_envelope_impl_t *env_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     if(soap_version == AXIS2_SOAP11)
     {
-        om_ns = axis2_om_namespace_create(env,
+        om_ns = axiom_namespace_create(env,
             AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, 
             AXIS2_SOAP_DEFAULT_NAMESPACE_PREFIX);
         if(!om_ns)
@@ -677,7 +677,7 @@
     }
     else if(soap_version == AXIS2_SOAP12)
     {
-        om_ns = axis2_om_namespace_create(env,
+        om_ns = axiom_namespace_create(env,
             AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, 
             AXIS2_SOAP_DEFAULT_NAMESPACE_PREFIX);
         if(!om_ns)
@@ -703,7 +703,7 @@
     const axis2_char_t *reason_text, 
     const int soap_version,
     axis2_array_list_t *sub_codes,
-    axis2_om_node_t *detail_node)
+    axiom_node_t *detail_node)
 {
     axis2_soap_envelope_t *soap_env = NULL;
     axis2_soap_body_t *soap_body = NULL;
@@ -774,7 +774,7 @@
 static axis2_status_t
 check_and_set_soap_version(axis2_soap_envelope_t *envelope,
                            const axis2_env_t *env,
-                           axis2_om_namespace_t *ns)
+                           axiom_namespace_t *ns)
 {
     axis2_soap_envelope_impl_t *envelope_impl = NULL;
     axis2_char_t *uri = NULL;
@@ -785,7 +785,7 @@
          
     envelope_impl = AXIS2_INTF_TO_IMPL(envelope);
     
-    uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
+    uri = AXIOM_NAMESPACE_GET_URI(ns, env);
     if(!uri)
         return AXIS2_FAILURE;
         
@@ -813,8 +813,8 @@
                                      int soap_version)
 {
     axis2_soap_envelope_impl_t *envelope_impl = NULL;
-    axis2_om_element_t *env_ele  = NULL;
-    axis2_om_namespace_t *env_ns = NULL;
+    axiom_element_t *env_ele  = NULL;
+    axiom_namespace_t *env_ns = NULL;
     const axis2_char_t *ns_uri         = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -834,19 +834,19 @@
         return AXIS2_FAILURE;
     }
     
-    env_ele = (axis2_om_element_t*)
-        AXIS2_OM_NODE_GET_DATA_ELEMENT(envelope_impl->om_ele_node,
+    env_ele = (axiom_element_t*)
+        AXIOM_NODE_GET_DATA_ELEMENT(envelope_impl->om_ele_node,
                                        env);
     if(!env_ele)
     {
         return AXIS2_FAILURE;
     }
                                            
-    env_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(env_ele, env, envelope_impl->om_ele_node);
+    env_ns = AXIOM_ELEMENT_GET_NAMESPACE(env_ele, env, envelope_impl->om_ele_node);
     if(!env_ns)
         return AXIS2_FAILURE;
 
-    status = axis2_om_namespace_set_uri(env_ns, env, ns_uri);
+    status = axiom_namespace_set_uri(env_ns, env, ns_uri);
     if(status == AXIS2_SUCCESS)
     {
         axis2_soap_envelope_set_soap_version_internal(soap_envelope, env, soap_version);

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c Mon Jun 12 01:22:58 2006
@@ -16,8 +16,8 @@
  #include "_axis2_soap_fault.h"
  #include <axis2_soap_const.h>
  #include "_axis2_soap_body.h"
- #include <axis2_om_node.h>
- #include <axis2_om_element.h>
+ #include <axiom_node.h>
+ #include <axiom_element.h>
  #include <axis2_soap_fault_code.h>
  #include <axis2_soap_fault_detail.h>
  #include <axis2_soap_fault_value.h>
@@ -33,7 +33,7 @@
 {
     axis2_soap_fault_t soap_fault;
     /* om element node corresponding to soap fault */
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     
     /* soap fault code sub element */
     axis2_soap_fault_code_t *fcode;
@@ -94,7 +94,7 @@
 
 
                                         
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_get_base_node(axis2_soap_fault_t *fault,
                                const axis2_env_t *env);  
                                                 
@@ -178,11 +178,11 @@
 {
     axis2_soap_fault_impl_t *fault_impl = NULL;
     axis2_soap_fault_t *fault = NULL;
-    axis2_om_element_t *this_ele = NULL;
-    axis2_om_node_t *this_node = NULL;
-    axis2_om_node_t *parent_node = NULL;
-    axis2_om_element_t *parent_ele = NULL;
-    axis2_om_namespace_t *parent_ns = NULL;
+    axiom_element_t *this_ele = NULL;
+    axiom_node_t *this_node = NULL;
+    axiom_node_t *parent_node = NULL;
+    axiom_element_t *parent_ele = NULL;
+    axiom_namespace_t *parent_ns = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, body, NULL);
@@ -201,16 +201,16 @@
     fault_impl->soap_version = 
         AXIS2_SOAP_BODY_GET_SOAP_VERSION(body, env);
     
-    parent_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    parent_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                         parent_node, env);
     if(!parent_ele)
     {
         AXIS2_FREE(env->allocator, fault_impl);
         return NULL;
     }
-    parent_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
+    parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     
-    this_ele = axis2_om_element_create(env, 
+    this_ele = axiom_element_create(env, 
                                        parent_node,                             
                                        AXIS2_SOAP_FAULT_LOCAL_NAME,
                                        parent_ns,
@@ -334,7 +334,7 @@
     } 
     else if(fault_impl->soap_builder)
     {
-        while(!(fault_impl->fcode) && !(AXIS2_OM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while(!(fault_impl->fcode) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -384,7 +384,7 @@
     } 
     else if(fault_impl->soap_builder)
     {
-        while(!(fault_impl->freason) && !(AXIS2_OM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while(!(fault_impl->freason) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -436,7 +436,7 @@
     } 
     else if(fault_impl->soap_builder)
     {
-        while(!(fault_impl->fnode) && !(AXIS2_OM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while(!(fault_impl->fnode) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -490,7 +490,7 @@
     } 
     else if(fault_impl->soap_builder)
     {
-        while(!(fault_impl->frole) && !(AXIS2_OM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while(!(fault_impl->frole) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -542,7 +542,7 @@
     } 
     else if(fault_impl->soap_builder)
     {
-        while(!(fault_impl->fdetail) && !(AXIS2_OM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while(!(fault_impl->fdetail) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -555,14 +555,14 @@
 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_soap_fault_impl_t *fault_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
    fault_impl = AXIS2_INTF_TO_IMPL(fault);
 
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
    {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
@@ -572,7 +572,7 @@
 
 }
                                         
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_get_base_node(axis2_soap_fault_t *fault,
                                const axis2_env_t *env)
 {
@@ -586,10 +586,10 @@
                                const axis2_env_t *env)
 {
     axis2_soap_fault_detail_t *detail = NULL;
-    axis2_om_node_t *detail_node = NULL;
-    axis2_om_element_t *detail_ele = NULL;
-    axis2_om_node_t *exception_node = NULL;
-    axis2_om_element_t *exception_ele = NULL;
+    axiom_node_t *detail_node = NULL;
+    axiom_element_t *detail_ele = NULL;
+    axiom_node_t *exception_node = NULL;
+    axiom_element_t *exception_ele = NULL;
     axis2_qname_t *qn = NULL;
     axis2_char_t *excep = NULL;
     
@@ -600,19 +600,19 @@
     detail_node = AXIS2_SOAP_FAULT_DETAIL_GET_BASE_NODE(detail, env);
     if(NULL != detail_node)
     {
-        detail_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+        detail_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                     detail_node, env);
         
         qn = axis2_qname_create(env,
              AXIS2_SOAP_FAULT_DETAIL_EXCEPTION_ENTRY, NULL, NULL);
         if(qn)
         {
-            exception_ele = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            exception_ele = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                         detail_ele, env,
                         qn, detail_node, &exception_node);
             AXIS2_QNAME_FREE(qn, env);                        
             if(exception_ele && 
-               (excep = AXIS2_OM_ELEMENT_GET_TEXT(exception_ele, env, exception_node)))
+               (excep = AXIOM_ELEMENT_GET_TEXT(exception_ele, env, exception_node)))
             {
                 return excep;
             }
@@ -628,8 +628,8 @@
 {
     axis2_soap_fault_impl_t *fault_impl = NULL;
     axis2_soap_fault_detail_t *detail = NULL;
-    axis2_om_node_t *fault_detail_entry_node = NULL;
-    axis2_om_element_t *fault_detail_ele = NULL;
+    axiom_node_t *fault_detail_entry_node = NULL;
+    axiom_element_t *fault_detail_ele = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
@@ -647,7 +647,7 @@
     }
     /** create an om element with the exception enrty */
     
-    fault_detail_ele = axis2_om_element_create(env, NULL, 
+    fault_detail_ele = axiom_element_create(env, NULL, 
                             AXIS2_SOAP_FAULT_DETAIL_EXCEPTION_ENTRY,
                             NULL, &fault_detail_entry_node);
     if(!fault_detail_ele)
@@ -655,7 +655,7 @@
         return AXIS2_FAILURE;
     }
     /** set the exception string as a text node of newly created om element */
-    AXIS2_OM_ELEMENT_SET_TEXT(fault_detail_ele,
+    AXIOM_ELEMENT_SET_TEXT(fault_detail_ele,
          env, exception, fault_detail_entry_node);
     /** now add this om element as a child of soap fault detail om element node */
     return AXIS2_SOAP_FAULT_DETAIL_ADD_DETAIL_ENTRY(detail, env, fault_detail_entry_node);             
@@ -681,7 +681,7 @@
                                       const int soap_version)
 {
     axis2_soap_fault_t *soap_fault = NULL;
-    axis2_om_node_t *fault_node    = NULL;
+    axiom_node_t *fault_node    = NULL;
     
     axis2_soap_fault_code_t *soap_fault_code = NULL;
     axis2_soap_fault_value_t *soap_fault_value = NULL;
@@ -689,11 +689,11 @@
     axis2_soap_fault_reason_t *soap_fault_reason = NULL;
     axis2_soap_fault_text_t *soap_fault_text = NULL;
     
-    axis2_om_node_t *value_node  = NULL;
-    axis2_om_element_t *value_ele = NULL;
+    axiom_node_t *value_node  = NULL;
+    axiom_element_t *value_ele = NULL;
     
-    axis2_om_node_t *text_node = NULL;
-    axis2_om_element_t *text_ele = NULL;
+    axiom_node_t *text_node = NULL;
+    axiom_element_t *text_ele = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, code_value, NULL);
@@ -713,14 +713,14 @@
     if(!soap_fault_code)
     {
         AXIS2_SOAP_FAULT_FREE(soap_fault, env);
-        AXIS2_OM_NODE_FREE_TREE(fault_node, env);
+        AXIOM_NODE_FREE_TREE(fault_node, env);
         return NULL;
     }
     soap_fault_reason = axis2_soap_fault_reason_create_with_parent(env, soap_fault);
     if(!soap_fault_reason)
     {
         AXIS2_SOAP_FAULT_FREE(soap_fault, env);
-        AXIS2_OM_NODE_FREE_TREE(fault_node, env);
+        AXIOM_NODE_FREE_TREE(fault_node, env);
         return NULL;
     }
         
@@ -728,7 +728,7 @@
     if(!soap_fault_value)
     {
         AXIS2_SOAP_FAULT_FREE(soap_fault, env);
-        AXIS2_OM_NODE_FREE_TREE(fault_node, env);
+        AXIOM_NODE_FREE_TREE(fault_node, env);
         return NULL;
     }
     
@@ -737,15 +737,15 @@
     {
         return NULL;
     }
-    value_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(value_node, env);
+    value_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(value_node, env);
     
-    AXIS2_OM_ELEMENT_SET_TEXT(value_ele, env, code_value, value_node);
+    AXIOM_ELEMENT_SET_TEXT(value_ele, env, code_value, value_node);
     
     soap_fault_text = axis2_soap_fault_text_create_with_parent( env, soap_fault_reason);
     if(!soap_fault_text)
     {
         AXIS2_SOAP_FAULT_FREE(soap_fault, env);
-        AXIS2_OM_NODE_FREE_TREE(fault_node, env);
+        AXIOM_NODE_FREE_TREE(fault_node, env);
         return NULL;
     }
     AXIS2_SOAP_FAULT_TEXT_SET_LANG(soap_fault_text, env, "en");
@@ -755,9 +755,9 @@
     {
         return NULL;
     }
-    text_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(text_node, env);
+    text_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(text_node, env);
     
-    AXIS2_OM_ELEMENT_SET_TEXT(text_ele, env, reason_text, text_node);
+    AXIOM_ELEMENT_SET_TEXT(text_ele, env, reason_text, text_node);
     
     return soap_fault;
 }

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c Mon Jun 12 01:22:58 2006
@@ -26,7 +26,7 @@
  {
     axis2_soap_fault_code_t fault_code;
     
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     
     axis2_soap_fault_sub_code_t *subcode;
     
@@ -57,7 +57,7 @@
                                 const axis2_env_t *env);
                                      
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_code_get_base_node(axis2_soap_fault_code_t *fault_code,
                                     const axis2_env_t *env);
  
@@ -116,13 +116,13 @@
     axis2_soap_fault_code_impl_t *fault_code_impl = NULL;
     axis2_soap_fault_code_t *fault_code = NULL;
     
-    axis2_om_element_t *this_ele = NULL;
-    axis2_om_node_t *this_node = NULL;
+    axiom_element_t *this_ele = NULL;
+    axiom_node_t *this_node = NULL;
     
-    axis2_om_node_t *parent_node = NULL;
-    axis2_om_element_t *parent_ele = NULL;
+    axiom_node_t *parent_node = NULL;
+    axiom_element_t *parent_ele = NULL;
     
-    axis2_om_namespace_t *parent_ns = NULL;
+    axiom_namespace_t *parent_ns = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, fault, NULL);
@@ -139,7 +139,7 @@
         AXIS2_SOAP_FAULT_CODE_FREE(fault_code, env);
         return NULL;
     }        
-    parent_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    parent_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                         parent_node, env);
     
     if(!parent_ele)
@@ -151,9 +151,9 @@
                     axis2_soap_fault_get_soap_version(fault, env);
     if(fault_code_impl->soap_version == AXIS2_SOAP12)
     {
-        parent_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
+        parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     }
-    this_ele = axis2_om_element_create(env, 
+    this_ele = axiom_element_create(env, 
                                        parent_node,                             
                                        AXIS2_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME,
                                        parent_ns,
@@ -290,7 +290,7 @@
     else if(NULL != fault_code_impl->builder)
     {
         while(!(fault_code_impl->subcode) && 
-            !(AXIS2_OM_NODE_IS_COMPLETE(fault_code_impl->om_ele_node, env)))
+            !(AXIOM_NODE_IS_COMPLETE(fault_code_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_code_impl->builder, env);
             if(status == AXIS2_FAILURE)
@@ -321,7 +321,7 @@
     else if(fault_code_impl->builder)
     {
         while(!(fault_code_impl->value) && 
-            !(AXIS2_OM_NODE_IS_COMPLETE(fault_code_impl->om_ele_node, env)))
+            !(AXIOM_NODE_IS_COMPLETE(fault_code_impl->om_ele_node, env)))
         {
             status = AXIS2_SOAP_BUILDER_NEXT(fault_code_impl->builder, env);
             if(status == AXIS2_FAILURE)
@@ -336,7 +336,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_soap_fault_code_impl_t *fault_code_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -344,7 +344,7 @@
    
    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
    
-   if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+   if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
    {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
@@ -354,7 +354,7 @@
 
 }
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_code_get_base_node(axis2_soap_fault_code_t *fault_code,
                                     const axis2_env_t *env)
 {

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c Mon Jun 12 01:22:58 2006
@@ -15,8 +15,8 @@
  */
  
  #include "_axis2_soap_fault.h"
- #include <axis2_om_element.h>
- #include <axis2_om_node.h>
+ #include <axiom_element.h>
+ #include <axiom_node.h>
  #include "_axis2_soap_fault_detail.h"
  
 /******************** impl struct ********************************************/
@@ -25,7 +25,7 @@
  {
     axis2_soap_fault_detail_t fault_detail;
  
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     
  }axis2_soap_fault_detail_impl_t;
 
@@ -43,16 +43,16 @@
 axis2_soap_fault_detail_add_detail_entry
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env,
-                         axis2_om_node_t *ele_node);
+                         axiom_node_t *ele_node);
                             
-axis2_om_children_iterator_t* AXIS2_CALL 
+axiom_children_iterator_t* AXIS2_CALL 
 axis2_soap_fault_detail_get_all_detail_entries
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env); 
 
 
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_detail_get_base_node
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env);
@@ -111,11 +111,11 @@
 {
     axis2_soap_fault_detail_impl_t *fault_detail_impl = NULL;
     axis2_soap_fault_detail_t *fault_detail = NULL;
-    axis2_om_element_t *this_ele = NULL;
-    axis2_om_node_t *this_node = NULL;
-    axis2_om_node_t *parent_node = NULL;
-    axis2_om_element_t *parent_ele = NULL;
-    axis2_om_namespace_t *parent_ns = NULL;
+    axiom_element_t *this_ele = NULL;
+    axiom_node_t *this_node = NULL;
+    axiom_node_t *parent_node = NULL;
+    axiom_element_t *parent_ele = NULL;
+    axiom_namespace_t *parent_ns = NULL;
     int soap_version = -1;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -131,16 +131,16 @@
     if(!parent_node)
         return NULL;
         
-    parent_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    parent_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                         parent_node, env);
     if(!parent_ele)
         return NULL;
     soap_version = axis2_soap_fault_get_soap_version(fault, env);
     if(soap_version == AXIS2_SOAP12)
     {
-        parent_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
+        parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     }
-    this_ele = axis2_om_element_create(env, 
+    this_ele = axiom_element_create(env, 
                                        parent_node,                             
                                        AXIS2_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME,
                                        parent_ns,
@@ -174,38 +174,38 @@
 axis2_soap_fault_detail_add_detail_entry
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env,
-                         axis2_om_node_t *node)
+                         axiom_node_t *node)
 {
     axis2_soap_fault_detail_impl_t *fault_detail_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
     fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
         
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error, 
                 AXIS2_ERROR_OM_ELEMENT_EXPECTED, AXIS2_FAILURE);
         return AXIS2_FAILURE;                
     }
 
-    AXIS2_OM_NODE_ADD_CHILD(fault_detail_impl->om_ele_node,env, node);    
+    AXIOM_NODE_ADD_CHILD(fault_detail_impl->om_ele_node,env, node);    
     return AXIS2_SUCCESS;
 }
                             
-axis2_om_children_iterator_t* AXIS2_CALL 
+axiom_children_iterator_t* AXIS2_CALL 
 axis2_soap_fault_detail_get_all_detail_entries
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env)
 {
     axis2_soap_fault_detail_impl_t *fault_detail_impl = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
     if(fault_detail_impl->om_ele_node)
     {
-        om_ele = (axis2_om_element_t *)
-            AXIS2_OM_NODE_GET_DATA_ELEMENT(fault_detail_impl->om_ele_node, env);
-        return AXIS2_OM_ELEMENT_GET_CHILDREN(om_ele,  env,
+        om_ele = (axiom_element_t *)
+            AXIOM_NODE_GET_DATA_ELEMENT(fault_detail_impl->om_ele_node, env);
+        return AXIOM_ELEMENT_GET_CHILDREN(om_ele,  env,
                             fault_detail_impl->om_ele_node);
     } 
     return NULL;
@@ -216,14 +216,14 @@
 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_soap_fault_detail_impl_t *fault_detail_impl = NULL;
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
    fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
    
-   if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+   if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
    {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
@@ -232,7 +232,7 @@
    return AXIS2_SUCCESS;
 }
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_detail_get_base_node
                         (axis2_soap_fault_detail_t *fault_detail,
                          const axis2_env_t *env)

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c Mon Jun 12 01:22:58 2006
@@ -15,8 +15,8 @@
  */
  
  #include "_axis2_soap_fault_node.h"
- #include <axis2_om_node.h>
- #include <axis2_om_element.h>
+ #include <axiom_node.h>
+ #include <axiom_element.h>
  #include "_axis2_soap_fault.h"
 
  /********************* impl struct *******************************************/
@@ -25,7 +25,7 @@
  {
     axis2_soap_fault_node_t fault_node;
     
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     
  }axis2_soap_fault_node_impl_t;
  
@@ -52,7 +52,7 @@
                             
 
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_node_get_base_node
                           (axis2_soap_fault_node_t *fault_node,
                            const axis2_env_t *env);
@@ -109,13 +109,13 @@
     axis2_soap_fault_node_impl_t *fault_node_impl = NULL;
     axis2_soap_fault_node_t *fault_node = NULL;
     
-    axis2_om_element_t *this_ele = NULL;
-    axis2_om_node_t *this_node = NULL;
+    axiom_element_t *this_ele = NULL;
+    axiom_node_t *this_node = NULL;
     
-    axis2_om_node_t *parent_node = NULL;
-    axis2_om_element_t *parent_ele = NULL;
+    axiom_node_t *parent_node = NULL;
+    axiom_element_t *parent_ele = NULL;
     
-    axis2_om_namespace_t *parent_ns = NULL;
+    axiom_namespace_t *parent_ns = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, fault, NULL);
@@ -133,7 +133,7 @@
         return NULL;
     }
     
-    parent_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    parent_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                         parent_node, env);
     if(!parent_ele)
     {
@@ -141,9 +141,9 @@
         return NULL;
     }
     
-    parent_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
+    parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     
-    this_ele = axis2_om_element_create(env, 
+    this_ele = axiom_element_create(env, 
                                        parent_node,                             
                                        AXIS2_SOAP12_SOAP_FAULT_NODE_LOCAL_NAME,
                                        parent_ns,
@@ -184,7 +184,7 @@
                            axis2_char_t *uri)
 {
     axis2_soap_fault_node_impl_t *fault_node_impl = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
@@ -192,12 +192,12 @@
     fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
     if(NULL != fault_node_impl->om_ele_node)
     {
-        om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+        om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                     fault_node_impl->om_ele_node, env);
 
         if(NULL != om_ele)
         {
-            return AXIS2_OM_ELEMENT_SET_TEXT(om_ele, env, uri, 
+            return AXIOM_ELEMENT_SET_TEXT(om_ele, env, uri, 
                     fault_node_impl->om_ele_node);
         }
     }
@@ -211,17 +211,17 @@
                            const axis2_env_t *env)
 {
     axis2_soap_fault_node_impl_t *fault_node_impl = NULL;
-    axis2_om_element_t *om_ele =  NULL;
+    axiom_element_t *om_ele =  NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
     if(NULL != fault_node_impl->om_ele_node)
     {
-        om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+        om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
             fault_node_impl->om_ele_node, env);
         if(NULL != om_ele)
         {
-            return AXIS2_OM_ELEMENT_GET_TEXT(om_ele,
+            return AXIOM_ELEMENT_GET_TEXT(om_ele,
                             env, fault_node_impl->om_ele_node);
         }
     
@@ -233,13 +233,13 @@
 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_soap_fault_node_impl_t* fault_node_impl = NULL;
     fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node); 
     
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error, 
                 AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
@@ -251,7 +251,7 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_node_get_base_node
                           (axis2_soap_fault_node_t *fault_node,
                            const axis2_env_t *env)

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c Mon Jun 12 01:22:58 2006
@@ -16,7 +16,7 @@
  
 #include <axis2_soap_fault_reason.h>
 #include "_axis2_soap_fault.h"
-#include <axis2_om_element.h>
+#include <axiom_element.h>
 #include <axis2_soap_fault_text.h>
 #include <axis2_soap_builder.h>
 #include <axis2_soap_builder.h>
@@ -27,7 +27,7 @@
 {
     axis2_soap_fault_reason_t fault_reason;
     /* corresponding om element node */    
-    axis2_om_node_t *om_ele_node;
+    axiom_node_t *om_ele_node;
     
     axis2_array_list_t *fault_texts;
     /* pointer to soap builder */
@@ -53,7 +53,7 @@
                                  const axis2_env_t *env,
                                  axis2_char_t *lang);
                                 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_reason_get_base_node
                                 (axis2_soap_fault_reason_t *fault_reason,
                                  const axis2_env_t *env);
@@ -140,11 +140,11 @@
 {
     axis2_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     axis2_soap_fault_reason_t *fault_reason = NULL;
-    axis2_om_element_t *this_ele = NULL;
-    axis2_om_node_t *this_node = NULL;
-    axis2_om_node_t *parent_node = NULL;
-    axis2_om_element_t *parent_ele = NULL;
-    axis2_om_namespace_t *parent_ns = NULL;
+    axiom_element_t *this_ele = NULL;
+    axiom_node_t *this_node = NULL;
+    axiom_node_t *parent_node = NULL;
+    axiom_element_t *parent_ele = NULL;
+    axiom_namespace_t *parent_ns = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, fault, NULL);
@@ -159,7 +159,7 @@
     {
         return NULL;
     }
-    parent_ele  = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    parent_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                         parent_node, env);
     if(!parent_ele)
     {
@@ -169,9 +169,9 @@
         axis2_soap_fault_get_soap_version(fault, env);
     if(fault_reason_impl->soap_version == AXIS2_SOAP12)
     {
-        parent_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
+        parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     }
-    this_ele = axis2_om_element_create(env, 
+    this_ele = axiom_element_create(env, 
                                        parent_node,                             
                                        AXIS2_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME,
                                        parent_ns,
@@ -252,9 +252,9 @@
     {
     
         if(NULL != fault_reason_impl->soap_builder &&
-            !(AXIS2_OM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            !(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
         {
-            while(!(AXIS2_OM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            while(!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
             {
                 status = AXIS2_SOAP_BUILDER_NEXT(fault_reason_impl->soap_builder, env);
                 if(status == AXIS2_FAILURE)
@@ -292,7 +292,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_soap_fault_reason_impl_t *fault_reason_impl = NULL;
    
@@ -301,7 +301,7 @@
    
    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
    
-   if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+   if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
    {
         AXIS2_ERROR_SET(env->error, 
             AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
@@ -312,7 +312,7 @@
    return AXIS2_SUCCESS;
 }
 
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 axis2_soap_fault_reason_get_base_node
                                 (axis2_soap_fault_reason_t *fault_reason,
                                  const axis2_env_t *env)
@@ -345,9 +345,9 @@
     
     if(!(fault_reason_impl->fault_texts) && (NULL != fault_reason_impl->soap_builder))
     {
-       if(!(AXIS2_OM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+       if(!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
         {
-            while(!(AXIS2_OM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            while(!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
             {
                 status = AXIS2_SOAP_BUILDER_NEXT(fault_reason_impl->soap_builder, env);
                 if(status == AXIS2_FAILURE)
@@ -370,9 +370,9 @@
     
     if(!(fault_reason_impl->fault_texts) && (NULL != fault_reason_impl->soap_builder))
     {
-       if(!(AXIS2_OM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+       if(!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
         {
-            while(!(AXIS2_OM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            while(!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
             {
                 status = AXIS2_SOAP_BUILDER_NEXT(fault_reason_impl->soap_builder, env);
                 if(status == AXIS2_FAILURE)



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