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 [10/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/util/om_util.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/util/om_util.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/util/om_util.c (original)
+++ webservices/axis2/trunk/c/axiom/src/util/om_util.c Mon Jun 12 01:22:58 2006
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
  
-#include <axis2_om_node.h>
-#include <axis2_om_element.h>
+#include <axiom_node.h>
+#include <axiom_element.h>
 #include <axis2_array_list.h>
 
 
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_first_child_element_with_uri(
-        axis2_om_node_t *ele_node,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_first_child_element_with_uri(
+        axiom_node_t *ele_node,
         const axis2_env_t *env,
         axis2_char_t *uri,
-        axis2_om_node_t **child)
+        axiom_node_t **child)
 {
-    axis2_om_node_t *child_node = NULL;
+    axiom_node_t *child_node = NULL;
     
     if(!ele_node || !uri)
     {
@@ -35,21 +35,21 @@
         return NULL;
     }
 
-    child_node = AXIS2_OM_NODE_GET_FIRST_CHILD(ele_node, env);
+    child_node = AXIOM_NODE_GET_FIRST_CHILD(ele_node, env);
     while(NULL != child_node)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child_node, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child_node, env) == AXIOM_ELEMENT)
         {
-            axis2_om_element_t *child_ele = NULL;
-            axis2_om_namespace_t *ns = NULL;
+            axiom_element_t *child_ele = NULL;
+            axiom_namespace_t *ns = NULL;
             
-            child_ele = (axis2_om_element_t*)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(child_node, env);
-            ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(child_ele, env, child_node);
+            child_ele = (axiom_element_t*)
+                AXIOM_NODE_GET_DATA_ELEMENT(child_node, env);
+            ns = AXIOM_ELEMENT_GET_NAMESPACE(child_ele, env, child_node);
             if(NULL != ns)
             {
                 axis2_char_t *child_uri = NULL;
-                child_uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
+                child_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
                 if(NULL != child_uri && AXIS2_STRCMP(child_uri, uri) == 0)
                 {
                     (*child) = child_node;
@@ -57,20 +57,20 @@
                 }
             }
         }    
-        child_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(child_node, env);
+        child_node = AXIOM_NODE_GET_NEXT_SIBLING(child_node, env);
     }
     return NULL;
 }        
         
         
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_next_sibling_element_with_uri(
-        axis2_om_node_t *ele_node,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_next_sibling_element_with_uri(
+        axiom_node_t *ele_node,
         const axis2_env_t *env,
         axis2_char_t *uri,
-        axis2_om_node_t **next_node)
+        axiom_node_t **next_node)
 {
-    axis2_om_node_t *next_sib_node = NULL;
+    axiom_node_t *next_sib_node = NULL;
     if(!ele_node || !uri)
     {
         AXIS2_ERROR_SET(env->error, 
@@ -78,21 +78,21 @@
         return NULL;
     }
 
-    next_sib_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(ele_node, env);
+    next_sib_node = AXIOM_NODE_GET_NEXT_SIBLING(ele_node, env);
     while(NULL != next_sib_node)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sib_node, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sib_node, env) == AXIOM_ELEMENT)
         {
-            axis2_om_element_t *sib_ele = NULL;
-            axis2_om_namespace_t *ns = NULL;
+            axiom_element_t *sib_ele = NULL;
+            axiom_namespace_t *ns = NULL;
             
-            sib_ele = (axis2_om_element_t*)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sib_node, env);
-            ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(sib_ele, env, next_sib_node);
+            sib_ele = (axiom_element_t*)
+                AXIOM_NODE_GET_DATA_ELEMENT(next_sib_node, env);
+            ns = AXIOM_ELEMENT_GET_NAMESPACE(sib_ele, env, next_sib_node);
             if(NULL != ns)
             {
                 axis2_char_t *sib_uri = NULL;
-                sib_uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
+                sib_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
                 if(NULL != sib_uri && AXIS2_STRCMP(sib_uri, uri) == 0)
                 {
                     (*next_node) = next_sib_node;
@@ -100,102 +100,102 @@
                 }
             }
         }    
-        next_sib_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sib_node, env);
+        next_sib_node = AXIOM_NODE_GET_NEXT_SIBLING(next_sib_node, env);
     }
     return NULL;
 }        
         
         
 
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_first_child_element(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_first_child_element(axiom_element_t *ele,
                                       const axis2_env_t *env,
-                                      axis2_om_node_t *ele_node,
-                                      axis2_om_node_t **child_node)
+                                      axiom_node_t *ele_node,
+                                      axiom_node_t **child_node)
 {
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     
-    return AXIS2_OM_ELEMENT_GET_FIRST_ELEMENT(ele, env, ele_node, child_node);
+    return AXIOM_ELEMENT_GET_FIRST_ELEMENT(ele, env, ele_node, child_node);
 }                                      
                                       
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_last_child_element(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_last_child_element(axiom_element_t *ele,
                                      const axis2_env_t *env,
-                                     axis2_om_node_t *ele_node,
-                                     axis2_om_node_t **child_node)
+                                     axiom_node_t *ele_node,
+                                     axiom_node_t **child_node)
 {
-    axis2_om_node_t *last_node = NULL;
+    axiom_node_t *last_node = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     
-    last_node = AXIS2_OM_NODE_GET_LAST_CHILD(ele_node, env);
+    last_node = AXIOM_NODE_GET_LAST_CHILD(ele_node, env);
     while(NULL != last_node)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(last_node, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(last_node, env) == AXIOM_ELEMENT)
         {
             *child_node = last_node;
-            return (axis2_om_element_t*)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(last_node, env);
+            return (axiom_element_t*)
+                AXIOM_NODE_GET_DATA_ELEMENT(last_node, env);
         
         }
-        last_node = AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(ele_node, env);
+        last_node = AXIOM_NODE_GET_PREVIOUS_SIBLING(ele_node, env);
     }
     return NULL;    
 }                                     
                                      
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_next_sibling_element(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_next_sibling_element(axiom_element_t *ele,
                                        const axis2_env_t *env,
-                                       axis2_om_node_t *ele_node,
-                                       axis2_om_node_t **next_node)
+                                       axiom_node_t *ele_node,
+                                       axiom_node_t **next_node)
 {
-    axis2_om_node_t *next_sibling = NULL;
+    axiom_node_t *next_sibling = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
 
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(ele_node, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(ele_node, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
             *next_node = next_sibling;
-            return (axis2_om_element_t *)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            return (axiom_element_t *)
+                AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);
     }
     return NULL;
 }                                       
                                        
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_first_child_element_with_localname(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_first_child_element_with_localname(axiom_element_t *ele,
                                              const axis2_env_t *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child = NULL;
-    axis2_om_node_t *next_sibling = NULL;
+    axiom_node_t *child = NULL;
+    axiom_node_t *next_sibling = NULL;
     axis2_char_t *child_localname = NULL;
-    axis2_om_element_t *om_ele  = NULL;
+    axiom_element_t *om_ele  = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     AXIS2_PARAM_CHECK(env->error, localname, NULL);
     
-    child = AXIS2_OM_NODE_GET_FIRST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_FIRST_CHILD(ele_node, env);
     if(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(child, env);
+            om_ele = (axiom_element_t *)
+                        AXIOM_NODE_GET_DATA_ELEMENT(child, env);
             if(NULL != om_ele)
             {
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && AXIS2_STRCMP(child_localname, localname) == 0)
                 {
                     *child_node = child;
@@ -207,15 +207,15 @@
         child_localname = NULL;
     }
     
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(child, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && AXIS2_STRCMP(child_localname, localname) == 0)
                 {
                     *child_node = next_sibling;
@@ -226,21 +226,21 @@
             om_ele = NULL;
             child_localname = NULL;
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
     }  
     return NULL;
 }                                             
                                              
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_last_child_element_with_localname(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_last_child_element_with_localname(axiom_element_t *ele,
                                              const axis2_env_t *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_node_t *child = NULL;
+    axiom_element_t *om_ele = NULL;
     axis2_char_t *child_localname = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -248,16 +248,16 @@
     AXIS2_PARAM_CHECK(env->error, localname, NULL);
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     
-    child = AXIS2_OM_NODE_GET_LAST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_LAST_CHILD(ele_node, env);
     while(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)  
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(ele_node, env);
+            om_ele = (axiom_element_t*)  
+                        AXIOM_NODE_GET_DATA_ELEMENT(ele_node, env);
             if(NULL != om_ele)
             {
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && 
                     AXIS2_STRCMP(child_localname, localname) == 0)
                 {
@@ -269,35 +269,35 @@
             om_ele = NULL;
             child_localname = NULL;
         }
-        child = AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(child, env);                
+        child = AXIOM_NODE_GET_PREVIOUS_SIBLING(child, env);                
     }
     return NULL;
 }                                             
                                                                                          
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_next_siblng_element_with_localname(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_next_siblng_element_with_localname(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
-                                             axis2_om_node_t **next_node)
+                                             axiom_node_t **next_node)
 {
-    axis2_om_node_t *next_sibling = NULL;
-    axis2_om_element_t *om_ele    = NULL;
+    axiom_node_t *next_sibling = NULL;
+    axiom_element_t *om_ele    = NULL;
     axis2_char_t *ele_localname   = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
 
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(ele_node, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(ele_node, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t *)
+                        AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
-                ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != ele_localname && AXIS2_STRCMP(localname, ele_localname) == 0)
                 {
                     *next_node = next_sibling;
@@ -307,24 +307,24 @@
             om_ele = NULL;
             ele_localname = NULL;                        
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);
     }
     return NULL;
 }                                             
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_first_child_element_with_uri_localname(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_first_child_element_with_uri_localname(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
                                              axis2_char_t *uri,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child = NULL;
-    axis2_om_node_t *next_sibling = NULL;
+    axiom_node_t *child = NULL;
+    axiom_node_t *next_sibling = NULL;
     axis2_char_t *child_localname = NULL;
-    axis2_om_element_t *om_ele  = NULL;
-    axis2_om_namespace_t *ns    = NULL;
+    axiom_element_t *om_ele  = NULL;
+    axiom_namespace_t *ns    = NULL;
     axis2_char_t *ns_uri        = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -333,22 +333,22 @@
     AXIS2_PARAM_CHECK(env->error, localname, NULL);
     AXIS2_PARAM_CHECK(env->error, uri, NULL);
      
-    child = AXIS2_OM_NODE_GET_FIRST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_FIRST_CHILD(ele_node, env);
     if(!child)
     {
         return NULL;
         
     }
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(ele_node, env) == AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(ele_node, env) == AXIOM_ELEMENT)
     {
-        om_ele = (axis2_om_element_t *)
-                    AXIS2_OM_NODE_GET_DATA_ELEMENT(child , env);
+        om_ele = (axiom_element_t *)
+                    AXIOM_NODE_GET_DATA_ELEMENT(child , env);
         if(NULL != om_ele)
         {
-            child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
-            ns              = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, child);
+            child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
+            ns              = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, child);
             if(NULL != ns)
-                ns_uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
+                ns_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
                 
             if((NULL != child_localname) && 
                 (AXIS2_STRCMP(child_localname, localname) == 0) && (NULL != ns_uri) 
@@ -364,18 +364,18 @@
     ns = NULL;
     ns_uri = NULL;
     
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(child, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
-                ns              = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, next_sibling);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                ns              = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, next_sibling);
                 if(NULL != ns)
-                    ns_uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
+                    ns_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
                     
                 if((NULL != child_localname) && 
                     (AXIS2_STRCMP(child_localname, localname) == 0) && (NULL != ns_uri) &&
@@ -391,22 +391,22 @@
             ns = NULL;
             ns_uri = NULL;
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
     }  
     return NULL;
 }                                                                                                                                                             
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_last_child_element_with_uri_localname(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_last_child_element_with_uri_localname(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
                                              axis2_char_t *uri,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child          = NULL;
-    axis2_om_element_t *om_ele      = NULL;
+    axiom_node_t *child          = NULL;
+    axiom_element_t *om_ele      = NULL;
     axis2_char_t *child_localname   = NULL;
-    axis2_om_namespace_t *ns        = NULL;
+    axiom_namespace_t *ns        = NULL;
     axis2_char_t *ns_uri            = NULL;
                
     AXIS2_ENV_CHECK(env, NULL);
@@ -415,19 +415,19 @@
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     AXIS2_PARAM_CHECK(env->error, uri, NULL);        
     
-    child = AXIS2_OM_NODE_GET_LAST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_LAST_CHILD(ele_node, env);
     while(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)  
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(ele_node, env);
+            om_ele = (axiom_element_t*)  
+                        AXIOM_NODE_GET_DATA_ELEMENT(ele_node, env);
             if(NULL != om_ele)
             {
-                ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, ele_node);
+                ns = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, ele_node);
                 if(NULL != ns)
-                    ns_uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                    ns_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && 
                     (AXIS2_STRCMP(child_localname, localname) == 0) && (NULL != ns_uri)
                     && (AXIS2_STRCMP(ns_uri, uri) == 0))
@@ -441,40 +441,40 @@
             ns = NULL;
             ns_uri = NULL;
         }
-        child = AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(child, env);                
+        child = AXIOM_NODE_GET_PREVIOUS_SIBLING(child, env);                
     }
     return NULL;
 }
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_next_sibling_element_with_uri_localname(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_next_sibling_element_with_uri_localname(axiom_element_t *ele,
                                              const axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
                                              axis2_char_t *uri,
-                                             axis2_om_node_t **next_node)
+                                             axiom_node_t **next_node)
 {
-    axis2_om_node_t *next_sibling = NULL;
-    axis2_om_element_t *om_ele    = NULL;
+    axiom_node_t *next_sibling = NULL;
+    axiom_element_t *om_ele    = NULL;
     axis2_char_t *ele_localname   = NULL;
-    axis2_om_namespace_t *ns      = NULL;
+    axiom_namespace_t *ns      = NULL;
     axis2_char_t *ns_uri          = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
 
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(ele_node, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(ele_node, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t *)
+                        AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
-                ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, next_sibling);
+                ns = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, next_sibling);
                 if(NULL != ns)
-                    ns_uri = AXIS2_OM_NAMESPACE_GET_URI(ns, env);
-                ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                    ns_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
+                ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != ele_localname && 
                     (AXIS2_STRCMP(localname, ele_localname) == 0) && (NULL != ns) 
                     && (AXIS2_STRCMP(ns_uri, uri) == 0))
@@ -488,23 +488,23 @@
             ns_uri = NULL;
             ns = NULL; 
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);
     }
     return NULL;
 }                                             
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_first_child_element_with_localnames(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_first_child_element_with_localnames(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_array_list_t *names,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child = NULL;
-    axis2_om_node_t *next_sibling = NULL;
+    axiom_node_t *child = NULL;
+    axiom_node_t *next_sibling = NULL;
     axis2_char_t *child_localname = NULL;
     axis2_char_t *given_localname = NULL;
-    axis2_om_element_t *om_ele  = NULL;
+    axiom_element_t *om_ele  = NULL;
     int size = 0;
     int i    = 0;
     AXIS2_ENV_CHECK(env, NULL);
@@ -512,17 +512,17 @@
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     AXIS2_PARAM_CHECK(env->error, names, NULL);
     
-    child = AXIS2_OM_NODE_GET_FIRST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_FIRST_CHILD(ele_node, env);
     if(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(child, env);
+            om_ele = (axiom_element_t *)
+                        AXIOM_NODE_GET_DATA_ELEMENT(child, env);
             if(NULL != om_ele)
             {
                 size = AXIS2_ARRAY_LIST_SIZE(names, env);
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
 
                 for(i =0; i < size; i++)
                 {
@@ -544,16 +544,16 @@
         size = 0;
     }
     
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(child, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
                 size = AXIS2_ARRAY_LIST_SIZE(names, env);
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 for(i = 0; i < size; i++)
                 {
                     given_localname = (axis2_char_t *)AXIS2_ARRAY_LIST_GET(names, env, i);
@@ -570,22 +570,22 @@
             child_localname = NULL;
             given_localname = NULL;
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
     }  
     return NULL;
    
 }                                             
                                              
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_last_child_element_with_localnames(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_last_child_element_with_localnames(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_array_list_t *names,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_node_t *child = NULL;
+    axiom_element_t *om_ele = NULL;
     axis2_char_t *child_localname = NULL;
     axis2_char_t *given_localname = NULL;
     int size = 0;
@@ -596,20 +596,20 @@
     AXIS2_PARAM_CHECK(env->error, names, NULL);
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     
-    child = AXIS2_OM_NODE_GET_LAST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_LAST_CHILD(ele_node, env);
     while(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)  
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(ele_node, env);
+            om_ele = (axiom_element_t*)  
+                        AXIOM_NODE_GET_DATA_ELEMENT(ele_node, env);
             if(NULL != om_ele)
             {
                 size = AXIS2_ARRAY_LIST_SIZE(names, env);
                 for(i = 0; i < size; i++)
                 {
                     given_localname = (axis2_char_t *)AXIS2_ARRAY_LIST_GET(names, env, i);
-                    child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                    child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                     if(NULL != child_localname && (NULL != given_localname) &&
                         (AXIS2_STRCMP(child_localname, given_localname) == 0))
                     {
@@ -622,20 +622,20 @@
             child_localname = NULL;
             given_localname = NULL;
         }
-        child = AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(child, env);                
+        child = AXIOM_NODE_GET_PREVIOUS_SIBLING(child, env);                
     }
     return NULL;
 }                                             
                                                                                          
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_next_siblng_element_with_localnames(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_next_siblng_element_with_localnames(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_array_list_t *names,
-                                             axis2_om_node_t **next_node)
+                                             axiom_node_t **next_node)
 {
-    axis2_om_node_t *next_sibling = NULL;
-    axis2_om_element_t *om_ele    = NULL;
+    axiom_node_t *next_sibling = NULL;
+    axiom_element_t *om_ele    = NULL;
     axis2_char_t *ele_localname   = NULL;
     axis2_char_t *given_localname = NULL;
     int size = 0;
@@ -646,20 +646,20 @@
     AXIS2_PARAM_CHECK(env->error, next_node, NULL);
     
 
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(ele_node, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(ele_node, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                    AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t *)
+                    AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
                 size = AXIS2_ARRAY_LIST_SIZE(names, env);
                 for(i = 0; i < size; i++)
                 {
                     given_localname = (axis2_char_t *)AXIS2_ARRAY_LIST_GET(names, env, i);
-                    ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                    ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                     if((NULL != ele_localname) && (NULL != given_localname) && 
                         (AXIS2_STRCMP(given_localname, ele_localname) == 0))
                     {
@@ -672,25 +672,25 @@
             om_ele = NULL;
             ele_localname = NULL;                        
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);
     }
     return NULL;    
 }                                              
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_first_child_element_with_localname_attr(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_first_child_element_with_localname_attr(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
                                              axis2_char_t *attr_name,
                                              axis2_char_t *attr_value,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child          = NULL;
-    axis2_om_node_t *next_sibling   = NULL;
+    axiom_node_t *child          = NULL;
+    axiom_node_t *next_sibling   = NULL;
     axis2_char_t *child_localname   = NULL;
-    axis2_om_element_t *om_ele      = NULL;
-    axis2_om_attribute_t *om_attr   = NULL;
+    axiom_element_t *om_ele      = NULL;
+    axiom_attribute_t *om_attr   = NULL;
     axis2_hash_t *attr_ht           = NULL;
     axis2_hash_index_t *hi          = NULL; 
     axis2_char_t *om_attr_value     = NULL;
@@ -703,21 +703,21 @@
     AXIS2_PARAM_CHECK(env->error, attr_name, NULL);
     AXIS2_PARAM_CHECK(env->error, attr_value, NULL);
     
-    child = AXIS2_OM_NODE_GET_FIRST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_FIRST_CHILD(ele_node, env);
 
     if(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(child, env);
+            om_ele = (axiom_element_t *)
+                        AXIOM_NODE_GET_DATA_ELEMENT(child, env);
             if(NULL != om_ele)
             {
                 
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && AXIS2_STRCMP(child_localname, localname) == 0)
                 {
-                    attr_ht = AXIS2_OM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
+                    attr_ht = AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
                     if(NULL != attr_ht)
                     {
                         
@@ -728,12 +728,12 @@
                             axis2_hash_this(hi, NULL, NULL, &val);
                             if(NULL != val)
                             {
-                                om_attr = (axis2_om_attribute_t *)val;
+                                om_attr = (axiom_attribute_t *)val;
                                 om_attr_name = 
-                                    AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
+                                    AXIOM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
                                     
                                 om_attr_value =
-                                    AXIS2_OM_ATTRIBUTE_GET_VALUE(om_attr, env); 
+                                    AXIOM_ATTRIBUTE_GET_VALUE(om_attr, env); 
                                 if(NULL != om_attr_name && NULL != om_attr_value &&
                                 AXIS2_STRCMP(om_attr_name, attr_name) == 0 &&
                                 AXIS2_STRCMP(om_attr_value, attr_value) == 0)
@@ -755,18 +755,18 @@
         hi = NULL;
     }
 
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(child, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && AXIS2_STRCMP(child_localname, localname) == 0)
                 {
-                    attr_ht = AXIS2_OM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
+                    attr_ht = AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
                     if(NULL != attr_ht)
                     {
                         
@@ -777,12 +777,12 @@
                             axis2_hash_this(hi, NULL, NULL, &val);
                             if(NULL != val)
                             {
-                                om_attr = (axis2_om_attribute_t *)val;
+                                om_attr = (axiom_attribute_t *)val;
                                 om_attr_name = 
-                                    AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
+                                    AXIOM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
                                     
                                 om_attr_value =
-                                    AXIS2_OM_ATTRIBUTE_GET_VALUE(om_attr, env); 
+                                    AXIOM_ATTRIBUTE_GET_VALUE(om_attr, env); 
                     
                                 if(NULL != om_attr_name && NULL != om_attr_value &&
                                 AXIS2_STRCMP(om_attr_name, attr_name) == 0 &&
@@ -803,25 +803,25 @@
             om_ele = NULL;
             child_localname = NULL;
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);  
     }  
     return NULL;
 }                                             
                                              
                                              
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_last_child_element_with_localname_attr(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_last_child_element_with_localname_attr(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
                                              axis2_char_t *attr_name,
                                              axis2_char_t *attr_value,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *child = NULL;
-    axis2_om_element_t *om_ele = NULL;
+    axiom_node_t *child = NULL;
+    axiom_element_t *om_ele = NULL;
     axis2_char_t *child_localname = NULL;
-    axis2_om_attribute_t *om_attr = NULL;
+    axiom_attribute_t *om_attr = NULL;
     axis2_char_t *om_attr_name = NULL;
     axis2_char_t *om_attr_value = NULL;
     axis2_hash_index_t *hi      = NULL;
@@ -832,20 +832,20 @@
     AXIS2_PARAM_CHECK(env->error, localname, NULL);
     AXIS2_PARAM_CHECK(env->error, child_node, NULL);
     
-    child = AXIS2_OM_NODE_GET_LAST_CHILD(ele_node, env);
+    child = AXIOM_NODE_GET_LAST_CHILD(ele_node, env);
     while(NULL != child)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(child, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(child, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t*)  
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(ele_node, env);
+            om_ele = (axiom_element_t*)  
+                        AXIOM_NODE_GET_DATA_ELEMENT(ele_node, env);
             if(NULL != om_ele)
             {
-                child_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                child_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != child_localname && 
                     AXIS2_STRCMP(child_localname, localname) == 0)
                 {
-                    attr_ht = AXIS2_OM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
+                    attr_ht = AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
                     if(NULL != attr_ht)
                     {
                         
@@ -856,12 +856,12 @@
                             axis2_hash_this(hi, NULL, NULL, &val);
                             if(NULL != val)
                             {
-                                om_attr = (axis2_om_attribute_t *)val;
+                                om_attr = (axiom_attribute_t *)val;
                                 om_attr_name = 
-                                    AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
+                                    AXIOM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
                                     
                                 om_attr_value =
-                                    AXIS2_OM_ATTRIBUTE_GET_VALUE(om_attr, env); 
+                                    AXIOM_ATTRIBUTE_GET_VALUE(om_attr, env); 
                     
                                 if(NULL != om_attr_name && NULL != om_attr_value &&
                                 AXIS2_STRCMP(om_attr_name, attr_name) == 0 &&
@@ -883,24 +883,24 @@
             om_ele = NULL;
             child_localname = NULL;
         }
-        child = AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(child, env);                
+        child = AXIOM_NODE_GET_PREVIOUS_SIBLING(child, env);                
     }
     return NULL;
 }                                             
                                                                                          
-AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-axis2_om_util_get_next_siblng_element_with_localname_attr(axis2_om_element_t *ele,
+AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+axiom_util_get_next_siblng_element_with_localname_attr(axiom_element_t *ele,
                                              axis2_env_t  *env,
-                                             axis2_om_node_t *ele_node,
+                                             axiom_node_t *ele_node,
                                              axis2_char_t *localname,
                                              axis2_char_t *attr_name,
                                              axis2_char_t *attr_value,
-                                             axis2_om_node_t **child_node)
+                                             axiom_node_t **child_node)
 {
-    axis2_om_node_t *next_sibling = NULL;
-    axis2_om_element_t *om_ele    = NULL;
+    axiom_node_t *next_sibling = NULL;
+    axiom_element_t *om_ele    = NULL;
     axis2_char_t *ele_localname   = NULL;
-    axis2_om_attribute_t *om_attr = NULL;
+    axiom_attribute_t *om_attr = NULL;
     axis2_char_t *om_attr_value   = NULL;
     axis2_char_t *om_attr_name    = NULL;
     axis2_hash_t *attr_ht         = NULL;
@@ -910,19 +910,19 @@
     AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
     
     
-    next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(ele_node, env);
+    next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(ele_node, env);
     while(NULL != next_sibling)
     {
-        if(AXIS2_OM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIS2_OM_ELEMENT)
+        if(AXIOM_NODE_GET_NODE_TYPE(next_sibling, env) == AXIOM_ELEMENT)
         {
-            om_ele = (axis2_om_element_t *)
-                        AXIS2_OM_NODE_GET_DATA_ELEMENT(next_sibling, env);
+            om_ele = (axiom_element_t *)
+                        AXIOM_NODE_GET_DATA_ELEMENT(next_sibling, env);
             if(NULL != om_ele)
             {
-                ele_localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+                ele_localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
                 if(NULL != ele_localname && AXIS2_STRCMP(localname, ele_localname) == 0)
                 {
-                    attr_ht = AXIS2_OM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
+                    attr_ht = AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(om_ele, env);
                     if(NULL != attr_ht)
                     {
                         
@@ -933,12 +933,12 @@
                             axis2_hash_this(hi, NULL, NULL, &val);
                             if(NULL != val)
                             {
-                                om_attr = (axis2_om_attribute_t *)val;
+                                om_attr = (axiom_attribute_t *)val;
                                 om_attr_name = 
-                                    AXIS2_OM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
+                                    AXIOM_ATTRIBUTE_GET_LOCALNAME(om_attr, env);
                                     
                                 om_attr_value =
-                                    AXIS2_OM_ATTRIBUTE_GET_VALUE(om_attr, env); 
+                                    AXIOM_ATTRIBUTE_GET_VALUE(om_attr, env); 
                     
                                 if(NULL != om_attr_name && NULL != om_attr_value &&
                                 AXIS2_STRCMP(om_attr_name, attr_name) == 0 &&
@@ -959,83 +959,83 @@
             om_ele = NULL;
             ele_localname = NULL;                        
         }
-        next_sibling = AXIS2_OM_NODE_GET_NEXT_SIBLING(next_sibling, env);
+        next_sibling = AXIOM_NODE_GET_NEXT_SIBLING(next_sibling, env);
     }
     return NULL;
 }                                             
                                                                             
 AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-axis2_om_util_get_child_node_text(axis2_om_node_t *om_node,
+axiom_util_get_child_node_text(axiom_node_t *om_node,
                              const axis2_env_t *env)
 {
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     AXIS2_ENV_CHECK(env , NULL);
     if(NULL == om_node)
         return NULL;
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(om_node, env) != AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(om_node, env) != AXIOM_ELEMENT)
         return NULL;
     
-    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(NULL != om_ele)
     {
-        return AXIS2_OM_ELEMENT_GET_TEXT(om_ele, env, om_node);
+        return AXIOM_ELEMENT_GET_TEXT(om_ele, env, om_node);
     }
     return NULL;
 }                             
                              
 AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-axis2_om_util_get_localname(axis2_om_node_t *node,
+axiom_util_get_localname(axiom_node_t *node,
                             const axis2_env_t *env)
 {
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     if(NULL == node)
         return NULL;
-    if(AXIS2_OM_NODE_GET_NODE_TYPE(node, env) != AXIS2_OM_ELEMENT)
+    if(AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
         return NULL;
-    om_ele = (axis2_om_element_t *)AXIS2_OM_NODE_GET_NODE_TYPE(node, env);
+    om_ele = (axiom_element_t *)AXIOM_NODE_GET_NODE_TYPE(node, env);
     if(NULL != om_ele)
-        return AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+        return AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
     return NULL;
 }                            
     
 AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-axis2_om_util_get_node_namespace_uri(axis2_om_node_t *om_node,
+axiom_util_get_node_namespace_uri(axiom_node_t *om_node,
                                      const axis2_env_t *env)
 {
-    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;
     if(!om_node)
         return NULL;
-    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_NODE_GET_DATA_ELEMENT(om_node, env);
+        om_ele = AXIOM_NODE_GET_DATA_ELEMENT(om_node, env);
         if(NULL == om_ele)
             return NULL;
-        om_ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(om_ele, env, om_node);
+        om_ns = AXIOM_ELEMENT_GET_NAMESPACE(om_ele, env, om_node);
         if(NULL != om_ns)
-            return AXIS2_OM_NAMESPACE_GET_URI(om_ns, env);                    
+            return AXIOM_NAMESPACE_GET_URI(om_ns, env);                    
     }        
     return NULL;
 } 
 
-AXIS2_EXTERN axis2_om_child_element_iterator_t* AXIS2_CALL
-axis2_om_util_get_child_elements(axis2_om_element_t *om_ele, 
+AXIS2_EXTERN axiom_child_element_iterator_t* AXIS2_CALL
+axiom_util_get_child_elements(axiom_element_t *om_ele, 
                                  const axis2_env_t *env,
-                                 axis2_om_node_t *om_node)
+                                 axiom_node_t *om_node)
 {
-    axis2_om_element_t *first_ele = NULL;
-    axis2_om_node_t *first_node   = NULL;
+    axiom_element_t *first_ele = NULL;
+    axiom_node_t *first_node   = NULL;
     AXIS2_PARAM_CHECK(env->error, om_node, NULL);
     AXIS2_PARAM_CHECK(env->error, om_ele, NULL);
     first_ele = 
-        AXIS2_OM_ELEMENT_GET_FIRST_ELEMENT(om_ele, env, om_node, &first_node);
+        AXIOM_ELEMENT_GET_FIRST_ELEMENT(om_ele, env, om_node, &first_node);
     if(NULL != first_ele)
     {
-        return axis2_om_child_element_iterator_create(env, first_node);
+        return axiom_child_element_iterator_create(env, first_node);
     }        
     return NULL;
 }

Modified: webservices/axis2/trunk/c/axiom/test/om/test_om.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/om/test_om.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/om/test_om.c (original)
+++ webservices/axis2/trunk/c/axiom/test/om/test_om.c Mon Jun 12 01:22:58 2006
@@ -14,11 +14,11 @@
  *   limitations under the License.
  */
 
-#include <axis2_om_stax_builder.h>
-#include <axis2_om_document.h>
-#include <axis2_om_node.h>
-#include <axis2_om_element.h>
-#include <axis2_om_text.h>
+#include <axiom_stax_builder.h>
+#include <axiom_document.h>
+#include <axiom_node.h>
+#include <axiom_element.h>
+#include <axiom_text.h>
 #include <axis2_stream.h>
 #include <axis2_log_default.h>
 #include <axis2_error_default.h>
@@ -58,13 +58,13 @@
 int
 test_om_build (const char *filename)
 {
-    axis2_om_element_t *ele1 = NULL, *ele2 = NULL;
-    axis2_om_stax_builder_t *builder = NULL;
-    axis2_om_text_t *text = NULL;
-    axis2_om_document_t *document = NULL;
-    axis2_om_node_t *node1 = NULL, *node2 = NULL;
-    axis2_om_output_t *om_output = NULL;
-    axis2_om_namespace_t* ns = NULL;
+    axiom_element_t *ele1 = NULL, *ele2 = NULL;
+    axiom_stax_builder_t *builder = NULL;
+    axiom_text_t *text = NULL;
+    axiom_document_t *document = NULL;
+    axiom_node_t *node1 = NULL, *node2 = NULL;
+    axiom_output_t *om_output = NULL;
+    axiom_namespace_t* ns = NULL;
     axis2_xml_reader_t *reader = NULL;
     axis2_xml_writer_t *writer = NULL;
     char *buffer = NULL;
@@ -80,9 +80,9 @@
         printf("ERROR CREATING PULLPARSER");
         return -1;
     }
-    /** create axis2_om_stax_builder by parsing pull_parser struct */
+    /** create axiom_stax_builder by parsing pull_parser struct */
     
-    builder = axis2_om_stax_builder_create (environment,reader);
+    builder = axiom_stax_builder_create (environment,reader);
     
     if(!builder)
     {
@@ -94,18 +94,18 @@
         document is the container of om model created using builder 
     */
            
-    document = AXIS2_OM_STAX_BUILDER_GET_DOCUMENT (builder, environment);
+    document = AXIOM_STAX_BUILDER_GET_DOCUMENT (builder, environment);
     /**
         get root element , building starts hear 
      */
     if(!document)
         return -1;
 
-    node1 = AXIS2_OM_DOCUMENT_GET_ROOT_ELEMENT (document, environment);
+    node1 = AXIOM_DOCUMENT_GET_ROOT_ELEMENT (document, environment);
     if(!node1)
     {
         printf(" root element null ");
-        AXIS2_OM_STAX_BUILDER_FREE(builder, environment);
+        AXIOM_STAX_BUILDER_FREE(builder, environment);
         return -1;
     }
     if(node1)
@@ -113,52 +113,52 @@
         /** print root node information */
         
        
-        ele1 =AXIS2_OM_NODE_GET_DATA_ELEMENT(node1,environment);
+        ele1 =AXIOM_NODE_GET_DATA_ELEMENT(node1,environment);
         if(ele1)
              
-        printf ("root localname %s\n",AXIS2_OM_ELEMENT_GET_LOCALNAME(ele1,environment));
+        printf ("root localname %s\n",AXIOM_ELEMENT_GET_LOCALNAME(ele1,environment));
          
-        ns = AXIS2_OM_ELEMENT_GET_NAMESPACE(ele1,environment, node1);
+        ns = AXIOM_ELEMENT_GET_NAMESPACE(ele1,environment, node1);
     
         if (ns)
         {
-            printf ("root ns prefix %s\n", AXIS2_OM_NAMESPACE_GET_PREFIX(ns,environment));
-            printf ("root ns uri %s\n", AXIS2_OM_NAMESPACE_GET_URI(ns,environment));
+            printf ("root ns prefix %s\n", AXIOM_NAMESPACE_GET_PREFIX(ns,environment));
+            printf ("root ns uri %s\n", AXIOM_NAMESPACE_GET_URI(ns,environment));
 
         }
     }
     /** build the document continuously untill all the xml file is built in to a om model */
     
     
-    node2 = AXIS2_OM_DOCUMENT_BUILD_NEXT( document , environment);
+    node2 = AXIOM_DOCUMENT_BUILD_NEXT( document , environment);
     do
     {
 
         if (!node2)
             break;
 
-        switch (AXIS2_OM_NODE_GET_NODE_TYPE(node2,environment))
+        switch (AXIOM_NODE_GET_NODE_TYPE(node2,environment))
         {
-        case AXIS2_OM_ELEMENT:
-            ele2 =(axis2_om_element_t*) AXIS2_OM_NODE_GET_DATA_ELEMENT(node2, environment);
-            if(ele2 && AXIS2_OM_ELEMENT_GET_LOCALNAME(ele2,environment))
+        case AXIOM_ELEMENT:
+            ele2 =(axiom_element_t*) AXIOM_NODE_GET_DATA_ELEMENT(node2, environment);
+            if(ele2 && AXIOM_ELEMENT_GET_LOCALNAME(ele2,environment))
             {
-                printf("\n localname %s\n" , AXIS2_OM_ELEMENT_GET_LOCALNAME(ele2,environment)); 
+                printf("\n localname %s\n" , AXIOM_ELEMENT_GET_LOCALNAME(ele2,environment)); 
             }
                         
             break;
-        case AXIS2_OM_TEXT:
+        case AXIOM_TEXT:
             
-            text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node2,environment);    
-            if( text && AXIS2_OM_TEXT_GET_VALUE(text ,environment))
-                printf("\n text value  %s \n", AXIS2_OM_TEXT_GET_VALUE(text,environment));
+            text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(node2,environment);    
+            if( text && AXIOM_TEXT_GET_VALUE(text ,environment))
+                printf("\n text value  %s \n", AXIOM_TEXT_GET_VALUE(text,environment));
             break;
 
         default:
             break;
         }
 
-        node2 = AXIS2_OM_DOCUMENT_BUILD_NEXT (document , environment);
+        node2 = AXIOM_DOCUMENT_BUILD_NEXT (document , environment);
     }
     while (node2);
     printf ("END: pull document\n");
@@ -167,17 +167,17 @@
     
     writer = axis2_xml_writer_create_for_memory(environment, NULL, AXIS2_TRUE, 0,
                                        AXIS2_XML_PARSER_TYPE_BUFFER);
-    om_output = axis2_om_output_create (environment, writer);
+    om_output = axiom_output_create (environment, writer);
 
-    AXIS2_OM_NODE_SERIALIZE (node1, environment , om_output);
+    AXIOM_NODE_SERIALIZE (node1, environment , om_output);
     
     buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(writer, environment);
     
-    AXIS2_OM_OUTPUT_FREE(om_output, environment);  
+    AXIOM_OUTPUT_FREE(om_output, environment);  
     if(buffer)
         printf("%s",buffer);
   
-    AXIS2_OM_STAX_BUILDER_FREE(builder, environment);
+    AXIOM_STAX_BUILDER_FREE(builder, environment);
     if(buffer)
         AXIS2_FREE(environment->allocator, buffer); 
     printf ("\ndone\n");
@@ -204,66 +204,66 @@
        </book>
     */
     int status;
-    axis2_om_element_t *ele1 = NULL, *ele2 = NULL, *ele3 = NULL, *ele4 =
+    axiom_element_t *ele1 = NULL, *ele2 = NULL, *ele3 = NULL, *ele4 =
         NULL;
-    axis2_om_node_t *node1 = NULL, *node2 = NULL, *node3 = NULL, *node4 =
+    axiom_node_t *node1 = NULL, *node2 = NULL, *node3 = NULL, *node4 =
         NULL, *node5 = NULL, *node6 = NULL;
-    axis2_om_attribute_t *attr1 = NULL, *attr2 = NULL;
-    axis2_om_namespace_t *ns1 = NULL, *ns2 = NULL;
-    axis2_om_text_t *text1 = NULL;
-    axis2_om_output_t *om_output = NULL;
+    axiom_attribute_t *attr1 = NULL, *attr2 = NULL;
+    axiom_namespace_t *ns1 = NULL, *ns2 = NULL;
+    axiom_text_t *text1 = NULL;
+    axiom_output_t *om_output = NULL;
     axis2_xml_writer_t *writer = NULL;
     axis2_char_t *output_buffer = NULL;
 
     ns1 =
-        axis2_om_namespace_create (environment,
+        axiom_namespace_create (environment,
                                    "http://ws.apache.org/axis2/c/om",
                                    "axiom");
     ns2 =
-        axis2_om_namespace_create (environment, "urn:ISBN:0-395-74341-6",
+        axiom_namespace_create (environment, "urn:ISBN:0-395-74341-6",
                                    "isbn");
-    ele1 = axis2_om_element_create (environment, NULL, "book", ns1, &node1);
-    AXIS2_OM_ELEMENT_DECLARE_NAMESPACE(ele1,environment,node1,ns2);
+    ele1 = axiom_element_create (environment, NULL, "book", ns1, &node1);
+    AXIOM_ELEMENT_DECLARE_NAMESPACE(ele1,environment,node1,ns2);
     
-    ele2 = axis2_om_element_create (environment, node1, "title", ns1, &node2);
+    ele2 = axiom_element_create (environment, node1, "title", ns1, &node2);
     
-    text1 = axis2_om_text_create (environment, node2, "Axis2/C OM HOWTO", &node3);
+    text1 = axiom_text_create (environment, node2, "Axis2/C OM HOWTO", &node3);
     
-    ele3 = axis2_om_element_create (environment, node1, "number", ns2, &node4);
+    ele3 = axiom_element_create (environment, node1, "number", ns2, &node4);
     
-    text1 = axis2_om_text_create (environment, node4, "1748491379", &node5);
+    text1 = axiom_text_create (environment, node4, "1748491379", &node5);
     
-    ele4 = axis2_om_element_create (environment, node1, "author", ns1, &node6);
+    ele4 = axiom_element_create (environment, node1, "author", ns1, &node6);
     
-    attr1 = axis2_om_attribute_create (environment, "title", "Mr", ns1);
+    attr1 = axiom_attribute_create (environment, "title", "Mr", ns1);
     
-    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(ele4, environment,attr1, node6);
+    AXIOM_ELEMENT_ADD_ATTRIBUTE(ele4, environment,attr1, node6);
     
-    attr2 = axis2_om_attribute_create (environment, "name", "Axitoc Oman", ns1);
+    attr2 = axiom_attribute_create (environment, "name", "Axitoc Oman", ns1);
     
-    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(ele4,environment, attr2, node6);
+    AXIOM_ELEMENT_ADD_ATTRIBUTE(ele4,environment, attr2, node6);
     
    
     /* serializing stuff */
     writer = axis2_xml_writer_create_for_memory(environment, NULL, AXIS2_TRUE, 0,
                                     AXIS2_XML_PARSER_TYPE_BUFFER);
-    om_output = axis2_om_output_create (environment, writer);
+    om_output = axiom_output_create (environment, writer);
 
     printf ("Serialize built document\n");
-    status = AXIS2_OM_NODE_SERIALIZE (node1,environment ,om_output);
+    status = AXIOM_NODE_SERIALIZE (node1,environment ,om_output);
     if (status != AXIS2_SUCCESS)
     {
-        printf ("\naxis2_om_node_serialize failed\n");
+        printf ("\naxiom_node_serialize failed\n");
         return status;
     }
     else
-        printf ("\naxis2_om_node_serialize success\n");
+        printf ("\naxiom_node_serialize success\n");
     /* end serializing stuff */
 
-     AXIS2_OM_NODE_FREE_TREE(node1,environment);
+     AXIOM_NODE_FREE_TREE(node1,environment);
      output_buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(writer, environment);
      
-     AXIS2_OM_OUTPUT_FREE(om_output, environment);
+     AXIOM_OUTPUT_FREE(om_output, environment);
      if(output_buffer)
      {
         printf("%s",output_buffer);

Modified: webservices/axis2/trunk/c/axiom/test/soap/test_soap.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/soap/test_soap.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/soap/test_soap.c (original)
+++ webservices/axis2/trunk/c/axiom/test/soap/test_soap.c Mon Jun 12 01:22:58 2006
@@ -14,11 +14,11 @@
 * limitations under the License.
 */
 
-#include <axis2_om_stax_builder.h>
-#include <axis2_om_document.h>
-#include <axis2_om_node.h>
-#include <axis2_om_element.h>
-#include <axis2_om_text.h>
+#include <axiom_stax_builder.h>
+#include <axiom_document.h>
+#include <axiom_node.h>
+#include <axiom_element.h>
+#include <axiom_text.h>
 #include <axis2_stream.h>
 #include <axis2_log_default.h>
 #include <axis2_error_default.h>
@@ -67,32 +67,32 @@
     return AXIS2_TRUE;
 }
 
-int printnode(axis2_om_node_t *om_node, const axis2_env_t *env)
+int printnode(axiom_node_t *om_node, const axis2_env_t *env)
 {
-    axis2_om_element_t *om_ele = NULL;
+    axiom_element_t *om_ele = NULL;
     axis2_char_t *localname = NULL;
-    axis2_om_namespace_t *om_ns =  NULL;
+    axiom_namespace_t *om_ns =  NULL;
     axis2_char_t *uri = NULL;
     axis2_char_t *prefix = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     if(!om_node)
         return AXIS2_FAILURE;
         
-    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)
             return AXIS2_FAILURE;
             
-        localname = AXIS2_OM_ELEMENT_GET_LOCALNAME(om_ele, env);
+        localname = AXIOM_ELEMENT_GET_LOCALNAME(om_ele, env);
         if(NULL != localname)
             printf("\n %s \n", localname);
-        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)
         {
-            prefix = AXIS2_OM_NAMESPACE_GET_PREFIX(om_ns, env);
-            uri    = AXIS2_OM_NAMESPACE_GET_URI(om_ns, env);
+            prefix = AXIOM_NAMESPACE_GET_PREFIX(om_ns, env);
+            uri    = AXIOM_NAMESPACE_GET_URI(om_ns, env);
             
             printf("\n uri %s \n prefix %s \n",uri, prefix);
         }
@@ -102,22 +102,22 @@
 
 int build_soap(const axis2_env_t *env, const char *filename, const axis2_char_t *uri)
 {
-    axis2_om_stax_builder_t *om_builder = NULL;
+    axiom_stax_builder_t *om_builder = NULL;
     
     axis2_xml_reader_t *xml_reader = NULL;
     
     axis2_soap_builder_t *soap_builder = NULL;
     axis2_soap_envelope_t *soap_envelope = NULL;
     
-    axis2_om_node_t *om_node = NULL;
+    axiom_node_t *om_node = NULL;
     axis2_char_t *buffer = NULL;
     
     axis2_xml_writer_t *xml_writer = NULL;
-    axis2_om_output_t *om_output = NULL;
+    axiom_output_t *om_output = NULL;
     
     axis2_soap_body_t *soap_body = NULL;
     axis2_soap_header_t *soap_header = NULL;
-    axis2_om_children_qname_iterator_t *children_iter = NULL;
+    axiom_children_qname_iterator_t *children_iter = NULL;
     
     int status = AXIS2_SUCCESS;    
     
@@ -136,7 +136,7 @@
     }
 
    
-    om_builder = axis2_om_stax_builder_create(env, xml_reader);
+    om_builder = axiom_stax_builder_create(env, xml_reader);
     if(!om_builder)
     {
         AXIS2_XML_READER_FREE(xml_reader, env);
@@ -174,9 +174,9 @@
         children_iter = AXIS2_SOAP_HEADER_EXAMINE_ALL_HEADER_BLOCKS(soap_header, env);
         if(NULL != children_iter)
         {
-            while(AXIS2_OM_CHILDREN_ITERATOR_HAS_NEXT(children_iter, env))
+            while(AXIOM_CHILDREN_ITERATOR_HAS_NEXT(children_iter, env))
             {   
-                om_node = AXIS2_OM_CHILDREN_ITERATOR_NEXT(children_iter, env);
+                om_node = AXIOM_CHILDREN_ITERATOR_NEXT(children_iter, env);
                 if(NULL != om_node)
                     printnode(om_node, env);
             }
@@ -208,7 +208,7 @@
     om_node = AXIS2_SOAP_BODY_GET_BASE_NODE(soap_body, 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(soap_builder, env);
             if(status == AXIS2_FAILURE)
@@ -227,7 +227,7 @@
         return AXIS2_FAILURE;
     }
     
-    om_output = axis2_om_output_create( env, xml_writer);  
+    om_output = axiom_output_create( env, xml_writer);  
     if(!om_output)
     {
         AXIS2_SOAP_BUILDER_FREE(soap_builder, env);
@@ -247,7 +247,7 @@
     
     AXIS2_SOAP_ENVELOPE_FREE(soap_envelope, env);
     
-    AXIS2_OM_OUTPUT_FREE(om_output, env);
+    AXIOM_OUTPUT_FREE(om_output, env);
     
     printf(" \n __________ END TEST SOAP BUILD ____________ \n");
     
@@ -264,21 +264,21 @@
     axis2_soap_fault_code_t *fault_code = NULL;
     axis2_soap_header_block_t *hb1 = NULL;
     
-    axis2_om_namespace_t *env_ns = NULL;
-    axis2_om_namespace_t *test_ns = NULL;
-    axis2_om_namespace_t *role_ns = NULL;
+    axiom_namespace_t *env_ns = NULL;
+    axiom_namespace_t *test_ns = NULL;
+    axiom_namespace_t *role_ns = NULL;
     
     axis2_xml_writer_t *xml_writer = NULL;
-    axis2_om_output_t *om_output = NULL;
+    axiom_output_t *om_output = NULL;
     
     axis2_char_t *buffer = NULL;
-    axis2_om_node_t *hb_node = NULL;
-    axis2_om_element_t *hb_ele =  NULL;
+    axiom_node_t *hb_node = NULL;
+    axiom_element_t *hb_ele =  NULL;
     
     printf(" \n ____________ BUILD SOAP PROGRAMATICALLY _______________ \n");
     
     
-    env_ns = axis2_om_namespace_create(env, "http://www.w3.org/2003/05/soap-envelope", "env");
+    env_ns = axiom_namespace_create(env, "http://www.w3.org/2003/05/soap-envelope", "env");
     if(!env_ns)
         return AXIS2_FAILURE;
         
@@ -290,9 +290,9 @@
     if(!soap_header)
         return AXIS2_FAILURE;
     
-    test_ns = axis2_om_namespace_create(env, "http://example.org/ts-tests", "test");
+    test_ns = axiom_namespace_create(env, "http://example.org/ts-tests", "test");
     
-    role_ns = axis2_om_namespace_create(env, "http://www.w3.org/2003/05/soap-envelope/role/next","role");
+    role_ns = axiom_namespace_create(env, "http://www.w3.org/2003/05/soap-envelope/role/next","role");
 
    
     
@@ -300,9 +300,9 @@
     
     hb_node = AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE(hb1, env);
     
-    hb_ele = AXIS2_OM_NODE_GET_DATA_ELEMENT(hb_node, env);
+    hb_ele = AXIOM_NODE_GET_DATA_ELEMENT(hb_node, env);
     
-    AXIS2_OM_ELEMENT_SET_NAMESPACE(hb_ele, env, test_ns, hb_node);
+    AXIOM_ELEMENT_SET_NAMESPACE(hb_ele, env, test_ns, hb_node);
     
     soap_body = axis2_soap_body_create_with_parent(env, soap_envelope);
     
@@ -314,7 +314,7 @@
     xml_writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE, 
                                           AXIS2_XML_PARSER_TYPE_BUFFER);
     
-    om_output = axis2_om_output_create( env, xml_writer);
+    om_output = axiom_output_create( env, xml_writer);
     
     AXIS2_SOAP_ENVELOPE_SERIALIZE(soap_envelope, env, om_output, AXIS2_FALSE);
     
@@ -328,7 +328,7 @@
     
     buffer = NULL;
     
-    AXIS2_OM_OUTPUT_FREE(om_output, env);
+    AXIOM_OUTPUT_FREE(om_output, env);
     
     printf("\n __________ END BUILD SOAP PROGRAMATICALLY ____________\n");
     
@@ -341,7 +341,7 @@
     axis2_soap_body_t *soap_body = NULL;
     axis2_soap_fault_t *soap_fault = NULL;
     axis2_xml_writer_t *xml_writer = NULL;
-    axis2_om_output_t *om_output = NULL;
+    axiom_output_t *om_output = NULL;
     axis2_char_t *buffer = NULL;
 
     soap_envelope = 
@@ -355,13 +355,13 @@
     axis2_soap_fault_role_create_with_parent(env, soap_fault);
     xml_writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE, 
                                           AXIS2_XML_PARSER_TYPE_BUFFER);
-    om_output = axis2_om_output_create( env, xml_writer);
+    om_output = axiom_output_create( env, xml_writer);
     AXIS2_SOAP_ENVELOPE_SERIALIZE(soap_envelope, env, om_output, AXIS2_FALSE);
     buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(xml_writer, env);
         printf("%s \n",  buffer);
     AXIS2_FREE(env->allocator, buffer);
     AXIS2_SOAP_ENVELOPE_FREE(soap_envelope, env);
-    AXIS2_OM_OUTPUT_FREE(om_output, env);
+    AXIOM_OUTPUT_FREE(om_output, env);
 return 0;
 }
 

Modified: webservices/axis2/trunk/c/axiom/test/unit/main.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/unit/main.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/unit/main.c (original)
+++ webservices/axis2/trunk/c/axiom/test/unit/main.c Mon Jun 12 01:22:58 2006
@@ -22,7 +22,7 @@
     CuString *output = CuStringNew();
     CuSuite* suite = CuSuiteNew();
 
-    CuSuiteAddSuite(suite, axis2_omGetSuite());
+    CuSuiteAddSuite(suite, axiomGetSuite());
     
     CuSuiteRun(suite);
     CuSuiteSummary(suite, output);

Modified: webservices/axis2/trunk/c/axiom/test/unit/om/main.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/unit/om/main.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/unit/om/main.c (original)
+++ webservices/axis2/trunk/c/axiom/test/unit/om/main.c Mon Jun 12 01:22:58 2006
@@ -20,7 +20,7 @@
     CuString *output = CuStringNew();
     CuSuite* suite = CuSuiteNew();
 
-    CuSuiteAddSuite(suite, axis2_omGetSuite());
+    CuSuiteAddSuite(suite, axiomGetSuite());
 
     CuSuiteRun(suite);
     CuSuiteSummary(suite, output);

Modified: webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.c (original)
+++ webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.c Mon Jun 12 01:22:58 2006
@@ -15,114 +15,114 @@
 */
 
 #include "om_node_test.h"
-#include <axis2_om_node_internal.h>
+#include <axiom_node_internal.h>
 
 #include <CuTest.h>
 
-void Testaxis2_om_node_add_child(CuTest *tc)
+void Testaxiom_node_add_child(CuTest *tc)
 {
-    axis2_om_node_t *parent;
-    axis2_om_node_t *child;
+    axiom_node_t *parent;
+    axiom_node_t *child;
     const axis2_env_t *env;
     axis2_allocator_t *allocator;
-    axis2_om_node_t *actual;
+    axiom_node_t *actual;
     allocator = axis2_allocator_init(NULL);
     env = axis2_env_create(allocator);
     
-    parent = axis2_om_node_create(env);   
-    child  = axis2_om_node_create(env); 
+    parent = axiom_node_create(env);   
+    child  = axiom_node_create(env); 
     
-    AXIS2_OM_NODE_ADD_CHILD(parent, env, child);
-    actual = AXIS2_OM_NODE_GET_FIRST_CHILD(parent, env);
+    AXIOM_NODE_ADD_CHILD(parent, env, child);
+    actual = AXIOM_NODE_GET_FIRST_CHILD(parent, env);
     CuAssertPtrEquals(tc, child, actual);  
     /*axis2_env_free(env); */
 }
 
-void Testaxis2_om_node_set_parent(CuTest *tc)
+void Testaxiom_node_set_parent(CuTest *tc)
 {
     
-    axis2_om_node_t *parent;
-    axis2_om_node_t *child;
+    axiom_node_t *parent;
+    axiom_node_t *child;
     const axis2_env_t *env;
     axis2_allocator_t *allocator;
     allocator = axis2_allocator_init(NULL);
     env = axis2_env_create(allocator);
     
-    parent = axis2_om_node_create(env);   
-    child  = axis2_om_node_create(env); 
+    parent = axiom_node_create(env);   
+    child  = axiom_node_create(env); 
     
-    axis2_om_node_set_parent(child, env, parent);
-    CuAssertPtrEquals(tc, parent, AXIS2_OM_NODE_GET_PARENT(child, env));
+    axiom_node_set_parent(child, env, parent);
+    CuAssertPtrEquals(tc, parent, AXIOM_NODE_GET_PARENT(child, env));
     /*axis2_env_free(env);*/
 }
 
     
-void Testaxis2_om_node_insert_sibling_before(CuTest *tc)
+void Testaxiom_node_insert_sibling_before(CuTest *tc)
 {
-    axis2_om_node_t *parent;
-    axis2_om_node_t *child;
-    axis2_om_node_t *sibling;
+    axiom_node_t *parent;
+    axiom_node_t *child;
+    axiom_node_t *sibling;
     const axis2_env_t *env;
     axis2_allocator_t *allocator;
     allocator = axis2_allocator_init(NULL);
     env = axis2_env_create(allocator);
     
-    parent = axis2_om_node_create(env);   
-    child  = axis2_om_node_create(env);
-    sibling = axis2_om_node_create(env);
+    parent = axiom_node_create(env);   
+    child  = axiom_node_create(env);
+    sibling = axiom_node_create(env);
 
-    AXIS2_OM_NODE_ADD_CHILD(parent,  env, child);
-    AXIS2_OM_NODE_INSERT_SIBLING_BEFORE(child, env, sibling);
+    AXIOM_NODE_ADD_CHILD(parent,  env, child);
+    AXIOM_NODE_INSERT_SIBLING_BEFORE(child, env, sibling);
     
-    CuAssertPtrEquals(tc, sibling,AXIS2_OM_NODE_GET_FIRST_CHILD(parent, env));    
+    CuAssertPtrEquals(tc, sibling,AXIOM_NODE_GET_FIRST_CHILD(parent, env));    
     /*axis2_env_free(env);*/
 }
-void Testaxis2_om_node_insert_sibling_after(CuTest *tc)
+void Testaxiom_node_insert_sibling_after(CuTest *tc)
 {
-    axis2_om_node_t *parent;
-    axis2_om_node_t *child;
-    axis2_om_node_t *sibling;
+    axiom_node_t *parent;
+    axiom_node_t *child;
+    axiom_node_t *sibling;
     const axis2_env_t *env;
     axis2_allocator_t *allocator;
     allocator = axis2_allocator_init(NULL);
     env = axis2_env_create(allocator);
     
-    parent = axis2_om_node_create(env);   
-    child  = axis2_om_node_create(env);
-    sibling = axis2_om_node_create(env);
+    parent = axiom_node_create(env);   
+    child  = axiom_node_create(env);
+    sibling = axiom_node_create(env);
 
-    AXIS2_OM_NODE_ADD_CHILD(parent, env, child);
-    AXIS2_OM_NODE_INSERT_SIBLING_AFTER(child, env, sibling);
+    AXIOM_NODE_ADD_CHILD(parent, env, child);
+    AXIOM_NODE_INSERT_SIBLING_AFTER(child, env, sibling);
     
-    CuAssertPtrEquals(tc, sibling,AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env));
+    CuAssertPtrEquals(tc, sibling,AXIOM_NODE_GET_NEXT_SIBLING(child, env));
     /*axis2_env_free(env);*/
 }
-void Testaxis2_om_node_detach(CuTest *tc)
+void Testaxiom_node_detach(CuTest *tc)
 {
-    axis2_om_node_t *parent;
-    axis2_om_node_t *child;
-    axis2_om_node_t *sibling1;
-    axis2_om_node_t *sibling2;
+    axiom_node_t *parent;
+    axiom_node_t *child;
+    axiom_node_t *sibling1;
+    axiom_node_t *sibling2;
     
     const axis2_env_t *env;
     axis2_allocator_t *allocator;
     allocator = axis2_allocator_init(NULL);
     env = axis2_env_create(allocator);
     
-    parent = axis2_om_node_create(env);   
-    child  = axis2_om_node_create(env);
-    sibling1 = axis2_om_node_create(env);
-    sibling2 = axis2_om_node_create(env);
+    parent = axiom_node_create(env);   
+    child  = axiom_node_create(env);
+    sibling1 = axiom_node_create(env);
+    sibling2 = axiom_node_create(env);
     
     
-    AXIS2_OM_NODE_ADD_CHILD(parent, env, child);
-    AXIS2_OM_NODE_ADD_CHILD(parent, env, sibling1);
-    AXIS2_OM_NODE_ADD_CHILD(parent, env, sibling2);
+    AXIOM_NODE_ADD_CHILD(parent, env, child);
+    AXIOM_NODE_ADD_CHILD(parent, env, sibling1);
+    AXIOM_NODE_ADD_CHILD(parent, env, sibling2);
 
-    CuAssertPtrEquals(tc, sibling1, AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env));
+    CuAssertPtrEquals(tc, sibling1, AXIOM_NODE_GET_NEXT_SIBLING(child, env));
 
-    AXIS2_OM_NODE_DETACH(sibling1, env);
+    AXIOM_NODE_DETACH(sibling1, env);
     
-    CuAssertPtrEquals(tc, sibling2, AXIS2_OM_NODE_GET_NEXT_SIBLING(child, env));
+    CuAssertPtrEquals(tc, sibling2, AXIOM_NODE_GET_NEXT_SIBLING(child, env));
     /*axis2_env_free(env);*/
 }

Modified: webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.h (original)
+++ webservices/axis2/trunk/c/axiom/test/unit/om/om_node_test.h Mon Jun 12 01:22:58 2006
@@ -20,12 +20,12 @@
 
 #include <CuTest.h>
 #include <axis2_env.h>
-#include <axis2_om_node.h>
+#include <axiom_node.h>
 
-void Testaxis2_om_node_add_child(CuTest *tc);
-void Testaxis2_om_node_set_parent(CuTest *tc);
-void Testaxis2_om_node_insert_sibling_after(CuTest *tc);
-void Testaxis2_om_node_insert_sibling_before(CuTest *tc);
-void Testaxis2_om_node_detach(CuTest *tc);
+void Testaxiom_node_add_child(CuTest *tc);
+void Testaxiom_node_set_parent(CuTest *tc);
+void Testaxiom_node_insert_sibling_after(CuTest *tc);
+void Testaxiom_node_insert_sibling_before(CuTest *tc);
+void Testaxiom_node_detach(CuTest *tc);
 
 #endif /* OM_NODE_TEST_H */

Modified: webservices/axis2/trunk/c/axiom/test/unit/om/om_test.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/unit/om/om_test.c?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/unit/om/om_test.c (original)
+++ webservices/axis2/trunk/c/axiom/test/unit/om/om_test.c Mon Jun 12 01:22:58 2006
@@ -21,16 +21,16 @@
 #include <axis2_env.h>
 #include <om_node_test.h>
 
-CuSuite* axis2_omGetSuite() {
+CuSuite* axiomGetSuite() {
     CuSuite* suite = CuSuiteNew();
-    SUITE_ADD_TEST(suite, Testaxis2_om_node_add_child);
+    SUITE_ADD_TEST(suite, Testaxiom_node_add_child);
     printf("came1\n");
-    SUITE_ADD_TEST(suite, Testaxis2_om_node_set_parent);
+    SUITE_ADD_TEST(suite, Testaxiom_node_set_parent);
     printf("came1\n");
-    SUITE_ADD_TEST(suite,Testaxis2_om_node_insert_sibling_after);
+    SUITE_ADD_TEST(suite,Testaxiom_node_insert_sibling_after);
     printf("came1\n");
-    SUITE_ADD_TEST(suite,Testaxis2_om_node_insert_sibling_before);
+    SUITE_ADD_TEST(suite,Testaxiom_node_insert_sibling_before);
     printf("came1\n");
-    SUITE_ADD_TEST(suite,Testaxis2_om_node_detach);
+    SUITE_ADD_TEST(suite,Testaxiom_node_detach);
     return suite;
 }

Modified: webservices/axis2/trunk/c/axiom/test/unit/om/om_test.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/test/unit/om/om_test.h?rev=413605&r1=413604&r2=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/test/unit/om/om_test.h (original)
+++ webservices/axis2/trunk/c/axiom/test/unit/om/om_test.h Mon Jun 12 01:22:58 2006
@@ -19,6 +19,6 @@
 
 #include <CuTest.h>
 
-CuSuite* axis2_omGetSuite();
+CuSuite* axiomGetSuite();
 
 #endif /* OM_TEST_H */



---------------------------------------------------------------------
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