axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r413606 [4/9] - in /webservices/axis2/trunk/c: include/ modules/core/addr/ modules/core/clientapi/ modules/core/clientapi/diclient/ modules/core/context/ modules/core/deployment/ modules/core/engine/ modules/core/receivers/ modules/core/tra...
Date Mon, 12 Jun 2006 08:26:34 GMT
Modified: webservices/axis2/trunk/c/modules/mod_addr/addr_out_handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/mod_addr/addr_out_handler.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/mod_addr/addr_out_handler.c (original)
+++ webservices/axis2/trunk/c/modules/mod_addr/addr_out_handler.c Mon Jun 12 01:26:30 2006
@@ -43,18 +43,18 @@
 axis2_status_t
 axis2_addr_out_handler_add_to_header (const axis2_env_t *env,
                                       axis2_endpoint_ref_t * epr,
-                                      axis2_om_node_t ** parent_node,
+                                      axiom_node_t ** parent_node,
                                       const axis2_char_t * addr_ns);
 
 axis2_status_t
 axis2_addr_out_handler_process_any_content_type (const axis2_env_t *env,
                                                  axis2_any_content_type_t *
                                                  reference_values,
-                                                 axis2_om_node_t *
+                                                 axiom_node_t *
                                                  parent_ele_node,
                                                  const axis2_char_t * addr_ns);
 
-axis2_om_node_t *axis2_addr_out_handler_process_string_info (const axis2_env_t *env,
+axiom_node_t *axis2_addr_out_handler_process_string_info (const axis2_env_t *env,
                                                              const axis2_char_t *value,
                                                              const axis2_char_t *type,
                                                              axis2_soap_header_t **soap_header,
@@ -114,11 +114,11 @@
     const axis2_char_t *addr_ns = NULL;
     axis2_msg_info_headers_t *msg_info_headers = NULL;
     axis2_ctx_t *ctx = NULL;
-    axis2_om_namespace_t *addressing_namespace = NULL;
+    axiom_namespace_t *addressing_namespace = NULL;
     axis2_soap_envelope_t *soap_envelope = NULL;
     axis2_soap_header_t *soap_header = NULL;
-    axis2_om_node_t *soap_header_node = NULL;
-    axis2_om_element_t *soap_header_ele = NULL;
+    axiom_node_t *soap_header_node = NULL;
+    axiom_element_t *soap_header_ele = NULL;
     axis2_endpoint_ref_t *epr = NULL;
     axis2_property_t *property = NULL;
 
@@ -196,19 +196,19 @@
         addr_ns = AXIS2_WSA_NAMESPACE;
     }
 
-    addressing_namespace = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+    addressing_namespace = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
     msg_info_headers = AXIS2_MSG_CTX_GET_MSG_INFO_HEADERS (msg_ctx, env);
     soap_envelope = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE (msg_ctx, env);
     if (!soap_envelope)
     {
-        AXIS2_OM_NAMESPACE_FREE(addressing_namespace, env);
+        AXIOM_NAMESPACE_FREE(addressing_namespace, env);
         return AXIS2_SUCCESS; /* can happen in case of one way services/clients */
     }
     soap_header  = AXIS2_SOAP_ENVELOPE_GET_HEADER (soap_envelope, env);
   
     if (!soap_header)
     {
-        AXIS2_OM_NAMESPACE_FREE(addressing_namespace, env);
+        AXIOM_NAMESPACE_FREE(addressing_namespace, env);
         return AXIS2_SUCCESS; /*No SOAP header, so no point proceeding*/
     }
 
@@ -223,14 +223,14 @@
         axis2_char_t *svc_group_context_id = NULL;
         axis2_char_t *message_id =  NULL;
         axis2_relates_to_t *relates_to = NULL;
-        axis2_om_node_t *relates_to_header_node = NULL;
-        axis2_om_element_t *relates_to_header_ele = NULL;
+        axiom_node_t *relates_to_header_node = NULL;
+        axiom_element_t *relates_to_header_ele = NULL;
 
         soap_header_node = AXIS2_SOAP_HEADER_GET_BASE_NODE (soap_header, env);
         soap_header_ele =
-            (axis2_om_element_t *)
-            AXIS2_OM_NODE_GET_DATA_ELEMENT (soap_header_node, env);
-        AXIS2_OM_ELEMENT_DECLARE_NAMESPACE (soap_header_ele, env,
+            (axiom_element_t *)
+            AXIOM_NODE_GET_DATA_ELEMENT (soap_header_node, env);
+        AXIOM_ELEMENT_DECLARE_NAMESPACE (soap_header_ele, env,
                                             soap_header_node, addressing_namespace);
 
         epr = AXIS2_MSG_INFO_HEADERS_GET_TO (msg_info_headers, env);
@@ -266,7 +266,7 @@
             address = AXIS2_ENDPOINT_REF_GET_ADDRESS (epr, env);
             if (address && AXIS2_STRCMP (address, "") != 0)
             {
-                axis2_om_node_t *to_header_block_node = NULL;
+                axiom_node_t *to_header_block_node = NULL;
                 axis2_soap_header_block_t *to_header_block = NULL;
                 
                 to_header_block  =
@@ -277,11 +277,11 @@
                     AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE (to_header_block, env);
                 if (to_header_block_node)
                 {
-                    axis2_om_element_t *to_header_block_element = NULL;
-                    to_header_block_element = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(to_header_block_node, env);
+                    axiom_element_t *to_header_block_element = NULL;
+                    to_header_block_element = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(to_header_block_node, env);
                     if (to_header_block_element)
                     {
-                        AXIS2_OM_ELEMENT_SET_TEXT(to_header_block_element, env, address, to_header_block_node);
+                        AXIOM_ELEMENT_SET_TEXT(to_header_block_element, env, address, to_header_block_node);
                     }
                 }
             }
@@ -411,16 +411,16 @@
             relationship_type = AXIS2_RELATES_TO_GET_RELATIONSHIP_TYPE (relates_to, env);
             if (AXIS2_STRCMP (relationship_type, "") != 0)
             {
-                axis2_om_attribute_t *om_attr = NULL;
-                axis2_om_namespace_t *addr_ns_obj = NULL;
-                axis2_om_namespace_t *dec_ns = NULL;
+                axiom_attribute_t *om_attr = NULL;
+                axiom_namespace_t *addr_ns_obj = NULL;
+                axiom_namespace_t *dec_ns = NULL;
                 relates_to_header_ele =
-                    (axis2_om_element_t *)
-                    AXIS2_OM_NODE_GET_DATA_ELEMENT (relates_to_header_node,
+                    (axiom_element_t *)
+                    AXIOM_NODE_GET_DATA_ELEMENT (relates_to_header_node,
                                                     env);
                 if(NULL != relates_to_header_ele)
                 {
-                    dec_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(relates_to_header_ele, env,
+                    dec_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(relates_to_header_ele, env,
                                                  addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
                     if(NULL != dec_ns)
                     {
@@ -428,31 +428,31 @@
                     }
                     else
                     {
-                        addr_ns_obj = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+                        addr_ns_obj = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
                     }
                     
-                    om_attr = axis2_om_attribute_create (env,
+                    om_attr = axiom_attribute_create (env,
                             AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE,
                             AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE,
                             addr_ns_obj);
                             
-                    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE (relates_to_header_ele, env,
+                    AXIOM_ELEMENT_ADD_ATTRIBUTE (relates_to_header_ele, env,
                                 om_attr, relates_to_header_node);
 
                 }                                
                 if(NULL != relates_to_header_ele)
                 {
-                    dec_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(relates_to_header_ele, env,
+                    dec_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(relates_to_header_ele, env,
                                                          addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
                     if(NULL == dec_ns)
                     {
-                        dec_ns = AXIS2_OM_ELEMENT_FIND_NAMESPACE(relates_to_header_ele, env, 
+                        dec_ns = AXIOM_ELEMENT_FIND_NAMESPACE(relates_to_header_ele, env, 
                                     relates_to_header_node, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
                         if(NULL != dec_ns)
                         {
-                            AXIS2_OM_NAMESPACE_FREE(addr_ns_obj, env);
+                            AXIOM_NAMESPACE_FREE(addr_ns_obj, env);
                             addr_ns_obj = NULL ;
-                            AXIS2_OM_ATTRIBUTE_SET_NAMESPACE(om_attr, env, dec_ns);
+                            AXIOM_ATTRIBUTE_SET_NAMESPACE(om_attr, env, dec_ns);
                         }                            
                     }
                 }
@@ -464,7 +464,7 @@
 }
 
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_addr_out_handler_process_string_info (const axis2_env_t *env,
                                             const axis2_char_t * value,
                                             const axis2_char_t * type,
@@ -474,8 +474,8 @@
 {
     axis2_soap_header_t *soap_header = NULL;
     axis2_soap_header_block_t *header_block = NULL;
-    axis2_om_node_t *header_block_node = NULL;
-    axis2_om_element_t *header_block_ele = NULL;
+    axiom_node_t *header_block_node = NULL;
+    axiom_element_t *header_block_ele = NULL;
 
     AXIS2_ENV_CHECK (env, NULL);
     AXIS2_PARAM_CHECK (env->error, value, NULL);
@@ -487,9 +487,9 @@
 
     if (value && AXIS2_STRCMP (value, "") != 0)
     {
-        axis2_om_namespace_t *addr_ns_obj = NULL;
+        axiom_namespace_t *addr_ns_obj = NULL;
         addr_ns_obj =
-            axis2_om_namespace_create (env, addr_ns,
+            axiom_namespace_create (env, addr_ns,
                                        AXIS2_WSA_DEFAULT_PREFIX);
         header_block =
             AXIS2_SOAP_HEADER_ADD_HEADER_BLOCK (soap_header, env, type,
@@ -497,18 +497,18 @@
         header_block_node =
             AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE (header_block, env);
         header_block_ele =
-            (axis2_om_element_t *)
-            AXIS2_OM_NODE_GET_DATA_ELEMENT (header_block_node, env);
+            (axiom_element_t *)
+            AXIOM_NODE_GET_DATA_ELEMENT (header_block_node, env);
         if(NULL != header_block_ele)
         {
-            axis2_om_namespace_t *dec_ns = NULL;
-            AXIS2_OM_ELEMENT_SET_TEXT (header_block_ele, env, value,
+            axiom_namespace_t *dec_ns = NULL;
+            AXIOM_ELEMENT_SET_TEXT (header_block_ele, env, value,
                                         header_block_node);
-            dec_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(header_block_ele, env,
+            dec_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(header_block_ele, env,
                                                  addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
             if(! dec_ns)
             {
-                 AXIS2_OM_NAMESPACE_FREE(addr_ns_obj, env);
+                 AXIOM_NAMESPACE_FREE(addr_ns_obj, env);
                  addr_ns_obj = NULL;
             }
         }
@@ -529,9 +529,9 @@
     axis2_array_list_t *ref_param_list = NULL;
     axis2_array_list_t *meta_data_list = NULL;
     axis2_array_list_t *extension_list = NULL;
-    axis2_om_node_t *header_block_node = NULL;
-    axis2_om_node_t *header_node = NULL;
-    axis2_om_namespace_t *addr_ns_obj = NULL;
+    axiom_node_t *header_block_node = NULL;
+    axiom_node_t *header_node = NULL;
+    axiom_namespace_t *addr_ns_obj = NULL;
     
     AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK (env->error, endpoint_ref, AXIS2_FAILURE);
@@ -540,7 +540,7 @@
 
     header_node = AXIS2_SOAP_HEADER_GET_BASE_NODE (soap_header, env);
     
-    addr_ns_obj = axis2_om_namespace_create (env, 
+    addr_ns_obj = axiom_namespace_create (env, 
                         addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
     header_block =
         AXIS2_SOAP_HEADER_ADD_HEADER_BLOCK (soap_header, env, type,
@@ -548,35 +548,35 @@
 
     if(NULL !=  addr_ns_obj)
     {
-        AXIS2_OM_NAMESPACE_FREE(addr_ns_obj, env);
+        AXIOM_NAMESPACE_FREE(addr_ns_obj, env);
         addr_ns_obj = NULL;
     }
 
     address = AXIS2_ENDPOINT_REF_GET_ADDRESS (endpoint_ref, env);
     if (address && AXIS2_STRCMP ("", address) != 0)
     {
-        axis2_om_node_t *hb_node = NULL;
-        axis2_om_element_t *hb_ele = NULL;
-        axis2_om_node_t *address_node = NULL;
-        axis2_om_element_t *address_ele = NULL;
+        axiom_node_t *hb_node = NULL;
+        axiom_element_t *hb_ele = NULL;
+        axiom_node_t *address_node = NULL;
+        axiom_element_t *address_ele = NULL;
         hb_node = AXIS2_SOAP_HEADER_BLOCK_GET_BASE_NODE (header_block, env);
-        hb_ele = (axis2_om_element_t *) 
-                    AXIS2_OM_NODE_GET_DATA_ELEMENT (hb_node, env);
+        hb_ele = (axiom_element_t *) 
+                    AXIOM_NODE_GET_DATA_ELEMENT (hb_node, env);
 
-        addr_ns_obj = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+        addr_ns_obj = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
         
         address_ele =
-            axis2_om_element_create (env, hb_node, EPR_ADDRESS, addr_ns_obj,
+            axiom_element_create (env, hb_node, EPR_ADDRESS, addr_ns_obj,
                                      &address_node);
         if(NULL != address_ele)
         {
-            axis2_om_namespace_t *dec_ns = NULL;
-            AXIS2_OM_ELEMENT_SET_TEXT (address_ele, env, address, address_node);
-            dec_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(address_ele, env, 
+            axiom_namespace_t *dec_ns = NULL;
+            AXIOM_ELEMENT_SET_TEXT (address_ele, env, address, address_node);
+            dec_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(address_ele, env, 
                                                  addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
             if(! dec_ns)
             {
-                 AXIS2_OM_NAMESPACE_FREE(addr_ns_obj, env);
+                 AXIOM_NAMESPACE_FREE(addr_ns_obj, env);
                  addr_ns_obj = NULL;
             }
         }
@@ -590,14 +590,14 @@
     ref_param_list = AXIS2_ENDPOINT_REF_GET_REF_PARAM_LIST(endpoint_ref, env);
     if (ref_param_list && AXIS2_ARRAY_LIST_SIZE(ref_param_list, env) > 0)
     {
-        axis2_om_node_t *reference_node = NULL;
-        axis2_om_element_t *reference_ele = NULL;
+        axiom_node_t *reference_node = NULL;
+        axiom_element_t *reference_ele = NULL;
         axis2_array_list_t *ref_attribute_list = NULL;
         int i = 0;
         
-        addr_ns_obj = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+        addr_ns_obj = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
          
-        reference_ele = axis2_om_element_create (env,
+        reference_ele = axiom_element_create (env,
                                                  header_block_node,
                                                  EPR_REFERENCE_PARAMETERS,
                                                  addr_ns_obj,
@@ -609,20 +609,20 @@
             int j = 0;
             for (j = 0; j < AXIS2_ARRAY_LIST_SIZE(ref_attribute_list, env); j++)
             {
-                axis2_om_attribute_t *attr = (axis2_om_attribute_t *)AXIS2_ARRAY_LIST_GET(ref_attribute_list, env, j);
+                axiom_attribute_t *attr = (axiom_attribute_t *)AXIS2_ARRAY_LIST_GET(ref_attribute_list, env, j);
                 if (attr)
                 {
-                    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(reference_ele, env, attr, reference_node);
+                    AXIOM_ELEMENT_ADD_ATTRIBUTE(reference_ele, env, attr, reference_node);
                 }
             }
         }
         
         for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(ref_param_list, env); i++)
         {
-            axis2_om_node_t *ref_node = (axis2_om_node_t *)AXIS2_ARRAY_LIST_GET(ref_param_list, env, i);
+            axiom_node_t *ref_node = (axiom_node_t *)AXIS2_ARRAY_LIST_GET(ref_param_list, env, i);
             if (ref_node)
             {
-                AXIS2_OM_NODE_ADD_CHILD(reference_node, env, ref_node);
+                AXIOM_NODE_ADD_CHILD(reference_node, env, ref_node);
             }
         }
 
@@ -631,16 +631,16 @@
     meta_data_list = AXIS2_ENDPOINT_REF_GET_META_DATA_LIST(endpoint_ref, env);
     if (meta_data_list && AXIS2_ARRAY_LIST_SIZE(meta_data_list, env) > 0)
     {
-        axis2_om_node_t *reference_node = NULL;
-        axis2_om_element_t *reference_ele = NULL;
+        axiom_node_t *reference_node = NULL;
+        axiom_element_t *reference_ele = NULL;
         axis2_array_list_t *meta_attribute_list = NULL;
         int i = 0;
         
         if (!reference_node) /* may be we alredy created this in ref params block */
         {
-            addr_ns_obj = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+            addr_ns_obj = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
          
-            reference_ele = axis2_om_element_create (env,
+            reference_ele = axiom_element_create (env,
                                                  header_block_node,
                                                  AXIS2_WSA_METADATA,
                                                  addr_ns_obj,
@@ -653,20 +653,20 @@
             int j = 0;
             for (j = 0; j < AXIS2_ARRAY_LIST_SIZE(meta_attribute_list, env); j++)
             {
-                axis2_om_attribute_t *attr = (axis2_om_attribute_t *)AXIS2_ARRAY_LIST_GET(meta_attribute_list, env, j);
+                axiom_attribute_t *attr = (axiom_attribute_t *)AXIS2_ARRAY_LIST_GET(meta_attribute_list, env, j);
                 if (attr)
                 {
-                    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(reference_ele, env, attr, reference_node);
+                    AXIOM_ELEMENT_ADD_ATTRIBUTE(reference_ele, env, attr, reference_node);
                 }
             }
         }
         
         for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(meta_data_list, env); i ++)
         {
-            axis2_om_node_t *ref_node = (axis2_om_node_t *)AXIS2_ARRAY_LIST_GET(meta_data_list, env, i);
+            axiom_node_t *ref_node = (axiom_node_t *)AXIS2_ARRAY_LIST_GET(meta_data_list, env, i);
             if (ref_node)
             {
-                AXIS2_OM_NODE_ADD_CHILD(reference_node, env, ref_node);
+                AXIOM_NODE_ADD_CHILD(reference_node, env, ref_node);
             }
         }
     }
@@ -677,10 +677,10 @@
         int i = 0;
         for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(extension_list, env); i ++)
         {
-            axis2_om_node_t *ref_node = (axis2_om_node_t *)AXIS2_ARRAY_LIST_GET(extension_list, env, i);
+            axiom_node_t *ref_node = (axiom_node_t *)AXIS2_ARRAY_LIST_GET(extension_list, env, i);
             if (ref_node)
             {
-                AXIS2_OM_NODE_ADD_CHILD(header_block_node, env, ref_node);
+                AXIOM_NODE_ADD_CHILD(header_block_node, env, ref_node);
             }
         }
     }
@@ -688,13 +688,13 @@
     if (AXIS2_STRCMP (AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ns) == 0)
     {
         axis2_any_content_type_t *referece_properties = NULL;
-        axis2_om_element_t *reference_ele = NULL;
-        axis2_om_node_t *reference_node = NULL;
+        axiom_element_t *reference_ele = NULL;
+        axiom_node_t *reference_node = NULL;
         referece_properties =
             AXIS2_ENDPOINT_REF_GET_REF_PROPERTIES (endpoint_ref, env);
-        addr_ns_obj = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+        addr_ns_obj = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
         reference_ele =
-            axis2_om_element_create (env, header_node,
+            axiom_element_create (env, header_node,
                                      EPR_REFERENCE_PROPERTIES, addr_ns_obj,
                                      &reference_node);
         axis2_addr_out_handler_process_any_content_type (env,
@@ -703,12 +703,12 @@
                                                          addr_ns);
          if(NULL != reference_ele)
         {
-            axis2_om_namespace_t *dec_ns = NULL;
-            dec_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE( reference_ele , env,
+            axiom_namespace_t *dec_ns = NULL;
+            dec_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE( reference_ele , env,
                                                  addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
             if(! dec_ns)
             {
-                 AXIS2_OM_NAMESPACE_FREE(addr_ns_obj, env);
+                 AXIOM_NAMESPACE_FREE(addr_ns_obj, env);
                  addr_ns_obj = NULL;
             }
         }
@@ -720,16 +720,16 @@
 axis2_status_t
 axis2_addr_out_handler_add_to_header (const axis2_env_t *env,
                                       axis2_endpoint_ref_t * epr,
-                                      axis2_om_node_t ** parent_node_p,
+                                      axiom_node_t ** parent_node_p,
                                       const axis2_char_t * addr_ns)
 {
-    axis2_om_node_t *parent_node = NULL;
+    axiom_node_t *parent_node = NULL;
     axis2_qname_t *interface_qname = NULL;
-    axis2_om_node_t *interface_node = NULL;
-    axis2_om_element_t *interface_ele = NULL;
+    axiom_node_t *interface_node = NULL;
+    axiom_element_t *interface_ele = NULL;
     const axis2_char_t *element_localname = NULL;
     axis2_svc_name_t *service_name = NULL;
-    axis2_om_namespace_t *addr_ns_obj = NULL;
+    axiom_namespace_t *addr_ns_obj = NULL;
 
     AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK (env->error, epr, AXIS2_FAILURE);
@@ -746,7 +746,7 @@
         axis2_char_t *qname_prefix = NULL;
         axis2_char_t *qname_localpart = NULL;
          
-        addr_ns_obj = axis2_om_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
+        addr_ns_obj = axiom_namespace_create (env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
         
         if (AXIS2_STRCMP (addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION) == 0)
         {
@@ -757,7 +757,7 @@
             element_localname = AXIS2_WSA_INTERFACE_NAME;
         }
 
-        interface_ele = axis2_om_element_create (env, parent_node,
+        interface_ele = axiom_element_create (env, parent_node,
                                                  element_localname,
                                                  addr_ns_obj,
                                                  &interface_node);
@@ -770,16 +770,16 @@
                           (AXIS2_STRLEN (qname_prefix) +
                            AXIS2_STRLEN (qname_localpart) + 2));
         sprintf (text, "%s:%s", qname_prefix, qname_localpart);
-        AXIS2_OM_ELEMENT_SET_TEXT (interface_ele, env, text, interface_node);
+        AXIOM_ELEMENT_SET_TEXT (interface_ele, env, text, interface_node);
         AXIS2_FREE (env->allocator, text);
         if(NULL !=interface_ele )
         {
-            axis2_om_namespace_t *dec_ns = NULL;
-            dec_ns = AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE( interface_ele , env,
+            axiom_namespace_t *dec_ns = NULL;
+            dec_ns = AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE( interface_ele , env,
                                                  addr_ns, AXIS2_WSA_DEFAULT_PREFIX);
             if(! dec_ns)
             {
-                 AXIS2_OM_NAMESPACE_FREE(addr_ns_obj, env);
+                 AXIOM_NAMESPACE_FREE(addr_ns_obj, env);
                  addr_ns_obj = NULL;
             }
         }
@@ -795,7 +795,7 @@
 axis2_addr_out_handler_process_any_content_type (const axis2_env_t *env,
                                                  axis2_any_content_type_t *
                                                  reference_values,
-                                                 axis2_om_node_t *
+                                                 axiom_node_t *
                                                  parent_ele_node,
                                                  const axis2_char_t * addr_ns)
 {
@@ -820,27 +820,27 @@
             axis2_hash_this (hash_index, &k, &len, &v);
             if (k)
             {
-                axis2_om_node_t *node = NULL;
-                axis2_om_element_t *ele = NULL;
+                axiom_node_t *node = NULL;
+                axiom_element_t *ele = NULL;
                 ele =
-                    axis2_om_element_create (env, parent_ele_node, k, NULL,
+                    axiom_element_create (env, parent_ele_node, k, NULL,
                                              &node);
                 if (ele)
                 {
                     if (AXIS2_STRCMP (AXIS2_WSA_NAMESPACE, addr_ns) == 0)
                     {
-                        axis2_om_namespace_t *addr_ns_obj = NULL;
-                        axis2_om_attribute_t *att = NULL;
+                        axiom_namespace_t *addr_ns_obj = NULL;
+                        axiom_attribute_t *att = NULL;
                         addr_ns_obj =
-                            axis2_om_namespace_create (env, addr_ns,
+                            axiom_namespace_create (env, addr_ns,
                                                        AXIS2_WSA_DEFAULT_PREFIX);
                         att =
-                            axis2_om_attribute_create (env,
+                            axiom_attribute_create (env,
                                                        AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE,
                                                        AXIS2_WSA_TYPE_ATTRIBUTE_VALUE,
                                                        addr_ns_obj);
                     }
-                    AXIS2_OM_ELEMENT_SET_TEXT (ele, env, v, node);
+                    AXIOM_ELEMENT_SET_TEXT (ele, env, v, node);
                 }
             }
         }

Modified: webservices/axis2/trunk/c/samples/client/echo/echo.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/echo/echo.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/echo/echo.c (original)
+++ webservices/axis2/trunk/c/samples/client/echo/echo.c Mon Jun 12 01:26:30 2006
@@ -15,12 +15,12 @@
  */
 
 #include <stdio.h>
-#include <axis2_om.h>
+#include <axiom.h>
 #include <axis2_util.h>
 #include <axis2_soap.h>
 #include <axis2_client.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_payload_for_echo_svc(const axis2_env_t *env);
 
 
@@ -32,8 +32,8 @@
     axis2_options_t *options = NULL;
     const axis2_char_t *client_home = NULL;
     axis2_svc_client_t* svc_client = NULL;
-    axis2_om_node_t *payload = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *payload = NULL;
+    axiom_node_t *ret_node = NULL;
    
     /* Set up the environment */
     env = axis2_env_create_all("echo.log", AXIS2_LOG_LEVEL_TRACE);
@@ -95,7 +95,7 @@
     if(ret_node)
     {
         axis2_char_t *om_str = NULL;
-        om_str = AXIS2_OM_NODE_TO_STRING(ret_node, env);
+        om_str = AXIOM_NODE_TO_STRING(ret_node, env);
         if (om_str)
             printf("\nReceived OM : %s\n", om_str);
         printf("\necho client invoke SUCCESSFUL!\n");
@@ -122,22 +122,22 @@
 }
 
 /* build SOAP request message content using OM */
-axis2_om_node_t *
+axiom_node_t *
 build_om_payload_for_echo_svc(const axis2_env_t *env)
 {
-    axis2_om_node_t *echo_om_node = NULL;
-    axis2_om_element_t* echo_om_ele = NULL;
-    axis2_om_node_t* text_om_node = NULL;
-    axis2_om_element_t * text_om_ele = NULL;
-    axis2_om_namespace_t *ns1 = NULL;
+    axiom_node_t *echo_om_node = NULL;
+    axiom_element_t* echo_om_ele = NULL;
+    axiom_node_t* text_om_node = NULL;
+    axiom_element_t * text_om_ele = NULL;
+    axiom_namespace_t *ns1 = NULL;
     axis2_char_t *om_str = NULL;
     
-    ns1 = axis2_om_namespace_create (env, "http://ws.apache.org/axis2/c/samples", "ns1");
-    echo_om_ele = axis2_om_element_create(env, NULL, "echoString", ns1, &echo_om_node);
-    text_om_ele = axis2_om_element_create(env, echo_om_node, "text", NULL, &text_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(text_om_ele, env, "echo5", text_om_node);
+    ns1 = axiom_namespace_create (env, "http://ws.apache.org/axis2/c/samples", "ns1");
+    echo_om_ele = axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node);
+    text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node);
+    AXIOM_ELEMENT_SET_TEXT(text_om_ele, env, "echo5", text_om_node);
     
-    om_str = AXIS2_OM_NODE_TO_STRING(echo_om_node, env);
+    om_str = AXIOM_NODE_TO_STRING(echo_om_node, env);
     if (om_str)
         printf("\nSending OM : %s\n", om_str);
 

Modified: webservices/axis2/trunk/c/samples/client/google/google_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/google/google_client.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/google/google_client.c (original)
+++ webservices/axis2/trunk/c/samples/client/google/google_client.c Mon Jun 12 01:26:30 2006
@@ -15,18 +15,18 @@
  */
 
 #include <stdio.h>
-#include <axis2_om.h>
+#include <axiom.h>
 #include <axis2_util.h>
 #include <axis2_soap.h>
 #include <axis2_client.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_soap_body_content(const axis2_env_t *env, 
     const axis2_char_t *operation, 
     const axis2_char_t *google_key, 
     const axis2_char_t *word_to_spell);
 
-void print_invalid_om(const axis2_env_t *env, axis2_om_node_t *ret_node);
+void print_invalid_om(const axis2_env_t *env, axiom_node_t *ret_node);
 
 int main(int argc, char** argv)
 {
@@ -36,8 +36,8 @@
     axis2_options_t *options = NULL;
     const axis2_char_t *client_home = NULL;
     axis2_svc_client_t* svc_client = NULL;
-    axis2_om_node_t *payload = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *payload = NULL;
+    axiom_node_t *ret_node = NULL;
     
     const axis2_char_t *google_key = NULL;
     const axis2_char_t *word_to_spell = NULL;
@@ -105,27 +105,27 @@
     
     if(ret_node)
     {
-        if (AXIS2_OM_NODE_GET_NODE_TYPE(ret_node, env) == AXIS2_OM_ELEMENT)
+        if (AXIOM_NODE_GET_NODE_TYPE(ret_node, env) == AXIOM_ELEMENT)
         {
             axis2_char_t *result = NULL;
-            axis2_om_element_t *result_ele = NULL;
-            axis2_om_node_t *ret_node1 = NULL;
+            axiom_element_t *result_ele = NULL;
+            axiom_node_t *ret_node1 = NULL;
 
-            result_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(ret_node, env);
-            if (AXIS2_STRCMP(AXIS2_OM_ELEMENT_GET_LOCALNAME(result_ele, env), "doSpellingSuggestionResponse") != 0 )
+            result_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(ret_node, env);
+            if (AXIS2_STRCMP(AXIOM_ELEMENT_GET_LOCALNAME(result_ele, env), "doSpellingSuggestionResponse") != 0 )
             {
                 print_invalid_om(env, ret_node);
                 return AXIS2_FAILURE;
             }
             
-            ret_node1 = AXIS2_OM_NODE_GET_FIRST_CHILD(ret_node, env); /*return*/
+            ret_node1 = AXIOM_NODE_GET_FIRST_CHILD(ret_node, env); /*return*/
             if (!ret_node1)
             {
                 print_invalid_om(env, ret_node);
                 return AXIS2_FAILURE;
             }
-            result_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(ret_node1, env);
-            result = AXIS2_OM_ELEMENT_GET_TEXT(result_ele, env, ret_node1);
+            result_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(ret_node1, env);
+            result = AXIOM_ELEMENT_GET_TEXT(result_ele, env, ret_node1);
             printf( "\nResult = %s\n", result);
         }
         else
@@ -151,50 +151,50 @@
     return 0;
 }
 
-axis2_om_node_t *
+axiom_node_t *
 build_soap_body_content(const axis2_env_t *env, 
     const axis2_char_t *operation, 
     const axis2_char_t *google_key, 
     const axis2_char_t *word_to_spell)
 {
-    axis2_om_node_t *google_om_node = NULL;
-    axis2_om_element_t* google_om_ele = NULL;
-    axis2_om_node_t* text_om_node = NULL;
-    axis2_om_element_t * text_om_ele = NULL;
-    axis2_om_namespace_t *ns0 = NULL, *ns1 = NULL, *ns2 = NULL, *ns3 = NULL;
-    axis2_om_attribute_t* attri1 = NULL;
+    axiom_node_t *google_om_node = NULL;
+    axiom_element_t* google_om_ele = NULL;
+    axiom_node_t* text_om_node = NULL;
+    axiom_element_t * text_om_ele = NULL;
+    axiom_namespace_t *ns0 = NULL, *ns1 = NULL, *ns2 = NULL, *ns3 = NULL;
+    axiom_attribute_t* attri1 = NULL;
     axis2_char_t *buffer = NULL;
 
-    ns0 = axis2_om_namespace_create (env, AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, "soapenv");
-    ns1 = axis2_om_namespace_create (env, "urn:GoogleSearch", "ns1");
-    ns2 = axis2_om_namespace_create (env, "http://www.w3.org/1999/XMLSchema-instance", "xsi");
-    ns3 = axis2_om_namespace_create (env, "http://www.w3.org/1999/XMLSchema", "xsd");
+    ns0 = axiom_namespace_create (env, AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, "soapenv");
+    ns1 = axiom_namespace_create (env, "urn:GoogleSearch", "ns1");
+    ns2 = axiom_namespace_create (env, "http://www.w3.org/1999/XMLSchema-instance", "xsi");
+    ns3 = axiom_namespace_create (env, "http://www.w3.org/1999/XMLSchema", "xsd");
 
-    attri1 = axis2_om_attribute_create (env, "encodingStyle", 
+    attri1 = axiom_attribute_create (env, "encodingStyle", 
         "http://schemas.xmlsoap.org/soap/encoding/", ns0);
     
-    google_om_ele = axis2_om_element_create(env, NULL, operation, ns1, &google_om_node);
-    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(google_om_ele, env, attri1, google_om_node);
-    AXIS2_OM_ELEMENT_DECLARE_NAMESPACE(google_om_ele, env, google_om_node, ns2);
-    AXIS2_OM_ELEMENT_DECLARE_NAMESPACE(google_om_ele, env, google_om_node, ns3);
-    
-    text_om_ele = axis2_om_element_create(env, google_om_node, "key", NULL, &text_om_node);
-    attri1 = axis2_om_attribute_create (env, "type", "xsd:string", ns2);
-    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(text_om_ele, env, attri1, text_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(text_om_ele, env, google_key, text_om_node);
-
-    text_om_ele = axis2_om_element_create(env, google_om_node, "phrase", NULL, &text_om_node);
-    AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(text_om_ele, env,attri1, text_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(text_om_ele, env, word_to_spell, text_om_node);
+    google_om_ele = axiom_element_create(env, NULL, operation, ns1, &google_om_node);
+    AXIOM_ELEMENT_ADD_ATTRIBUTE(google_om_ele, env, attri1, google_om_node);
+    AXIOM_ELEMENT_DECLARE_NAMESPACE(google_om_ele, env, google_om_node, ns2);
+    AXIOM_ELEMENT_DECLARE_NAMESPACE(google_om_ele, env, google_om_node, ns3);
+    
+    text_om_ele = axiom_element_create(env, google_om_node, "key", NULL, &text_om_node);
+    attri1 = axiom_attribute_create (env, "type", "xsd:string", ns2);
+    AXIOM_ELEMENT_ADD_ATTRIBUTE(text_om_ele, env, attri1, text_om_node);
+    AXIOM_ELEMENT_SET_TEXT(text_om_ele, env, google_key, text_om_node);
+
+    text_om_ele = axiom_element_create(env, google_om_node, "phrase", NULL, &text_om_node);
+    AXIOM_ELEMENT_ADD_ATTRIBUTE(text_om_ele, env,attri1, text_om_node);
+    AXIOM_ELEMENT_SET_TEXT(text_om_ele, env, word_to_spell, text_om_node);
     
-   buffer = AXIS2_OM_NODE_TO_STRING(google_om_node, env);
+   buffer = AXIOM_NODE_TO_STRING(google_om_node, env);
    printf("%s\n", buffer);
     return google_om_node;
 }
 
-void print_invalid_om(const axis2_env_t *env, axis2_om_node_t *ret_node)
+void print_invalid_om(const axis2_env_t *env, axiom_node_t *ret_node)
 {
     axis2_char_t *buffer = NULL;
-    buffer = AXIS2_OM_NODE_TO_STRING(ret_node, env);
+    buffer = AXIOM_NODE_TO_STRING(ret_node, env);
     printf ("\nReceived OM as result : %s\n", buffer);
 }

Modified: webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.c (original)
+++ webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.c Mon Jun 12 01:26:30 2006
@@ -97,13 +97,13 @@
 
 /***************************Function implementation****************************/
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_add(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node)
+                        axiom_node_t *node)
 {
     axis2_svc_client_t *svc_client = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *ret_node = NULL;
     axis2_qname_t *op_qname =  NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -115,13 +115,13 @@
     return ret_node;
 }
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_sub(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node)
+                        axiom_node_t *node)
 {
     axis2_svc_client_t *svc_client = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *ret_node = NULL;
     axis2_qname_t *op_qname =  NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -133,13 +133,13 @@
     return ret_node;
 }
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_mul(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node)
+                        axiom_node_t *node)
 {
     axis2_svc_client_t *svc_client = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *ret_node = NULL;
     axis2_qname_t *op_qname =  NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -151,13 +151,13 @@
     return ret_node;
 }
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_div(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node)
+                        axiom_node_t *node)
 {
     axis2_svc_client_t *svc_client = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *ret_node = NULL;
     axis2_qname_t *op_qname =  NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

Modified: webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.h?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.h (original)
+++ webservices/axis2/trunk/c/samples/client/math/axis2_math_stub.h Mon Jun 12 01:26:30 2006
@@ -29,25 +29,25 @@
 {
 #endif
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_add(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node);
+                        axiom_node_t *node);
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_sub(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node);
+                        axiom_node_t *node);
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_mul(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node);
+                        axiom_node_t *node);
 
-axis2_om_node_t *
+axiom_node_t *
 axis2_math_stub_div(axis2_stub_t *stub,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node);
+                        axiom_node_t *node);
 /**
  * populate services
  */

Modified: webservices/axis2/trunk/c/samples/client/math/math_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/math/math_client.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/math/math_client.c (original)
+++ webservices/axis2/trunk/c/samples/client/math/math_client.c Mon Jun 12 01:26:30 2006
@@ -16,12 +16,12 @@
 
 #include "axis2_math_stub.h"
 #include <stdio.h>
-#include <axis2_om.h>
+#include <axiom.h>
 #include <axis2_util.h>
 #include <axis2_soap.h>
 #include <axis2_client.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, 
     const axis2_char_t *operation, 
     const axis2_char_t *param1, 
@@ -30,12 +30,12 @@
 int main(int argc, char** argv)
 {
     axis2_stub_t *stub = NULL;
-    axis2_om_node_t *node = NULL;
+    axiom_node_t *node = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     const axis2_env_t *env = NULL;
     const axis2_char_t *address = NULL;
     const axis2_char_t *client_home = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *ret_node = NULL;
 
     const axis2_char_t *operation = "add";
     const axis2_char_t *param1 = "40";
@@ -78,24 +78,24 @@
     ret_node = axis2_math_stub_add(stub, env, node);
     if(ret_node)
     {
-        if (AXIS2_OM_NODE_GET_NODE_TYPE(ret_node, env) == AXIS2_OM_ELEMENT)
+        if (AXIOM_NODE_GET_NODE_TYPE(ret_node, env) == AXIOM_ELEMENT)
         {
             axis2_char_t *result = NULL;
-            axis2_om_element_t *result_ele = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(ret_node, env);
+            axiom_element_t *result_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(ret_node, env);
             
-            result = AXIS2_OM_ELEMENT_GET_TEXT(result_ele, env, ret_node);
+            result = AXIOM_ELEMENT_GET_TEXT(result_ele, env, ret_node);
             printf( "\nResult = %s\n", result);
         }
         else
         {
             axis2_xml_writer_t *writer = NULL;
-            axis2_om_output_t *om_output = NULL;
+            axiom_output_t *om_output = NULL;
             axis2_char_t *buffer = NULL;
             writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
                AXIS2_XML_PARSER_TYPE_BUFFER);
-            om_output = axis2_om_output_create (env, writer);
+            om_output = axiom_output_create (env, writer);
 
-            AXIS2_OM_NODE_SERIALIZE (ret_node, env, om_output);
+            AXIOM_NODE_SERIALIZE (ret_node, env, om_output);
             buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(writer, env);
             printf ("\nReceived invalid OM as result : %s\n", buffer);
             if(NULL != buffer)
@@ -105,7 +105,7 @@
             }
             if(NULL != om_output)
             {
-                AXIS2_OM_OUTPUT_FREE(om_output, env);
+                AXIOM_OUTPUT_FREE(om_output, env);
                 om_output = NULL;
             }
         }
@@ -125,38 +125,38 @@
     return status;
 }
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, 
     const axis2_char_t *operation, 
     const axis2_char_t *param1, 
     const axis2_char_t *param2)
 {
-    axis2_om_node_t *math_om_node = NULL;
-    axis2_om_element_t* math_om_ele = NULL;
-    axis2_om_node_t* text_om_node = NULL;
-    axis2_om_element_t * text_om_ele = NULL;
-    axis2_om_namespace_t *ns1 = NULL;
+    axiom_node_t *math_om_node = NULL;
+    axiom_element_t* math_om_ele = NULL;
+    axiom_node_t* text_om_node = NULL;
+    axiom_element_t * text_om_ele = NULL;
+    axiom_namespace_t *ns1 = 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;
 
-    ns1 = axis2_om_namespace_create (env, "http://ws.apache.org/axis2/c/samplesmath", "ns1");
+    ns1 = axiom_namespace_create (env, "http://ws.apache.org/axis2/c/samplesmath", "ns1");
 
-    math_om_ele = axis2_om_element_create(env, NULL, operation, ns1, &math_om_node);
+    math_om_ele = axiom_element_create(env, NULL, operation, ns1, &math_om_node);
     
-    text_om_ele = axis2_om_element_create(env, math_om_node, "param1", NULL, &text_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(text_om_ele, env, param1, text_om_node);
+    text_om_ele = axiom_element_create(env, math_om_node, "param1", NULL, &text_om_node);
+    AXIOM_ELEMENT_SET_TEXT(text_om_ele, env, param1, text_om_node);
     
-    text_om_ele = axis2_om_element_create(env, math_om_node, "param2", NULL, &text_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(text_om_ele, env, param2, text_om_node);
+    text_om_ele = axiom_element_create(env, math_om_node, "param2", NULL, &text_om_node);
+    AXIOM_ELEMENT_SET_TEXT(text_om_ele, env, param2, text_om_node);
     
     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_OM_NODE_SERIALIZE(math_om_node, env, om_output);
+    AXIOM_NODE_SERIALIZE(math_om_node, env, om_output);
     buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(xml_writer, env);         
     AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "\nSending OM node in XML : %s \n",  buffer); 
     if(NULL != buffer)
@@ -166,7 +166,7 @@
     }
     if(NULL != om_output)
     {
-        AXIS2_OM_OUTPUT_FREE(om_output, env);
+        AXIOM_OUTPUT_FREE(om_output, env);
         om_output = NULL;
     }
 

Modified: webservices/axis2/trunk/c/samples/client/mtom/mtom_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/mtom/mtom_client.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/mtom/mtom_client.c (original)
+++ webservices/axis2/trunk/c/samples/client/mtom/mtom_client.c Mon Jun 12 01:26:30 2006
@@ -15,12 +15,12 @@
  */
 
 #include <stdio.h>
-#include <axis2_om.h>
+#include <axiom.h>
 #include <axis2_util.h>
 #include <axis2_soap.h>
 #include <axis2_client.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, 
     const axis2_char_t *image_name, 
     const axis2_char_t *to_save_name);
@@ -33,8 +33,8 @@
     axis2_options_t *options = NULL;
     const axis2_char_t *client_home = NULL;
     axis2_svc_client_t* svc_client = NULL;
-    axis2_om_node_t *payload = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *payload = NULL;
+    axiom_node_t *ret_node = NULL;
     const axis2_char_t *image_name = "resources/axis2.jpg";
     const axis2_char_t *to_save_name = "test.jpg";
 
@@ -104,7 +104,7 @@
     if(ret_node)
     {
         axis2_char_t *om_str = NULL;
-        om_str = AXIS2_OM_NODE_TO_STRING(ret_node, env);
+        om_str = AXIOM_NODE_TO_STRING(ret_node, env);
         if (om_str)
             printf("\nReceived OM : %s\n", om_str);
         printf("\nmtom client invoke SUCCESSFUL!\n");
@@ -133,33 +133,33 @@
 }
 
 /* build SOAP request message content using OM */
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, 
     const axis2_char_t *image_name, 
     const axis2_char_t *to_save_name)
 {
-    axis2_om_node_t *mtom_om_node = NULL;
-    axis2_om_element_t* mtom_om_ele = NULL;
-    axis2_om_node_t* image_om_node = NULL;
-    axis2_om_element_t * image_om_ele = NULL;
-    axis2_om_node_t* file_om_node = NULL;
-    axis2_om_element_t * file_om_ele = NULL;
-    axis2_om_node_t* data_om_node = NULL;
-    axis2_om_text_t * data_text = NULL;
-    axis2_om_namespace_t *ns1 = NULL;
+    axiom_node_t *mtom_om_node = NULL;
+    axiom_element_t* mtom_om_ele = NULL;
+    axiom_node_t* image_om_node = NULL;
+    axiom_element_t * image_om_ele = NULL;
+    axiom_node_t* file_om_node = NULL;
+    axiom_element_t * file_om_ele = NULL;
+    axiom_node_t* data_om_node = NULL;
+    axiom_text_t * data_text = NULL;
+    axiom_namespace_t *ns1 = NULL;
 
     axis2_data_handler_t *data_handler = NULL;
     
-    ns1 = axis2_om_namespace_create (env, "http://ws.apache.org/axis2/c/samples/mtom", "ns1");
-    mtom_om_ele = axis2_om_element_create(env, NULL, "mtomSample", ns1, &mtom_om_node);
+    ns1 = axiom_namespace_create (env, "http://ws.apache.org/axis2/c/samples/mtom", "ns1");
+    mtom_om_ele = axiom_element_create(env, NULL, "mtomSample", ns1, &mtom_om_node);
     
-    file_om_ele = axis2_om_element_create(env, mtom_om_node, "fileName", ns1, &file_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(file_om_ele, env, to_save_name, file_om_node);
+    file_om_ele = axiom_element_create(env, mtom_om_node, "fileName", ns1, &file_om_node);
+    AXIOM_ELEMENT_SET_TEXT(file_om_ele, env, to_save_name, file_om_node);
 
-    image_om_ele = axis2_om_element_create(env, mtom_om_node, "image", ns1, &image_om_node);
+    image_om_ele = axiom_element_create(env, mtom_om_node, "image", ns1, &image_om_node);
 
     data_handler = axis2_data_handler_create(env, image_name, "image/jpeg");
-    data_text = axis2_om_text_create_with_data_handler(env, image_om_node, data_handler, &data_om_node);
+    data_text = axiom_text_create_with_data_handler(env, image_om_node, data_handler, &data_om_node);
 
     return mtom_om_node;
 }

Modified: webservices/axis2/trunk/c/samples/client/notify/notify_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/client/notify/notify_client.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/client/notify/notify_client.c (original)
+++ webservices/axis2/trunk/c/samples/client/notify/notify_client.c Mon Jun 12 01:26:30 2006
@@ -15,12 +15,12 @@
  */
 
 #include <stdio.h>
-#include <axis2_om.h>
+#include <axiom.h>
 #include <axis2_util.h>
 #include <axis2_soap.h>
 #include <axis2_client.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env);
 
 int main(int argc, char** argv)
@@ -31,7 +31,7 @@
     axis2_options_t *options = NULL;
     const axis2_char_t *client_home = NULL;
     axis2_svc_client_t* svc_client = NULL;
-    axis2_om_node_t *payload = NULL;
+    axiom_node_t *payload = NULL;
     axis2_status_t status = AXIS2_FAILURE;
    
     /* Set up the environment */
@@ -117,19 +117,19 @@
 }
 
 /* build SOAP request message content using OM */
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env)
 {
-    axis2_om_node_t *notify_om_node = NULL;
-    axis2_om_element_t* notify_om_ele = NULL;
-    axis2_om_namespace_t *ns1 = NULL;
+    axiom_node_t *notify_om_node = NULL;
+    axiom_element_t* notify_om_ele = NULL;
+    axiom_namespace_t *ns1 = NULL;
     axis2_char_t *buffer = NULL;
     
-    ns1 = axis2_om_namespace_create (env, "http://example.org/notify", "m");
-    notify_om_ele = axis2_om_element_create(env, NULL, "notify", ns1, &notify_om_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(notify_om_ele, env, "notify5", notify_om_node);
+    ns1 = axiom_namespace_create (env, "http://example.org/notify", "m");
+    notify_om_ele = axiom_element_create(env, NULL, "notify", ns1, &notify_om_node);
+    AXIOM_ELEMENT_SET_TEXT(notify_om_ele, env, "notify5", notify_om_node);
     
-    buffer = AXIS2_OM_NODE_TO_STRING(notify_om_node, env);
+    buffer = AXIOM_NODE_TO_STRING(notify_om_node, env);
     printf("\nSending OM node in XML : %s \n",  buffer); 
 
     return notify_om_node;

Modified: webservices/axis2/trunk/c/samples/server/echo/echo.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/echo/echo.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/echo/echo.c (original)
+++ webservices/axis2/trunk/c/samples/server/echo/echo.c Mon Jun 12 01:26:30 2006
@@ -17,15 +17,15 @@
 #include <axis2_xml_writer.h>
 #include <stdio.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, axis2_char_t *text);
 
-axis2_om_node_t *
-axis2_echo_echo (const axis2_env_t *env, axis2_om_node_t *node)
+axiom_node_t *
+axis2_echo_echo (const axis2_env_t *env, axiom_node_t *node)
 {
-    axis2_om_node_t *text_parent_node = NULL;
-    axis2_om_node_t *text_node = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *text_parent_node = NULL;
+    axiom_node_t *text_node = NULL;
+    axiom_node_t *ret_node = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
    
@@ -43,19 +43,19 @@
    else
    {
       axis2_xml_writer_t *writer = NULL;
-      axis2_om_output_t *om_output = NULL;
+      axiom_output_t *om_output = NULL;
       axis2_char_t *buffer = NULL;
    
       writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
             AXIS2_XML_PARSER_TYPE_BUFFER);
-      om_output = axis2_om_output_create (env, writer);
+      om_output = axiom_output_create (env, writer);
 
-      AXIS2_OM_NODE_SERIALIZE (node, env, om_output);
+      AXIOM_NODE_SERIALIZE (node, env, om_output);
       buffer = AXIS2_XML_WRITER_GET_XML(writer, env);
       printf("buffer = %s \n", buffer);
    }
 
-    text_parent_node = AXIS2_OM_NODE_GET_FIRST_CHILD(node, env);
+    text_parent_node = AXIOM_NODE_GET_FIRST_CHILD(node, env);
     if (!text_parent_node) /* 'text' node */
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -63,7 +63,7 @@
         return NULL;
     }
     
-    text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(text_parent_node, env);
+    text_node = AXIOM_NODE_GET_FIRST_CHILD(text_parent_node, env);
     if (!text_node) /* actual text to echo */
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -71,12 +71,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text , env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text , env))
         {
-            axis2_char_t *text_str = AXIS2_OM_TEXT_GET_VALUE(text, env);
+            axis2_char_t *text_str = AXIOM_TEXT_GET_VALUE(text, env);
             printf("Echoing text value  %s \n", text_str);
             ret_node = build_om_programatically(env, text_str);
         }
@@ -92,22 +92,22 @@
 }
 
 /* Builds the response content */
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, axis2_char_t *text)
 {
-    axis2_om_node_t *echo_om_node = NULL;
-    axis2_om_element_t* echo_om_ele = NULL;
-    axis2_om_node_t* text_om_node = NULL;
-    axis2_om_element_t * text_om_ele = NULL;
-    axis2_om_namespace_t *ns1 = NULL;
+    axiom_node_t *echo_om_node = NULL;
+    axiom_element_t* echo_om_ele = NULL;
+    axiom_node_t* text_om_node = NULL;
+    axiom_element_t * text_om_ele = NULL;
+    axiom_namespace_t *ns1 = NULL;
     
-    ns1 = axis2_om_namespace_create (env, "http://ws.apache.org/axis2/c/samples", "ns1");
+    ns1 = axiom_namespace_create (env, "http://ws.apache.org/axis2/c/samples", "ns1");
 
-    echo_om_ele = axis2_om_element_create(env, NULL, "echoString", ns1, &echo_om_node);
+    echo_om_ele = axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node);
     
-    text_om_ele = axis2_om_element_create(env, echo_om_node, "text", NULL, &text_om_node);
+    text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node);
 
-    AXIS2_OM_ELEMENT_SET_TEXT(text_om_ele, env, text, text_om_node);
+    AXIOM_ELEMENT_SET_TEXT(text_om_ele, env, text, text_om_node);
     
     return echo_om_node;
 }

Modified: webservices/axis2/trunk/c/samples/server/echo/echo.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/echo/echo.h?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/echo/echo.h (original)
+++ webservices/axis2/trunk/c/samples/server/echo/echo.h Mon Jun 12 01:26:30 2006
@@ -20,10 +20,10 @@
 #include <axis2_svc_skeleton.h>
 #include <axis2_log_default.h>
 #include <axis2_error_default.h>
-#include <axis2_om_text.h>
-#include <axis2_om_node.h>
-#include <axis2_om_element.h>
+#include <axiom_text.h>
+#include <axiom_node.h>
+#include <axiom_element.h>
 
-axis2_om_node_t *axis2_echo_echo(const axis2_env_t *env, axis2_om_node_t *node);
+axiom_node_t *axis2_echo_echo(const axis2_env_t *env, axiom_node_t *node);
 
 #endif /* CALC_H*/

Modified: webservices/axis2/trunk/c/samples/server/echo/echo_skeleton.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/echo/echo_skeleton.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/echo/echo_skeleton.c (original)
+++ webservices/axis2/trunk/c/samples/server/echo/echo_skeleton.c Mon Jun 12 01:26:30 2006
@@ -28,10 +28,10 @@
 /*
  * This method invokes the right service method 
  */
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 echo_invoke(axis2_svc_skeleton_t *svc_skeleton,
             const axis2_env_t *env,
-            axis2_om_node_t *node,
+            axiom_node_t *node,
             axis2_msg_ctx_t *msg_ctx);
             
 
@@ -39,9 +39,9 @@
 echo_init(axis2_svc_skeleton_t *svc_skeleton,
           const axis2_env_t *env);
 
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 echo_on_fault(axis2_svc_skeleton_t *svc_skeli, 
-              const axis2_env_t *env, axis2_om_node_t *node);
+              const axis2_env_t *env, axiom_node_t *node);
 
 /*Create function */
 axis2_svc_skeleton_t *
@@ -82,10 +82,10 @@
 /*
  * This method invokes the right service method 
  */
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 echo_invoke(axis2_svc_skeleton_t *svc_skeleton,
             const axis2_env_t *env,
-            axis2_om_node_t *node,
+            axiom_node_t *node,
             axis2_msg_ctx_t *msg_ctx)
 {
     /* Invoke the business logic.
@@ -98,19 +98,19 @@
 }
 
 /* On fault, handle the fault */
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 echo_on_fault(axis2_svc_skeleton_t *svc_skeli, 
-              const axis2_env_t *env, axis2_om_node_t *node)
+              const axis2_env_t *env, axiom_node_t *node)
 {
    /* Here we are just setting a simple error message inside an element 
     * called 'EchoServiceError' 
     */
-    axis2_om_node_t *error_node = NULL;
-    axis2_om_node_t* text_node = NULL;
-    axis2_om_element_t *error_ele = NULL;
-    error_ele = axis2_om_element_create(env, node, "EchoServiceError", NULL, 
+    axiom_node_t *error_node = NULL;
+    axiom_node_t* text_node = NULL;
+    axiom_element_t *error_ele = NULL;
+    error_ele = axiom_element_create(env, node, "EchoServiceError", NULL, 
         &error_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(error_ele, env, "Echo service failed ", 
+    AXIOM_ELEMENT_SET_TEXT(error_ele, env, "Echo service failed ", 
         text_node);
     return error_node;
 }

Modified: webservices/axis2/trunk/c/samples/server/math/math.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/math/math.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/math/math.c (original)
+++ webservices/axis2/trunk/c/samples/server/math/math.c Mon Jun 12 01:26:30 2006
@@ -16,15 +16,15 @@
 #include "math.h"
 #include <stdio.h>
 
-axis2_om_node_t *
-axis2_math_add (const axis2_env_t *env, axis2_om_node_t *node)
+axiom_node_t *
+axis2_math_add (const axis2_env_t *env, axiom_node_t *node)
 {
-    axis2_om_node_t *param1_node = NULL;
-    axis2_om_node_t *param1_text_node = NULL;
+    axiom_node_t *param1_node = NULL;
+    axiom_node_t *param1_text_node = NULL;
     axis2_char_t *param1_str = NULL;
     long int param1 = 0;
-    axis2_om_node_t *param2_node = NULL;
-    axis2_om_node_t *param2_text_node = NULL;
+    axiom_node_t *param2_node = NULL;
+    axiom_node_t *param2_text_node = NULL;
     axis2_char_t *param2_str = NULL;
     long int param2 = 0;
 
@@ -35,7 +35,7 @@
         return NULL;
     }
 
-    param1_node = AXIS2_OM_NODE_GET_FIRST_CHILD(node, env);
+    param1_node = AXIOM_NODE_GET_FIRST_CHILD(node, env);
     if (!param1_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -43,7 +43,7 @@
         return NULL;
     }
     
-    param1_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param1_node, env);
+    param1_text_node = AXIOM_NODE_GET_FIRST_CHILD(param1_node, env);
     if (!param1_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -51,12 +51,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param1_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param1_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -66,7 +66,7 @@
         return NULL;
     }
    
-    param2_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(param1_node, env);
+    param2_node = AXIOM_NODE_GET_NEXT_SIBLING(param1_node, env);
     if (!param2_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -74,7 +74,7 @@
         return NULL;
     }
     
-    param2_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param2_node, env);
+    param2_text_node = AXIOM_NODE_GET_FIRST_CHILD(param2_node, env);
     if (!param2_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -82,12 +82,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param2_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param2_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -102,10 +102,10 @@
         long int result = 0;
         axis2_char_t result_str[255];
 
-        axis2_om_element_t *ele1 = NULL;
-        axis2_om_node_t *node1 = NULL, *node2 = NULL;
-        axis2_om_namespace_t *ns1 = NULL;
-        axis2_om_text_t *text1 = NULL;
+        axiom_element_t *ele1 = NULL;
+        axiom_node_t *node1 = NULL, *node2 = NULL;
+        axiom_namespace_t *ns1 = NULL;
+        axiom_text_t *text1 = NULL;
         
         param1 = strtol(param1_str, NULL, 10);
         param2 = strtol(param2_str, NULL, 10);
@@ -114,11 +114,11 @@
 
         
 
-        ns1 = axis2_om_namespace_create (env,
+        ns1 = axiom_namespace_create (env,
                                    "http://axis2/test/namespace1",
                                    "ns1");
-        ele1 = axis2_om_element_create (env, NULL, "result", ns1, &node1);
-        text1 = axis2_om_text_create (env, node1, result_str, &node2);
+        ele1 = axiom_element_create (env, NULL, "result", ns1, &node1);
+        text1 = axiom_text_create (env, node1, result_str, &node2);
 
         return node1;
     }
@@ -128,15 +128,15 @@
     return NULL;
 }
 
-axis2_om_node_t *
-axis2_math_sub (const axis2_env_t *env, axis2_om_node_t *node)
+axiom_node_t *
+axis2_math_sub (const axis2_env_t *env, axiom_node_t *node)
 {
-    axis2_om_node_t *param1_node = NULL;
-    axis2_om_node_t *param1_text_node = NULL;
+    axiom_node_t *param1_node = NULL;
+    axiom_node_t *param1_text_node = NULL;
     axis2_char_t *param1_str = NULL;
     long int param1 = 0;
-    axis2_om_node_t *param2_node = NULL;
-    axis2_om_node_t *param2_text_node = NULL;
+    axiom_node_t *param2_node = NULL;
+    axiom_node_t *param2_text_node = NULL;
     axis2_char_t *param2_str = NULL;
     long int param2 = 0;
 
@@ -147,7 +147,7 @@
         return NULL;
     }
 
-    param1_node = AXIS2_OM_NODE_GET_FIRST_CHILD(node, env);
+    param1_node = AXIOM_NODE_GET_FIRST_CHILD(node, env);
     if (!param1_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -155,7 +155,7 @@
         return NULL;
     }
     
-    param1_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param1_node, env);
+    param1_text_node = AXIOM_NODE_GET_FIRST_CHILD(param1_node, env);
     if (!param1_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -163,12 +163,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param1_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param1_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -178,7 +178,7 @@
         return NULL;
     }
    
-    param2_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(param1_node, env);
+    param2_node = AXIOM_NODE_GET_NEXT_SIBLING(param1_node, env);
     if (!param2_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -186,7 +186,7 @@
         return NULL;
     }
     
-    param2_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param2_node, env);
+    param2_text_node = AXIOM_NODE_GET_FIRST_CHILD(param2_node, env);
     if (!param2_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -194,12 +194,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param2_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param2_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -214,10 +214,10 @@
         long int result = 0;
         axis2_char_t result_str[255];
 
-        axis2_om_element_t *ele1 = NULL;
-        axis2_om_node_t *node1 = NULL, *node2 = NULL;
-        axis2_om_namespace_t *ns1 = NULL;
-        axis2_om_text_t *text1 = NULL;
+        axiom_element_t *ele1 = NULL;
+        axiom_node_t *node1 = NULL, *node2 = NULL;
+        axiom_namespace_t *ns1 = NULL;
+        axiom_text_t *text1 = NULL;
         
         param1 = strtol(param1_str, NULL, 10);
         param2 = strtol(param2_str, NULL, 10);
@@ -226,11 +226,11 @@
 
         
 
-        ns1 = axis2_om_namespace_create (env,
+        ns1 = axiom_namespace_create (env,
                                    "http://axis2/test/namespace1",
                                    "ns1");
-        ele1 = axis2_om_element_create (env, NULL, "result", ns1, &node1);
-        text1 = axis2_om_text_create (env, node1, result_str, &node2);
+        ele1 = axiom_element_create (env, NULL, "result", ns1, &node1);
+        text1 = axiom_text_create (env, node1, result_str, &node2);
 
         return node1;
     }
@@ -241,15 +241,15 @@
 }
 
 
-axis2_om_node_t *
-axis2_math_mul (const axis2_env_t *env, axis2_om_node_t *node)
+axiom_node_t *
+axis2_math_mul (const axis2_env_t *env, axiom_node_t *node)
 {
-    axis2_om_node_t *param1_node = NULL;
-    axis2_om_node_t *param1_text_node = NULL;
+    axiom_node_t *param1_node = NULL;
+    axiom_node_t *param1_text_node = NULL;
     axis2_char_t *param1_str = NULL;
     long int param1 = 0;
-    axis2_om_node_t *param2_node = NULL;
-    axis2_om_node_t *param2_text_node = NULL;
+    axiom_node_t *param2_node = NULL;
+    axiom_node_t *param2_text_node = NULL;
     axis2_char_t *param2_str = NULL;
     long int param2 = 0;
 
@@ -260,7 +260,7 @@
         return NULL;
     }
 
-    param1_node = AXIS2_OM_NODE_GET_FIRST_CHILD(node, env);
+    param1_node = AXIOM_NODE_GET_FIRST_CHILD(node, env);
     if (!param1_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -268,7 +268,7 @@
         return NULL;
     }
     
-    param1_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param1_node, env);
+    param1_text_node = AXIOM_NODE_GET_FIRST_CHILD(param1_node, env);
     if (!param1_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -276,12 +276,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param1_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param1_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -291,7 +291,7 @@
         return NULL;
     }
    
-    param2_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(param1_node, env);
+    param2_node = AXIOM_NODE_GET_NEXT_SIBLING(param1_node, env);
     if (!param2_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -299,7 +299,7 @@
         return NULL;
     }
     
-    param2_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param2_node, env);
+    param2_text_node = AXIOM_NODE_GET_FIRST_CHILD(param2_node, env);
     if (!param2_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -307,12 +307,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param2_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param2_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -327,10 +327,10 @@
         long int result = 0;
         axis2_char_t result_str[255];
 
-        axis2_om_element_t *ele1 = NULL;
-        axis2_om_node_t *node1 = NULL, *node2 = NULL;
-        axis2_om_namespace_t *ns1 = NULL;
-        axis2_om_text_t *text1 = NULL;
+        axiom_element_t *ele1 = NULL;
+        axiom_node_t *node1 = NULL, *node2 = NULL;
+        axiom_namespace_t *ns1 = NULL;
+        axiom_text_t *text1 = NULL;
         
         param1 = strtol(param1_str, NULL, 10);
         param2 = strtol(param2_str, NULL, 10);
@@ -339,11 +339,11 @@
 
         
 
-        ns1 = axis2_om_namespace_create (env,
+        ns1 = axiom_namespace_create (env,
                                    "http://axis2/test/namespace1",
                                    "ns1");
-        ele1 = axis2_om_element_create (env, NULL, "result", ns1, &node1);
-        text1 = axis2_om_text_create (env, node1, result_str, &node2);
+        ele1 = axiom_element_create (env, NULL, "result", ns1, &node1);
+        text1 = axiom_text_create (env, node1, result_str, &node2);
 
         return node1;
     }
@@ -354,15 +354,15 @@
 }
 
 
-axis2_om_node_t *
-axis2_math_div (const axis2_env_t *env, axis2_om_node_t *node)
+axiom_node_t *
+axis2_math_div (const axis2_env_t *env, axiom_node_t *node)
 {
-    axis2_om_node_t *param1_node = NULL;
-    axis2_om_node_t *param1_text_node = NULL;
+    axiom_node_t *param1_node = NULL;
+    axiom_node_t *param1_text_node = NULL;
     axis2_char_t *param1_str = NULL;
     long int param1 = 0;
-    axis2_om_node_t *param2_node = NULL;
-    axis2_om_node_t *param2_text_node = NULL;
+    axiom_node_t *param2_node = NULL;
+    axiom_node_t *param2_text_node = NULL;
     axis2_char_t *param2_str = NULL;
     long int param2 = 0;
 
@@ -373,7 +373,7 @@
         return NULL;
     }
 
-    param1_node = AXIS2_OM_NODE_GET_FIRST_CHILD(node, env);
+    param1_node = AXIOM_NODE_GET_FIRST_CHILD(node, env);
     if (!param1_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -381,7 +381,7 @@
         return NULL;
     }
     
-    param1_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param1_node, env);
+    param1_text_node = AXIOM_NODE_GET_FIRST_CHILD(param1_node, env);
     if (!param1_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -389,12 +389,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param1_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param1_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param1_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param1_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -404,7 +404,7 @@
         return NULL;
     }
    
-    param2_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(param1_node, env);
+    param2_node = AXIOM_NODE_GET_NEXT_SIBLING(param1_node, env);
     if (!param2_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -412,7 +412,7 @@
         return NULL;
     }
     
-    param2_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(param2_node, env);
+    param2_text_node = AXIOM_NODE_GET_FIRST_CHILD(param2_node, env);
     if (!param2_text_node)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -420,12 +420,12 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(param2_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text ,env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(param2_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text ,env))
         {
-            param2_str = AXIS2_OM_TEXT_GET_VALUE(text,env);
+            param2_str = AXIOM_TEXT_GET_VALUE(text,env);
         }
     }
     else
@@ -440,10 +440,10 @@
         long int result = 0;
         axis2_char_t result_str[255];
 
-        axis2_om_element_t *ele1 = NULL;
-        axis2_om_node_t *node1 = NULL, *node2 = NULL;
-        axis2_om_namespace_t *ns1 = NULL;
-        axis2_om_text_t *text1 = NULL;
+        axiom_element_t *ele1 = NULL;
+        axiom_node_t *node1 = NULL, *node2 = NULL;
+        axiom_namespace_t *ns1 = NULL;
+        axiom_text_t *text1 = NULL;
         
         param1 = strtol(param1_str, NULL, 10);
         param2 = strtol(param2_str, NULL, 10);
@@ -454,11 +454,11 @@
 
         
 
-        ns1 = axis2_om_namespace_create (env,
+        ns1 = axiom_namespace_create (env,
                                    "http://axis2/test/namespace1",
                                    "ns1");
-        ele1 = axis2_om_element_create (env, NULL, "result", ns1, &node1);
-        text1 = axis2_om_text_create (env, node1, result_str, &node2);
+        ele1 = axiom_element_create (env, NULL, "result", ns1, &node1);
+        text1 = axiom_text_create (env, node1, result_str, &node2);
 
         return node1;
     }

Modified: webservices/axis2/trunk/c/samples/server/math/math.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/math/math.h?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/math/math.h (original)
+++ webservices/axis2/trunk/c/samples/server/math/math.h Mon Jun 12 01:26:30 2006
@@ -20,13 +20,13 @@
 #include <axis2_svc_skeleton.h>
 #include <axis2_log_default.h>
 #include <axis2_error_default.h>
-#include <axis2_om_text.h>
-#include <axis2_om_node.h>
-#include <axis2_om_element.h>
+#include <axiom_text.h>
+#include <axiom_node.h>
+#include <axiom_element.h>
 
-axis2_om_node_t *axis2_math_add(const axis2_env_t *env, axis2_om_node_t *node);
-axis2_om_node_t *axis2_math_sub(const axis2_env_t *env, axis2_om_node_t *node);
-axis2_om_node_t *axis2_math_mul(const axis2_env_t *env, axis2_om_node_t *node);
-axis2_om_node_t *axis2_math_div(const axis2_env_t *env, axis2_om_node_t *node);
+axiom_node_t *axis2_math_add(const axis2_env_t *env, axiom_node_t *node);
+axiom_node_t *axis2_math_sub(const axis2_env_t *env, axiom_node_t *node);
+axiom_node_t *axis2_math_mul(const axis2_env_t *env, axiom_node_t *node);
+axiom_node_t *axis2_math_div(const axis2_env_t *env, axiom_node_t *node);
 
 #endif /* MATH_H*/

Modified: webservices/axis2/trunk/c/samples/server/math/math_skeleton.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/math/math_skeleton.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/math/math_skeleton.c (original)
+++ webservices/axis2/trunk/c/samples/server/math/math_skeleton.c Mon Jun 12 01:26:30 2006
@@ -25,10 +25,10 @@
 /*
  * This method invokes the right service method 
  */
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 math_invoke(axis2_svc_skeleton_t *svc_skeleton,
             const axis2_env_t *env,
-            axis2_om_node_t *node,
+            axiom_node_t *node,
             axis2_msg_ctx_t *msg_ctx);
 
 int AXIS2_CALL math_init(axis2_svc_skeleton_t *svc_skeleton,
@@ -97,10 +97,10 @@
 /*
  * This method invokes the right service method 
  */
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 math_invoke(axis2_svc_skeleton_t *svc_skeleton,
             const axis2_env_t *env,
-            axis2_om_node_t *node,
+            axiom_node_t *node,
             axis2_msg_ctx_t *msg_ctx)
 {
     /* Depending on the function name invoke the
@@ -108,13 +108,13 @@
      */
     if (node)
     {
-        if (AXIS2_OM_NODE_GET_NODE_TYPE(node, env) == AXIS2_OM_ELEMENT)
+        if (AXIOM_NODE_GET_NODE_TYPE(node, env) == AXIOM_ELEMENT)
         {
-            axis2_om_element_t *element = NULL;
-            element = (axis2_om_element_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env);
+            axiom_element_t *element = NULL;
+            element = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(node, env);
             if (element)
             {
-                axis2_char_t *op_name = AXIS2_OM_ELEMENT_GET_LOCALNAME(element, env);
+                axis2_char_t *op_name = AXIOM_ELEMENT_GET_LOCALNAME(element, env);
                 if (op_name)
                 {
                     if ( AXIS2_STRCMP(op_name, "add") == 0 )

Modified: webservices/axis2/trunk/c/samples/server/mtom/mtom.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/mtom/mtom.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/mtom/mtom.c (original)
+++ webservices/axis2/trunk/c/samples/server/mtom/mtom.c Mon Jun 12 01:26:30 2006
@@ -16,15 +16,15 @@
 #include "mtom.h"
 #include <stdio.h>
 
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, axis2_char_t *text);
 
-axis2_om_node_t *
-axis2_mtom_mtom (const axis2_env_t *env, axis2_om_node_t *node)
+axiom_node_t *
+axis2_mtom_mtom (const axis2_env_t *env, axiom_node_t *node)
 {
-    axis2_om_node_t *file_name_node = NULL;
-    axis2_om_node_t *file_text_node = NULL;
-    axis2_om_node_t *ret_node = NULL;
+    axiom_node_t *file_name_node = NULL;
+    axiom_node_t *file_text_node = NULL;
+    axiom_node_t *ret_node = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
    
@@ -43,7 +43,7 @@
         return NULL;
     }
 
-    file_name_node = AXIS2_OM_NODE_GET_FIRST_CHILD(node, env);
+    file_name_node = AXIOM_NODE_GET_FIRST_CHILD(node, env);
     if (!file_name_node) /* 'text' node */
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -51,7 +51,7 @@
         return NULL;
     }
     
-    file_text_node = AXIS2_OM_NODE_GET_FIRST_CHILD(file_name_node, env);
+    file_text_node = AXIOM_NODE_GET_FIRST_CHILD(file_name_node, env);
     if (!file_text_node) /* actual text to mtom */
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
@@ -59,30 +59,30 @@
         return NULL;
     }
     
-    if (AXIS2_OM_NODE_GET_NODE_TYPE(file_text_node, env) == AXIS2_OM_TEXT)
+    if (AXIOM_NODE_GET_NODE_TYPE(file_text_node, env) == AXIOM_TEXT)
     {
-        axis2_om_text_t *text = (axis2_om_text_t *)AXIS2_OM_NODE_GET_DATA_ELEMENT(file_text_node, env);
-        if( text && AXIS2_OM_TEXT_GET_VALUE(text , env))
+        axiom_text_t *text = (axiom_text_t *)AXIOM_NODE_GET_DATA_ELEMENT(file_text_node, env);
+        if( text && AXIOM_TEXT_GET_VALUE(text , env))
         {
-            axis2_om_node_t *image_node = NULL;
-            axis2_char_t *text_str = AXIS2_OM_TEXT_GET_VALUE(text, env);
+            axiom_node_t *image_node = NULL;
+            axis2_char_t *text_str = AXIOM_TEXT_GET_VALUE(text, env);
             printf("File Name  %s \n", text_str);
             
-            image_node = AXIS2_OM_NODE_GET_NEXT_SIBLING(file_name_node, env);
+            image_node = AXIOM_NODE_GET_NEXT_SIBLING(file_name_node, env);
             if (image_node)
             {
-                axis2_om_node_t *inc_node = NULL;
-                inc_node = AXIS2_OM_NODE_GET_FIRST_CHILD(image_node, env);
+                axiom_node_t *inc_node = NULL;
+                inc_node = AXIOM_NODE_GET_FIRST_CHILD(image_node, env);
                 if (inc_node)
                 {
-                    axis2_om_node_t *binary_node = NULL;
-                    binary_node = AXIS2_OM_NODE_GET_FIRST_CHILD(inc_node, env);
+                    axiom_node_t *binary_node = NULL;
+                    binary_node = AXIOM_NODE_GET_FIRST_CHILD(inc_node, env);
                     if (binary_node)
                     {
                         axis2_data_handler_t *data_handler = NULL;
-                        axis2_om_text_t *bin_text = (axis2_om_text_t *)
-                            AXIS2_OM_NODE_GET_DATA_ELEMENT(binary_node, env);
-                        data_handler = AXIS2_OM_TEXT_SET_GET_DATA_HANDLER(bin_text, env);
+                        axiom_text_t *bin_text = (axiom_text_t *)
+                            AXIOM_NODE_GET_DATA_ELEMENT(binary_node, env);
+                        data_handler = AXIOM_TEXT_SET_GET_DATA_HANDLER(bin_text, env);
                         if (data_handler)
                         {
                             AXIS2_DATA_HANDLER_SET_FILE_NAME(data_handler, env, text_str);
@@ -106,18 +106,18 @@
 }
 
 /* Builds the response content */
-axis2_om_node_t *
+axiom_node_t *
 build_om_programatically(const axis2_env_t *env, axis2_char_t *text)
 {
-    axis2_om_node_t *mtom_om_node = NULL;
-    axis2_om_element_t* mtom_om_ele = NULL;
-    axis2_om_namespace_t *ns1 = NULL;
+    axiom_node_t *mtom_om_node = NULL;
+    axiom_element_t* mtom_om_ele = NULL;
+    axiom_namespace_t *ns1 = NULL;
     
-    ns1 = axis2_om_namespace_create (env, "http://ws.apache.org/axis2/c/samples", "ns1");
+    ns1 = axiom_namespace_create (env, "http://ws.apache.org/axis2/c/samples", "ns1");
 
-    mtom_om_ele = axis2_om_element_create(env, NULL, "response", ns1, &mtom_om_node);
+    mtom_om_ele = axiom_element_create(env, NULL, "response", ns1, &mtom_om_node);
     
-    AXIS2_OM_ELEMENT_SET_TEXT(mtom_om_ele, env, "Image Saved", mtom_om_node);
+    AXIOM_ELEMENT_SET_TEXT(mtom_om_ele, env, "Image Saved", mtom_om_node);
     
     return mtom_om_node;
 }

Modified: webservices/axis2/trunk/c/samples/server/mtom/mtom.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/mtom/mtom.h?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/mtom/mtom.h (original)
+++ webservices/axis2/trunk/c/samples/server/mtom/mtom.h Mon Jun 12 01:26:30 2006
@@ -20,10 +20,10 @@
 #include <axis2_svc_skeleton.h>
 #include <axis2_log_default.h>
 #include <axis2_error_default.h>
-#include <axis2_om_text.h>
-#include <axis2_om_node.h>
-#include <axis2_om_element.h>
+#include <axiom_text.h>
+#include <axiom_node.h>
+#include <axiom_element.h>
 
-axis2_om_node_t *axis2_mtom_mtom(const axis2_env_t *env, axis2_om_node_t *node);
+axiom_node_t *axis2_mtom_mtom(const axis2_env_t *env, axiom_node_t *node);
 
 #endif /* CALC_H*/

Modified: webservices/axis2/trunk/c/samples/server/mtom/mtom_skeleton.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/samples/server/mtom/mtom_skeleton.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/samples/server/mtom/mtom_skeleton.c (original)
+++ webservices/axis2/trunk/c/samples/server/mtom/mtom_skeleton.c Mon Jun 12 01:26:30 2006
@@ -28,10 +28,10 @@
 /*
  * This method invokes the right service method 
  */
-axis2_om_node_t* AXIS2_CALL 
+axiom_node_t* AXIS2_CALL 
 mtom_invoke(axis2_svc_skeleton_t *svc_skeleton,
             const axis2_env_t *env,
-            axis2_om_node_t *node,
+            axiom_node_t *node,
             axis2_msg_ctx_t *msg_ctx);
             
 
@@ -39,9 +39,9 @@
 mtom_init(axis2_svc_skeleton_t *svc_skeleton,
           const axis2_env_t *env);
 
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 mtom_on_fault(axis2_svc_skeleton_t *svc_skeli, 
-              const axis2_env_t *env, axis2_om_node_t *node);
+              const axis2_env_t *env, axiom_node_t *node);
 
 /*Create function */
 axis2_svc_skeleton_t *
@@ -82,10 +82,10 @@
 /*
  * This method invokes the right service method 
  */
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 mtom_invoke(axis2_svc_skeleton_t *svc_skeleton,
             const axis2_env_t *env,
-            axis2_om_node_t *node,
+            axiom_node_t *node,
             axis2_msg_ctx_t *msg_ctx)
 {
     /* Invoke the business logic.
@@ -98,19 +98,19 @@
 }
 
 /* On fault, handle the fault */
-axis2_om_node_t* AXIS2_CALL
+axiom_node_t* AXIS2_CALL
 mtom_on_fault(axis2_svc_skeleton_t *svc_skeli, 
-              const axis2_env_t *env, axis2_om_node_t *node)
+              const axis2_env_t *env, axiom_node_t *node)
 {
    /* Here we are just setting a simple error message inside an element 
     * called 'EchoServiceError' 
     */
-    axis2_om_node_t *error_node = NULL;
-    axis2_om_node_t* text_node = NULL;
-    axis2_om_element_t *error_ele = NULL;
-    error_ele = axis2_om_element_create(env, node, "EchoServiceError", NULL, 
+    axiom_node_t *error_node = NULL;
+    axiom_node_t* text_node = NULL;
+    axiom_element_t *error_ele = NULL;
+    error_ele = axiom_element_create(env, node, "EchoServiceError", NULL, 
         &error_node);
-    AXIS2_OM_ELEMENT_SET_TEXT(error_ele, env, "Echo service failed ", 
+    AXIOM_ELEMENT_SET_TEXT(error_ele, env, "Echo service failed ", 
         text_node);
     return error_node;
 }



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