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 [2/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/core/deployment/conf_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c Mon Jun 12 01:26:30 2006
@@ -48,35 +48,35 @@
 axis2_status_t AXIS2_CALL
 axis2_conf_builder_process_module_refs(axis2_conf_builder_t *conf_builder,
                                 const axis2_env_t *env,
-                                axis2_om_children_qname_iterator_t *module_refs);
+                                axiom_children_qname_iterator_t *module_refs);
 
 static axis2_status_t
 axis2_conf_builder_process_disp_order(axis2_conf_builder_t *conf_builder,
                                                 const axis2_env_t *env,
-                                                axis2_om_node_t *disp_order);
+                                                axiom_node_t *disp_order);
 
 static axis2_status_t
 axis2_conf_builder_process_phase_orders(axis2_conf_builder_t *conf_builder,
                             const axis2_env_t *env,
-                            axis2_om_children_qname_iterator_t *phase_orders);
+                            axiom_children_qname_iterator_t *phase_orders);
 static axis2_array_list_t *
 axis2_conf_builder_get_phase_list(axis2_conf_builder_t *conf_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *phase_orders);
+                                    axiom_node_t *phase_orders);
 static axis2_status_t
 axis2_conf_builder_process_transport_senders(axis2_conf_builder_t *conf_builder,
                             const axis2_env_t *env,
-                            axis2_om_children_qname_iterator_t *trs_senders);
+                            axiom_children_qname_iterator_t *trs_senders);
 static axis2_status_t
 axis2_conf_builder_process_transport_recvs(axis2_conf_builder_t *conf_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_children_qname_iterator_t *trs_recvs);
+                                    axiom_children_qname_iterator_t *trs_recvs);
                                     
 axis2_status_t AXIS2_CALL
 axis2_conf_builder_process_default_module_versions(
                             axis2_conf_builder_t *conf_builder,
                             const axis2_env_t *env, 
-                            axis2_om_children_qname_iterator_t *module_versions);
+                            axiom_children_qname_iterator_t *module_versions);
 /************************** End of function prototypes ************************/
 
 AXIS2_EXTERN axis2_conf_builder_t * AXIS2_CALL 
@@ -187,17 +187,17 @@
     axis2_qname_t *qtransportrecv = NULL;
     axis2_qname_t *qphaseorder = NULL;
     axis2_qname_t *qdefmodver = NULL;
-    axis2_om_children_qname_iterator_t *itr = NULL;
-    axis2_om_children_qname_iterator_t *msg_recvs = NULL;
-    axis2_om_children_qname_iterator_t *module_itr = NULL;
-    axis2_om_children_qname_iterator_t *trs_senders = NULL;
-    axis2_om_children_qname_iterator_t *trs_recvs = NULL;
-    axis2_om_children_qname_iterator_t *phase_orders = NULL;
-    axis2_om_children_qname_iterator_t *def_mod_versions = NULL;
-    axis2_om_element_t *conf_element = NULL;
-    axis2_om_node_t *conf_node = NULL;
-    axis2_om_element_t *disp_order_element = NULL;
-    axis2_om_node_t *disp_order_node = NULL;
+    axiom_children_qname_iterator_t *itr = NULL;
+    axiom_children_qname_iterator_t *msg_recvs = NULL;
+    axiom_children_qname_iterator_t *module_itr = NULL;
+    axiom_children_qname_iterator_t *trs_senders = NULL;
+    axiom_children_qname_iterator_t *trs_recvs = NULL;
+    axiom_children_qname_iterator_t *phase_orders = NULL;
+    axiom_children_qname_iterator_t *def_mod_versions = NULL;
+    axiom_element_t *conf_element = NULL;
+    axiom_node_t *conf_node = NULL;
+    axiom_element_t *disp_order_element = NULL;
+    axiom_node_t *disp_order_node = NULL;
     axis2_status_t status = AXIS2_FAILURE;
    
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -208,33 +208,33 @@
     {
         return AXIS2_FAILURE;
     }
-    conf_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(conf_node, env);
+    conf_element = AXIOM_NODE_GET_DATA_ELEMENT(conf_node, env);
     /* processing Paramters */
     /* Processing service level paramters */
     qparamst = axis2_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-    itr = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env, qparamst,
+    itr = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env, qparamst,
         conf_node);
     AXIS2_QNAME_FREE(qparamst, env);
     AXIS2_DESC_BUILDER_PROCESS_PARAMS(conf_builder->desc_builder, env, itr,
         builder_impl->conf->param_container, builder_impl->conf->param_container);
     /* process MessageReciver */
     qmsgrecv = axis2_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL);
-    msg_recvs = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
+    msg_recvs = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
         qmsgrecv, conf_node);
     AXIS2_QNAME_FREE(qmsgrecv, env);
-    while(AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(msg_recvs, env))
+    while(AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(msg_recvs, env))
     {
-        axis2_om_node_t *msg_recv_node = NULL;
-        axis2_om_element_t *msg_recv_element = NULL;
+        axiom_node_t *msg_recv_node = NULL;
+        axiom_element_t *msg_recv_element = NULL;
         axis2_msg_recv_t *msg_recv = NULL;
-        axis2_om_attribute_t *mep_att = NULL;
+        axiom_attribute_t *mep_att = NULL;
         axis2_qname_t *qmep = NULL;
         axis2_char_t *att_value = NULL;
         
-        msg_recv_node = (axis2_om_node_t *) 
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(msg_recvs, env);
-        msg_recv_element = (axis2_om_element_t *) 
-            AXIS2_OM_NODE_GET_DATA_ELEMENT(msg_recv_node, env);
+        msg_recv_node = (axiom_node_t *) 
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(msg_recvs, env);
+        msg_recv_element = (axiom_element_t *) 
+            AXIOM_NODE_GET_DATA_ELEMENT(msg_recv_node, env);
         msg_recv = AXIS2_DESC_BUILDER_LOAD_MSG_RECV(conf_builder->desc_builder,
             env, msg_recv_element);
         if(!msg_recv)
@@ -242,15 +242,15 @@
             return AXIS2_FAILURE;
         }
         qmep = axis2_qname_create(env, AXIS2_MEP, NULL, NULL);
-        mep_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(msg_recv_element, env, qmep);
-        att_value = AXIS2_OM_ATTRIBUTE_GET_VALUE(mep_att, env);
+        mep_att = AXIOM_ELEMENT_GET_ATTRIBUTE(msg_recv_element, env, qmep);
+        att_value = AXIOM_ATTRIBUTE_GET_VALUE(mep_att, env);
         AXIS2_CONF_ADD_MSG_RECV(builder_impl->conf, env, att_value, msg_recv);
         AXIS2_QNAME_FREE(qmep, env);
     }
     
     /* processing Dispatching Order */
     qdisporder = axis2_qname_create(env, AXIS2_DISPATCH_ORDER, NULL, NULL);
-    disp_order_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+    disp_order_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
         conf_element, env, qdisporder, conf_node, &disp_order_node);
     AXIS2_QNAME_FREE(qdisporder, env);
     if(NULL != disp_order_element)
@@ -272,7 +272,7 @@
 
     /* Process Module refs */
     qmodulest = axis2_qname_create(env, AXIS2_MODULEST, NULL, NULL);
-    module_itr = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
+    module_itr = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
         qmodulest, conf_node);
     AXIS2_QNAME_FREE(qmodulest, env);
     status = axis2_conf_builder_process_module_refs(conf_builder, env, module_itr);
@@ -282,14 +282,14 @@
     }
     /* Proccessing Transport Sennders */
     qtransportsender = axis2_qname_create(env, AXIS2_TRANSPORTSENDER, NULL, NULL);
-    trs_senders = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
+    trs_senders = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
         qtransportsender, conf_node);
     AXIS2_QNAME_FREE(qtransportsender, env);
     axis2_conf_builder_process_transport_senders(conf_builder, env, trs_senders);
 
     /* Proccessing Transport Recivers */
     qtransportrecv = axis2_qname_create(env, AXIS2_TRANSPORTRECEIVER, NULL, NULL);
-    trs_recvs = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
+    trs_recvs = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
         qtransportrecv, conf_node);
     AXIS2_QNAME_FREE(qtransportrecv, env);
     axis2_conf_builder_process_transport_recvs(conf_builder, env, trs_recvs);
@@ -300,7 +300,7 @@
 
     /* processing Phase orders */
     qphaseorder = axis2_qname_create(env, AXIS2_PHASE_ORDER, NULL, NULL);
-    phase_orders = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
+    phase_orders = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, env,
         qphaseorder, conf_node);
     AXIS2_QNAME_FREE(qphaseorder, env);
     axis2_conf_builder_process_phase_orders(conf_builder, env, phase_orders);
@@ -308,7 +308,7 @@
     /* Processing default module versions */
     qdefmodver = axis2_qname_create(env, AXIS2_DEFAULT_MODULE_VERSION, NULL, 
                         NULL);
-    def_mod_versions = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, 
+    def_mod_versions = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(conf_element, 
                                     env, qdefmodver, conf_node);
     AXIS2_QNAME_FREE(qdefmodver, env);
     if(NULL != def_mod_versions)
@@ -327,7 +327,7 @@
 axis2_status_t AXIS2_CALL
 axis2_conf_builder_process_module_refs(axis2_conf_builder_t *conf_builder,
                                 const axis2_env_t *env,
-                                axis2_om_children_qname_iterator_t *module_refs) 
+                                axiom_children_qname_iterator_t *module_refs) 
 {
     axis2_conf_builder_impl_t *builder_impl = NULL;
     axis2_status_t status = AXIS2_SUCCESS;
@@ -336,23 +336,23 @@
     AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE);
     builder_impl = AXIS2_INTF_TO_IMPL(conf_builder);
     
-    while (AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(module_refs,
+    while (AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(module_refs,
             env)) 
     {
-        axis2_om_node_t *module_ref_node = NULL;
-        axis2_om_element_t *module_ref_element = NULL;
+        axiom_node_t *module_ref_node = NULL;
+        axiom_element_t *module_ref_element = NULL;
         axis2_qname_t *qref = NULL;
         
-        axis2_om_attribute_t *module_ref_att = NULL;
-        module_ref_node = (axis2_om_node_t *)
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(module_refs, env);
+        axiom_attribute_t *module_ref_att = NULL;
+        module_ref_node = (axiom_node_t *)
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(module_refs, env);
         if(!module_ref_node)
         {
             return AXIS2_FAILURE;
         }
-        module_ref_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(module_ref_node, env);
+        module_ref_element = AXIOM_NODE_GET_DATA_ELEMENT(module_ref_node, env);
         qref = axis2_qname_create(env, AXIS2_REF, NULL, NULL);
-        module_ref_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(module_ref_element, env,
+        module_ref_att = AXIOM_ELEMENT_GET_ATTRIBUTE(module_ref_element, env,
             qref);
         if (qref)
             AXIS2_QNAME_FREE(qref, env);
@@ -361,7 +361,7 @@
             axis2_qname_t *qrefname = NULL;
             axis2_char_t *ref_name = NULL;
             
-            ref_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(module_ref_att, env);
+            ref_name = AXIOM_ATTRIBUTE_GET_VALUE(module_ref_att, env);
             AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "module %s found in axis2.xml", ref_name);
             qrefname = axis2_qname_create(env, ref_name, NULL, NULL);
             status = AXIS2_DEP_ENGINE_ADD_MODULE(conf_builder->desc_builder->
@@ -376,11 +376,11 @@
 static axis2_status_t
 axis2_conf_builder_process_disp_order(axis2_conf_builder_t *conf_builder,
                                         const axis2_env_t *env,
-                                        axis2_om_node_t *disp_order_node)
+                                        axiom_node_t *disp_order_node)
 {
     axis2_conf_builder_impl_t *builder_impl = NULL;
-    axis2_om_element_t *disp_order_element = NULL;
-    axis2_om_children_qname_iterator_t *disps = NULL;
+    axiom_element_t *disp_order_element = NULL;
+    axiom_children_qname_iterator_t *disps = NULL;
     axis2_qname_t *qdisp = NULL;
     axis2_bool_t found_disp = AXIS2_FALSE;
     axis2_phase_t *disp_phase = NULL;
@@ -392,10 +392,10 @@
     AXIS2_PARAM_CHECK(env->error, disp_order_node, AXIS2_FAILURE);
     builder_impl = AXIS2_INTF_TO_IMPL(conf_builder);
     
-    disp_order_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(
+    disp_order_element = AXIOM_NODE_GET_DATA_ELEMENT(
         disp_order_node, env);
     qdisp = axis2_qname_create(env, AXIS2_DISPATCHER, NULL, NULL);
-    disps = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(
+    disps = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(
         disp_order_element, env, qdisp, disp_order_node);
     AXIS2_QNAME_FREE(qdisp, env);
     disp_phase = axis2_phase_create(env, AXIS2_PHASE_DISPATCH);
@@ -405,14 +405,14 @@
     }
     if(disps)
     {
-        qname_itr_has_next = AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(disps, 
+        qname_itr_has_next = AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(disps, 
             env);
     }
     while (AXIS2_TRUE == qname_itr_has_next)
     {
-        axis2_om_node_t *disp_node = NULL;
-        axis2_om_element_t *disp_element = NULL;
-        axis2_om_attribute_t *disp_att = NULL;
+        axiom_node_t *disp_node = NULL;
+        axiom_element_t *disp_element = NULL;
+        axiom_attribute_t *disp_att = NULL;
         axis2_char_t *class_name = NULL;
         axis2_char_t *dll_name = NULL;
         axis2_qname_t *class_qname = NULL;
@@ -423,18 +423,18 @@
         axis2_handler_t *handler = NULL;
         
         found_disp = AXIS2_TRUE;
-        disp_node = (axis2_om_node_t *) 
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(disps, env);
+        disp_node = (axiom_node_t *) 
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(disps, env);
         class_qname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
-        disp_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(disp_element, env, class_qname);
+        disp_att = AXIOM_ELEMENT_GET_ATTRIBUTE(disp_element, env, class_qname);
         AXIS2_QNAME_FREE(class_qname, env);
         if(!disp_att)
         {
-            qname_itr_has_next = AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(disps, 
+            qname_itr_has_next = AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(disps, 
                 env);
             continue;
         }
-        class_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(disp_att, env);
+        class_name = AXIOM_ATTRIBUTE_GET_VALUE(disp_att, env);
         dll_desc = axis2_dll_desc_create(env);
         dll_name = 
             AXIS2_DLL_DESC_CREATE_PLATFORM_SPECIFIC_DLL_NAME(dll_desc, env, 
@@ -462,7 +462,7 @@
         /*disptachClas.getHandlerDesc().setParent(axisConfiguration); */
         AXIS2_PHASE_ADD_HANDLER_AT(disp_phase, env, count, handler);
         count ++;
-        qname_itr_has_next = AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(disps, 
+        qname_itr_has_next = AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(disps, 
             env);
         
     }
@@ -497,7 +497,7 @@
 static axis2_status_t
 axis2_conf_builder_process_phase_orders(axis2_conf_builder_t *conf_builder,
                             const axis2_env_t *env,
-                            axis2_om_children_qname_iterator_t *phase_orders)
+                            axiom_children_qname_iterator_t *phase_orders)
 {
     axis2_conf_builder_impl_t *builder_impl = NULL;
     axis2_phases_info_t *info = NULL;
@@ -508,34 +508,34 @@
     
     info = AXIS2_DEP_ENGINE_GET_PHASES_INFO(conf_builder->desc_builder->engine,
         env);
-    while (AXIS2_TRUE == AXIS2_OM_CHILDREN_ITERATOR_HAS_NEXT(phase_orders, env))
+    while (AXIS2_TRUE == AXIOM_CHILDREN_ITERATOR_HAS_NEXT(phase_orders, env))
     {
-        axis2_om_node_t *phase_orders_node = NULL;
-        axis2_om_element_t *phase_orders_element = NULL;
-        axis2_om_attribute_t *phase_orders_att = NULL;
+        axiom_node_t *phase_orders_node = NULL;
+        axiom_element_t *phase_orders_element = NULL;
+        axiom_attribute_t *phase_orders_att = NULL;
         axis2_qname_t *qtype = NULL;
         axis2_char_t *flow_type = NULL;
         axis2_array_list_t *phase_list = NULL;
         
-        phase_orders_node = (axis2_om_node_t *) AXIS2_OM_CHILDREN_ITERATOR_NEXT(
+        phase_orders_node = (axiom_node_t *) AXIOM_CHILDREN_ITERATOR_NEXT(
             phase_orders, env);
         if(phase_orders_node)
         {
-            phase_orders_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(phase_orders_node,
+            phase_orders_element = AXIOM_NODE_GET_DATA_ELEMENT(phase_orders_node,
                 env);
         }
         if(phase_orders_element)
         {
             qtype = axis2_qname_create(env, AXIS2_TYPE, NULL, NULL);
 
-            phase_orders_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(phase_orders_element, 
+            phase_orders_att = AXIOM_ELEMENT_GET_ATTRIBUTE(phase_orders_element, 
                 env, qtype);
             AXIS2_QNAME_FREE(qtype, env);
         }
 
         if (phase_orders_att)
         {
-            flow_type = AXIS2_OM_ATTRIBUTE_GET_VALUE(phase_orders_att, env);
+            flow_type = AXIOM_ATTRIBUTE_GET_VALUE(phase_orders_att, env);
         }
         
         phase_list = axis2_conf_builder_get_phase_list(conf_builder, env,
@@ -574,19 +574,19 @@
 static axis2_array_list_t *
 axis2_conf_builder_get_phase_list(axis2_conf_builder_t *conf_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *phase_orders_node)
+                                    axiom_node_t *phase_orders_node)
 {
     axis2_conf_builder_impl_t *builder_impl = NULL;
     axis2_array_list_t *phase_list = NULL;
-    axis2_om_children_qname_iterator_t *phases = NULL;
+    axiom_children_qname_iterator_t *phases = NULL;
     axis2_qname_t *qphase = NULL;
-    axis2_om_element_t *phase_orders_element;
+    axiom_element_t *phase_orders_element;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, phase_orders_node, AXIS2_FAILURE);
     builder_impl = AXIS2_INTF_TO_IMPL(conf_builder);
     
-    phase_orders_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(phase_orders_node, 
+    phase_orders_element = AXIOM_NODE_GET_DATA_ELEMENT(phase_orders_node, 
         env);
     if(!phase_orders_element)
     {
@@ -596,7 +596,7 @@
     }
     phase_list = axis2_array_list_create(env, 0);
     qphase = axis2_qname_create(env, AXIS2_PHASE, NULL, NULL);
-    phases = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(phase_orders_element, env,
+    phases = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(phase_orders_element, env,
         qphase, phase_orders_node);
     AXIS2_QNAME_FREE(qphase, env);
     if(!phases)
@@ -605,31 +605,31 @@
         return NULL;
     }
     
-    while (AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(phases, env))
+    while (AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(phases, env))
     {
-        axis2_om_node_t *phase_node = NULL;
-        axis2_om_element_t *phase_element = NULL;
-        axis2_om_attribute_t *phase_att = NULL;
+        axiom_node_t *phase_node = NULL;
+        axiom_element_t *phase_element = NULL;
+        axiom_attribute_t *phase_att = NULL;
         axis2_qname_t *qattname = NULL;
         axis2_char_t *att_value = NULL;
         
-        phase_node = (axis2_om_node_t *) AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(
+        phase_node = (axiom_node_t *) AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(
             phases, env);
         if (phase_node)
         {
-            phase_element = (axis2_om_element_t*)AXIS2_OM_NODE_GET_DATA_ELEMENT(
+            phase_element = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT(
                 phase_node, env);
         }
 
         qattname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
         if (phase_element)
         {
-            phase_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(phase_element, env, 
+            phase_att = AXIOM_ELEMENT_GET_ATTRIBUTE(phase_element, env, 
                 qattname);
         }
         if (phase_att)
         {
-            att_value = AXIS2_OM_ATTRIBUTE_GET_VALUE(phase_att, env);
+            att_value = AXIOM_ATTRIBUTE_GET_VALUE(phase_att, env);
         }
         if(att_value)
         {
@@ -644,7 +644,7 @@
 static axis2_status_t
 axis2_conf_builder_process_transport_senders(axis2_conf_builder_t *conf_builder,
                                 const axis2_env_t *env,
-                                axis2_om_children_qname_iterator_t *trs_senders)
+                                axiom_children_qname_iterator_t *trs_senders)
 {
     axis2_conf_builder_impl_t *builder_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -653,22 +653,22 @@
     AXIS2_PARAM_CHECK(env->error, trs_senders, AXIS2_FAILURE);
     builder_impl = AXIS2_INTF_TO_IMPL(conf_builder);
     
-    while (AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(trs_senders,
+    while (AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(trs_senders,
                 env))
     {
         axis2_transport_out_desc_t *transport_out = NULL;
-        axis2_om_node_t *transport_node = NULL;
-        axis2_om_element_t *transport_element = NULL;
-        axis2_om_attribute_t *trs_name = NULL;
+        axiom_node_t *transport_node = NULL;
+        axiom_element_t *transport_element = NULL;
+        axiom_attribute_t *trs_name = NULL;
         axis2_qname_t *qattname = NULL;
         
-        transport_node = (axis2_om_node_t *) 
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(trs_senders, env);
+        transport_node = (axiom_node_t *) 
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(trs_senders, env);
 
         if (transport_node)
         {
-            transport_element = (axis2_om_element_t*)
-                AXIS2_OM_NODE_GET_DATA_ELEMENT(transport_node, env);
+            transport_element = (axiom_element_t*)
+                AXIOM_NODE_GET_DATA_ELEMENT(transport_node, env);
             if(!transport_element)
             {
                 return AXIS2_FAILURE;
@@ -683,17 +683,17 @@
         qattname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
         if (transport_element)
         {
-            trs_name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(transport_element, env, 
+            trs_name = AXIOM_ELEMENT_GET_ATTRIBUTE(transport_element, env, 
                 qattname);
         }
         AXIS2_QNAME_FREE(qattname, env);
         if(NULL != trs_name)
         {
             axis2_char_t *name = NULL;
-            axis2_om_attribute_t *trs_dll_att = NULL;
+            axiom_attribute_t *trs_dll_att = NULL;
             axis2_char_t *dll_name = NULL;
             axis2_char_t *class_name = NULL;
-            axis2_om_children_qname_iterator_t *itr = NULL;
+            axiom_children_qname_iterator_t *itr = NULL;
             axis2_qname_t *qname = NULL;
             axis2_qname_t *qparamst = NULL;
             axis2_qname_t *qinflowst = NULL;
@@ -701,14 +701,14 @@
             axis2_qname_t *qinfaultflowst = NULL;
             axis2_qname_t *qoutfaultflowst = NULL;
             axis2_qname_t *qdllname = NULL;
-            axis2_om_element_t *in_flow_element = NULL;
-            axis2_om_node_t *in_flow_node = NULL;
-            axis2_om_element_t *out_flow_element = NULL;
-            axis2_om_node_t *out_flow_node = NULL;
-            axis2_om_element_t *in_fault_flow_element = NULL;
-            axis2_om_node_t *in_fault_flow_node = NULL;
-            axis2_om_element_t *out_fault_flow_element = NULL;
-            axis2_om_node_t *out_fault_flow_node = NULL;
+            axiom_element_t *in_flow_element = NULL;
+            axiom_node_t *in_flow_node = NULL;
+            axiom_element_t *out_flow_element = NULL;
+            axiom_node_t *out_flow_node = NULL;
+            axiom_element_t *in_fault_flow_element = NULL;
+            axiom_node_t *in_fault_flow_node = NULL;
+            axiom_element_t *out_fault_flow_element = NULL;
+            axiom_node_t *out_fault_flow_node = NULL;
             axis2_dll_desc_t *dll_desc = NULL;
             axis2_param_t *impl_info_param = NULL;
             void *transport_sender = NULL;
@@ -718,7 +718,7 @@
             axis2_char_t *temp_path2 = NULL;
             axis2_char_t *temp_path3 = NULL;
             
-            name = AXIS2_OM_ATTRIBUTE_GET_VALUE(trs_name, env);
+            name = AXIOM_ATTRIBUTE_GET_VALUE(trs_name, env);
             qname = axis2_qname_create(env, name, NULL, NULL);
             transport_out = axis2_transport_out_desc_create_with_qname(env, qname);
             AXIS2_QNAME_FREE(qname, env);
@@ -729,7 +729,7 @@
 
             /* transport impl class */
             qdllname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
-            trs_dll_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(transport_element, env,
+            trs_dll_att = AXIOM_ELEMENT_GET_ATTRIBUTE(transport_element, env,
                 qdllname);
             AXIS2_QNAME_FREE(qdllname, env);
             if(NULL == trs_dll_att)
@@ -738,7 +738,7 @@
                     AXIS2_FAILURE);
                 return AXIS2_FAILURE;
             }
-            class_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(trs_dll_att, env);
+            class_name = AXIOM_ATTRIBUTE_GET_VALUE(trs_dll_att, env);
             impl_info_param = axis2_param_create(env, class_name, NULL); 
             if(!impl_info_param)
             {
@@ -779,7 +779,7 @@
             /* Process Parameters */
             /* Processing service level paramters */
             qparamst = axis2_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-            itr = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(transport_element,
+            itr = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(transport_element,
                 env, qparamst, transport_node);
             AXIS2_QNAME_FREE(qparamst, env);
             status = AXIS2_DESC_BUILDER_PROCESS_PARAMS(conf_builder->desc_builder, env,
@@ -792,7 +792,7 @@
             }
             /* process INFLOW */
             qinflowst = axis2_qname_create(env, AXIS2_INFLOWST, NULL, NULL); 
-            in_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            in_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qinflowst, transport_node, &in_flow_node);
             AXIS2_QNAME_FREE(qinflowst, env);
             if(NULL != in_flow_element)
@@ -803,7 +803,7 @@
                 return AXIS2_FAILURE;
             }
             qoutflowst = axis2_qname_create(env, AXIS2_OUTFLOWST, NULL, NULL);
-            out_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            out_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qoutflowst, transport_node, &out_flow_node);
             AXIS2_QNAME_FREE(qoutflowst, env);
             if(NULL != out_flow_element)
@@ -824,7 +824,7 @@
             /* process IN FAULT FLOW */
             qinfaultflowst = axis2_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, 
                 NULL); 
-            in_fault_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            in_fault_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qinfaultflowst, transport_node, 
                     &in_fault_flow_node);
             AXIS2_QNAME_FREE(qinfaultflowst, env);
@@ -838,7 +838,7 @@
 
             qoutfaultflowst = axis2_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL,
                 NULL);
-            out_fault_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            out_fault_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qoutfaultflowst, transport_node, 
                     &out_fault_flow_node);
             AXIS2_QNAME_FREE(qoutfaultflowst, env);
@@ -874,7 +874,7 @@
 static axis2_status_t
 axis2_conf_builder_process_transport_recvs(axis2_conf_builder_t *conf_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_children_qname_iterator_t *trs_recvs)
+                                    axiom_children_qname_iterator_t *trs_recvs)
 {
     axis2_conf_builder_impl_t *builder_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -883,20 +883,20 @@
     AXIS2_PARAM_CHECK(env->error, trs_recvs, AXIS2_FAILURE);
     builder_impl = AXIS2_INTF_TO_IMPL(conf_builder);
     
-    while (AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(trs_recvs, 
+    while (AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(trs_recvs, 
             env))
     {
         axis2_transport_in_desc_t *transport_in = NULL;
-        axis2_om_node_t *transport_node = NULL;
-        axis2_om_element_t *transport_element = NULL;
-        axis2_om_attribute_t *trs_name = NULL;
+        axiom_node_t *transport_node = NULL;
+        axiom_element_t *transport_element = NULL;
+        axiom_attribute_t *trs_name = NULL;
         axis2_qname_t *qattname = NULL;
          
-        transport_node = (axis2_om_node_t *) 
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(trs_recvs, env);
+        transport_node = (axiom_node_t *) 
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(trs_recvs, env);
         if(transport_node)
         {
-            transport_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(transport_node, 
+            transport_element = AXIOM_NODE_GET_DATA_ELEMENT(transport_node, 
                 env);
             if(!transport_element)
             {
@@ -910,15 +910,15 @@
 
         /* getting transport Name */
         qattname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
-        trs_name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(transport_element, env,
+        trs_name = AXIOM_ELEMENT_GET_ATTRIBUTE(transport_element, env,
             qattname);
         AXIS2_QNAME_FREE(qattname, env);
        
         if(NULL != trs_name)
         {
             axis2_char_t *name = NULL;
-            axis2_om_attribute_t *trs_class_name = NULL;
-            axis2_om_children_qname_iterator_t *itr = NULL;
+            axiom_attribute_t *trs_class_name = NULL;
+            axiom_children_qname_iterator_t *itr = NULL;
             axis2_qname_t *transport_in_desc_qname = NULL;
             axis2_qname_t *class_qname = NULL;
             axis2_qname_t *qparamst = NULL;
@@ -926,17 +926,17 @@
             axis2_qname_t *qoutflowst = NULL;
             axis2_qname_t *qinfaultflowst = NULL;
             axis2_qname_t *qoutfaultflowst = NULL;
-            axis2_om_element_t *in_flow_element = NULL;
-            axis2_om_node_t *in_flow_node = NULL;
-            axis2_om_element_t *out_flow_element = NULL;
-            axis2_om_node_t *out_flow_node = NULL;
-            axis2_om_element_t *in_fault_flow_element = NULL;
-            axis2_om_node_t *in_fault_flow_node = NULL;
-            axis2_om_element_t *out_fault_flow_element = NULL;
-            axis2_om_node_t *out_fault_flow_node = NULL;
+            axiom_element_t *in_flow_element = NULL;
+            axiom_node_t *in_flow_node = NULL;
+            axiom_element_t *out_flow_element = NULL;
+            axiom_node_t *out_flow_node = NULL;
+            axiom_element_t *in_fault_flow_element = NULL;
+            axiom_node_t *in_fault_flow_node = NULL;
+            axiom_element_t *out_fault_flow_element = NULL;
+            axiom_node_t *out_fault_flow_node = NULL;
             
             
-            name = AXIS2_OM_ATTRIBUTE_GET_VALUE(trs_name, env);
+            name = AXIOM_ATTRIBUTE_GET_VALUE(trs_name, env);
             transport_in_desc_qname = axis2_qname_create(env, name, NULL, NULL);
             transport_in = axis2_transport_in_desc_create_with_qname(env, 
                 transport_in_desc_qname);
@@ -948,7 +948,7 @@
 
             /* transport impl class */
             class_qname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
-            trs_class_name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(transport_element, env,
+            trs_class_name = AXIOM_ELEMENT_GET_ATTRIBUTE(transport_element, env,
                 class_qname);
             AXIS2_QNAME_FREE(class_qname, env);
             
@@ -966,7 +966,7 @@
                 axis2_char_t *temp_path2 = NULL;
                 axis2_char_t *temp_path3 = NULL;
                 
-                class_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(trs_class_name, env);
+                class_name = AXIOM_ATTRIBUTE_GET_VALUE(trs_class_name, env);
                 impl_info_param = axis2_param_create(env, class_name, NULL);
                 dll_desc = axis2_dll_desc_create(env);
                 dll_name = 
@@ -1002,7 +1002,7 @@
             /* processing Paramters */
             /* Processing service level paramters */
             qparamst = axis2_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);            
-            itr = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(transport_element,
+            itr = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(transport_element,
                 env, qparamst, transport_node);
             AXIS2_QNAME_FREE(qparamst, env);
             status = AXIS2_DESC_BUILDER_PROCESS_PARAMS(conf_builder->desc_builder, env,
@@ -1015,7 +1015,7 @@
             }
             /* process OUTFLOW */
             qoutflowst = axis2_qname_create(env, AXIS2_OUTFLOWST, NULL, NULL);
-            out_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            out_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qoutflowst, transport_node, &out_flow_node);
             AXIS2_QNAME_FREE(qoutflowst, env);
             if(NULL != out_flow_element)
@@ -1027,7 +1027,7 @@
             }
 
             qinflowst = axis2_qname_create(env, AXIS2_INFLOWST, NULL, NULL);
-            in_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            in_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qinflowst, transport_node, &in_flow_node);
             AXIS2_QNAME_FREE(qinflowst, env);
             if(NULL != in_flow_element)
@@ -1048,7 +1048,7 @@
 
             qinfaultflowst = axis2_qname_create(env, AXIS2_IN_FAILTFLOW, NULL,
                 NULL);            
-            in_fault_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            in_fault_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qinfaultflowst, transport_node,
                     &in_fault_flow_node);
             AXIS2_QNAME_FREE(qinfaultflowst, env);
@@ -1070,7 +1070,7 @@
 
             qoutfaultflowst = axis2_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL,
                 NULL);
-            out_fault_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
+            out_fault_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(
                 transport_element, env, qoutfaultflowst, transport_node,
                     &out_fault_flow_node);
             if(NULL != out_fault_flow_element)
@@ -1100,20 +1100,20 @@
 axis2_conf_builder_process_default_module_versions(
                             axis2_conf_builder_t *conf_builder,
                             const axis2_env_t *env, 
-                            axis2_om_children_qname_iterator_t *module_versions)
+                            axiom_children_qname_iterator_t *module_versions)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, module_versions, AXIS2_FAILURE);
     
-    while (AXIS2_OM_CHILDREN_ITERATOR_HAS_NEXT(module_versions, env))
+    while (AXIOM_CHILDREN_ITERATOR_HAS_NEXT(module_versions, env))
     {
-        axis2_om_element_t *om_element = NULL;
+        axiom_element_t *om_element = NULL;
         axis2_char_t *name = NULL;
         axis2_char_t *default_version = NULL;
         axis2_qname_t *attribute_qname = NULL;
         
-        om_element = (axis2_om_element_t *) 
-                        AXIS2_OM_CHILDREN_ITERATOR_NEXT(module_versions, env);
+        om_element = (axiom_element_t *) 
+                        AXIOM_CHILDREN_ITERATOR_NEXT(module_versions, env);
         if(NULL == om_element)
         {
             continue;
@@ -1123,7 +1123,7 @@
         {
             continue;
         }
-        name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, 
+        name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, 
                                                     attribute_qname);
         AXIS2_QNAME_FREE(attribute_qname, env);
         attribute_qname = NULL;
@@ -1137,7 +1137,7 @@
         {
             continue;
         }
-        default_version = AXIS2_OM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, 
+        default_version = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, 
                         attribute_qname);
         AXIS2_QNAME_FREE(attribute_qname, env);
         attribute_qname = NULL;

Modified: webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c Mon Jun 12 01:26:30 2006
@@ -22,7 +22,7 @@
 #include <axis2_flow.h>
 #include <axis2_arch_reader.h>
 #include <axis2_svc_builder.h>
-#include <axis2_om_node.h>
+#include <axiom_node.h>
 #include <axis2_class_loader.h>
 #include <axis2_string.h>
 #include <axis2_utils.h>
@@ -1653,7 +1653,7 @@
                             axis2_char_t *file_name)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
-    axis2_om_node_t *node = NULL;
+    axiom_node_t *node = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, file_name, NULL);

Modified: webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c Mon Jun 12 01:26:30 2006
@@ -33,7 +33,7 @@
      * Store the full path to configuration file.
      */
     axis2_char_t *file_name;
-    axis2_om_stax_builder_t *builder;
+    axiom_stax_builder_t *builder;
        
 } axis2_desc_builder_impl_t;
 
@@ -46,7 +46,7 @@
 axis2_desc_builder_free (axis2_desc_builder_t *desc_builder, 
                             const axis2_env_t *env);
 
-axis2_om_node_t *AXIS2_CALL
+axiom_node_t *AXIS2_CALL
 axis2_build_OM(axis2_desc_builder_t *desc_builder,
                 const axis2_env_t *env);
 
@@ -54,21 +54,21 @@
 struct axis2_flow *AXIS2_CALL
 axis2_desc_builder_process_flow(axis2_desc_builder_t *desc_builder,
                                 const axis2_env_t *env,
-                                struct axis2_om_element *flow_element,
+                                struct axiom_element *flow_element,
                                 axis2_param_container_t *parent,
-                                axis2_om_node_t *node);
+                                axiom_node_t *node);
 
 struct axis2_handler_desc *AXIS2_CALL
 axis2_desc_builder_process_handler(axis2_desc_builder_t *desc_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *handler_element,
+                                    axiom_node_t *handler_element,
                                     axis2_param_container_t *parent);
 
 
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_params(axis2_desc_builder_t *desc_builder,
                                 const axis2_env_t *env,
-                                axis2_om_children_qname_iterator_t *params,
+                                axiom_children_qname_iterator_t *params,
                                 axis2_param_container_t *param_container,
                                 axis2_param_container_t *parent );
 
@@ -76,13 +76,13 @@
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_op_module_refs(axis2_desc_builder_t *desc_builder,
                           const axis2_env_t *env,
-                          axis2_om_children_qname_iterator_t *module_refs, 
+                          axiom_children_qname_iterator_t *module_refs, 
                           struct axis2_op *op);
                               
 struct axis2_msg_recv *AXIS2_CALL
 axis2_desc_builder_load_msg_recv(axis2_desc_builder_t *desc_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_element_t *recv_element);
+                                    axiom_element_t *recv_element);
 
 struct axis2_msg_recv *AXIS2_CALL
 axis2_desc_builder_load_default_msg_recv(axis2_desc_builder_t *desc_builder,
@@ -108,8 +108,8 @@
 set_attrs_and_value(
         axis2_param_t *param,
         const axis2_env_t *env,
-        axis2_om_element_t *param_element,
-        axis2_om_node_t *param_node);
+        axiom_element_t *param_element,
+        axiom_node_t *param_node);
 
                                 
 /************************** End of function prototypes ************************/
@@ -242,7 +242,7 @@
 
     if(desc_builder_impl->builder)
     {
-        AXIS2_OM_STAX_BUILDER_FREE(desc_builder_impl->builder, env);
+        AXIOM_STAX_BUILDER_FREE(desc_builder_impl->builder, env);
         desc_builder_impl->builder = NULL;
     }
     
@@ -260,14 +260,14 @@
    return AXIS2_SUCCESS;
 }
 
-axis2_om_node_t *AXIS2_CALL
+axiom_node_t *AXIS2_CALL
 axis2_build_OM(axis2_desc_builder_t *desc_builder,
                 const axis2_env_t *env) 
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     axis2_xml_reader_t *reader = NULL;
-    axis2_om_document_t *document = NULL;
-    axis2_om_node_t *root = NULL;
+    axiom_document_t *document = NULL;
+    axiom_node_t *root = NULL;
     
     AXIS2_ENV_CHECK(env, NULL); 
     desc_builder_impl = AXIS2_INTF_TO_IMPL(desc_builder);
@@ -289,8 +289,8 @@
         return NULL;
     }
     
-    /** create axis2_om_stax_builder by parsing pull_parser struct */
-    desc_builder_impl->builder = axis2_om_stax_builder_create (env, reader);
+    /** create axiom_stax_builder by parsing pull_parser struct */
+    desc_builder_impl->builder = axiom_stax_builder_create (env, reader);
 
     if(!(desc_builder_impl->builder))
     {
@@ -302,28 +302,28 @@
         get the om document form builder 
         document is the container of om model created using builder
     */
-    document = AXIS2_OM_STAX_BUILDER_GET_DOCUMENT(desc_builder_impl->builder, env);
+    document = AXIOM_STAX_BUILDER_GET_DOCUMENT(desc_builder_impl->builder, env);
     /** 
      * In description building we don't want defferred building. So build
      * the whole tree at once
      */
-    AXIS2_OM_DOCUMENT_BUILD_ALL(document, env);
+    AXIOM_DOCUMENT_BUILD_ALL(document, env);
     /**
         get root element , building starts hear 
      */
-    root = AXIS2_OM_DOCUMENT_GET_ROOT_ELEMENT (document, env);
+    root = AXIOM_DOCUMENT_GET_ROOT_ELEMENT (document, env);
     return root;
 }
 
 axis2_flow_t *AXIS2_CALL
 axis2_desc_builder_process_flow(axis2_desc_builder_t *desc_builder,
                                 const axis2_env_t *env,
-                                axis2_om_element_t *flow_element,
+                                axiom_element_t *flow_element,
                                 axis2_param_container_t *parent,
-                                axis2_om_node_t *flow_node)
+                                axiom_node_t *flow_node)
 {
     axis2_flow_t *flow = NULL;
-    axis2_om_children_qname_iterator_t *handlers = NULL;
+    axiom_children_qname_iterator_t *handlers = NULL;
     axis2_qname_t *qchild = NULL;
         
     AXIS2_ENV_CHECK(env, NULL);
@@ -343,19 +343,19 @@
     }
     
     qchild = axis2_qname_create(env, AXIS2_HANDLERST, NULL, NULL); 
-    handlers = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(flow_element, env, 
+    handlers = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(flow_element, env, 
         qchild, flow_node);
     if(qchild)
         AXIS2_QNAME_FREE(qchild, env);
 
-    while(AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(handlers ,env))
+    while(AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(handlers ,env))
     {
-        axis2_om_node_t *handler_node = NULL;
+        axiom_node_t *handler_node = NULL;
         axis2_handler_desc_t *handler_desc = NULL;
         axis2_status_t status = AXIS2_FAILURE;
             
-        handler_node = (axis2_om_node_t *)
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(handlers, env);
+        handler_node = (axiom_node_t *)
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(handlers, env);
         
         handler_desc = axis2_desc_builder_process_handler(desc_builder, env, 
             handler_node, parent);
@@ -373,19 +373,19 @@
 struct axis2_handler_desc *AXIS2_CALL
 axis2_desc_builder_process_handler(axis2_desc_builder_t *desc_builder,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *handler_node,
+                                    axiom_node_t *handler_node,
                                     struct axis2_param_container *parent)
 {
     axis2_handler_desc_t *handler_desc = NULL;
-    axis2_om_attribute_t *name_attrib = NULL;
+    axiom_attribute_t *name_attrib = NULL;
     axis2_qname_t *attr_qname = NULL;
-    axis2_om_attribute_t *class_attrib = NULL;
+    axiom_attribute_t *class_attrib = NULL;
     axis2_qname_t *class_qname = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     axis2_char_t *attrib_value = NULL;
-    axis2_om_element_t *handler_element = NULL;
-    axis2_om_node_t *order_node = NULL;
-    axis2_om_element_t *order_element = NULL;
+    axiom_element_t *handler_element = NULL;
+    axiom_node_t *order_node = NULL;
+    axiom_element_t *order_element = NULL;
     axis2_qname_t *order_qname = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -399,8 +399,8 @@
     }
     /* Setting Handler name */
     attr_qname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
-    handler_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(handler_node, env);
-    name_attrib = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(handler_element, env, 
+    handler_element = AXIOM_NODE_GET_DATA_ELEMENT(handler_node, env);
+    name_attrib = AXIOM_ELEMENT_GET_ATTRIBUTE(handler_element, env, 
         attr_qname);
     if(attr_qname)
     {
@@ -419,7 +419,7 @@
         axis2_qname_t *handler_qname = NULL;
         axis2_char_t *value = NULL;
         
-        value = AXIS2_OM_ATTRIBUTE_GET_VALUE(name_attrib, env);
+        value = AXIOM_ATTRIBUTE_GET_VALUE(name_attrib, env);
         handler_qname = axis2_qname_create(env, value, NULL, NULL); 
         status = AXIS2_HANDLER_DESC_SET_QNAME(handler_desc, env, handler_qname);
         if(handler_qname)
@@ -434,7 +434,7 @@
 
     /*Setting Handler Class name */
     class_qname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
-    class_attrib = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(handler_element, env,
+    class_attrib = AXIOM_ELEMENT_GET_ATTRIBUTE(handler_element, env,
         class_qname);
     if(class_qname)    
         AXIS2_QNAME_FREE(class_qname, env);
@@ -448,7 +448,7 @@
     }
     else
     {   
-        attrib_value = AXIS2_OM_ATTRIBUTE_GET_VALUE(class_attrib, env);
+        attrib_value = AXIOM_ATTRIBUTE_GET_VALUE(class_attrib, env);
         status = AXIS2_HANDLER_DESC_SET_CLASS_NAME(handler_desc, env, attrib_value);
         /*if(AXIS2_FAILURE == status)
         {
@@ -460,7 +460,7 @@
     /*processing phase Rules (order) */
  
     order_qname = axis2_qname_create(env, AXIS2_ORDER, NULL, NULL);
-    order_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(handler_element,
+    order_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(handler_element,
         env, order_qname, handler_node, &order_node);
     if(order_qname)
         AXIS2_QNAME_FREE(order_qname, env);
@@ -475,11 +475,11 @@
     else
     {
         axis2_hash_t *order_itr = NULL;
-        axis2_om_children_qname_iterator_t *params = NULL;
+        axiom_children_qname_iterator_t *params = NULL;
         axis2_qname_t *param_qname = NULL;
         axis2_hash_index_t *index_i = NULL;
         
-        order_itr = AXIS2_OM_ELEMENT_GET_ALL_ATTRIBUTES(order_element, env);
+        order_itr = AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(order_element, env);
         if(!order_itr)
         {
             AXIS2_HANDLER_DESC_FREE(handler_desc, env);
@@ -490,18 +490,18 @@
     
         while(NULL != index_i)
         {
-            axis2_om_attribute_t *order_attrib = NULL;
+            axiom_attribute_t *order_attrib = NULL;
             axis2_qname_t *qname = NULL;
             axis2_char_t *name = NULL;
             axis2_char_t *value = NULL;
             void *v = NULL;
 
             axis2_hash_this (index_i, NULL, NULL, &v);
-            order_attrib = (axis2_om_attribute_t *) v;
-            qname = AXIS2_OM_ATTRIBUTE_GET_QNAME(order_attrib, env);
+            order_attrib = (axiom_attribute_t *) v;
+            qname = AXIOM_ATTRIBUTE_GET_QNAME(order_attrib, env);
             name = AXIS2_QNAME_GET_LOCALPART(qname, env);
 
-            value = AXIS2_OM_ATTRIBUTE_GET_VALUE(order_attrib, env);
+            value = AXIOM_ATTRIBUTE_GET_VALUE(order_attrib, env);
             if(0 == AXIS2_STRCMP(AXIS2_AFTER, name))
             {
                 struct axis2_phase_rule *phase_rule = NULL;
@@ -574,7 +574,7 @@
         }
         
         param_qname = axis2_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-        params = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(handler_element,
+        params = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(handler_element,
             env, param_qname, handler_node);
         AXIS2_QNAME_FREE(param_qname, env);
         status = axis2_desc_builder_process_params(desc_builder, env, params, 
@@ -600,12 +600,12 @@
 set_attrs_and_value(
         axis2_param_t *param,
         const axis2_env_t *env,
-        axis2_om_element_t *param_element,
-        axis2_om_node_t *param_node)
+        axiom_element_t *param_element,
+        axiom_node_t *param_node)
 {
     axis2_status_t status = AXIS2_FAILURE;
     axis2_hash_t *attrs = NULL;
-    axis2_om_child_element_iterator_t *childs = NULL;
+    axiom_child_element_iterator_t *childs = NULL;
         
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
@@ -613,7 +613,7 @@
     AXIS2_PARAM_CHECK(env->error, param_node, AXIS2_FAILURE);
 
      /* Setting attributes */
-    attrs = AXIS2_OM_ELEMENT_EXTRACT_ATTRIBUTES(param_element, env, param_node);
+    attrs = AXIOM_ELEMENT_EXTRACT_ATTRIBUTES(param_element, env, param_node);
     if(attrs)
     {
         axis2_hash_index_t *i = NULL;
@@ -622,7 +622,7 @@
                 axis2_hash_next (env, i))
         {
             void *v = NULL;
-            axis2_om_attribute_t *value = NULL;
+            axiom_attribute_t *value = NULL;
             axis2_generic_obj_t *obj = NULL;
             axis2_qname_t *attr_qname = NULL;
             axis2_char_t *attr_name = NULL;
@@ -641,18 +641,18 @@
                         AXIS2_FAILURE);
                 return AXIS2_FAILURE;
             }
-            value = (axis2_om_attribute_t *) v;
+            value = (axiom_attribute_t *) v;
             AXIS2_GENERIC_OBJ_SET_VALUE(obj, env, value);
             AXIS2_GENERIC_OBJ_SET_FREE_FUNC(obj, env, 
-                    axis2_om_attribute_free_void_arg);
-            attr_qname = AXIS2_OM_ATTRIBUTE_GET_QNAME(value, env);
+                    axiom_attribute_free_void_arg);
+            attr_qname = AXIOM_ATTRIBUTE_GET_QNAME(value, env);
             attr_name = AXIS2_QNAME_TO_STRING(attr_qname, env);
             axis2_hash_set(attrs, attr_name, AXIS2_HASH_KEY_STRING, obj); 
         }
         AXIS2_PARAM_SET_ATTRIBUTES(param, env, attrs);
     }
 
-    childs = AXIS2_OM_ELEMENT_GET_CHILD_ELEMENTS(param_element, env, param_node);
+    childs = AXIOM_ELEMENT_GET_CHILD_ELEMENTS(param_element, env, param_node);
     if(childs)
     {
         axis2_array_list_t *value_list = NULL;
@@ -660,17 +660,17 @@
         value_list = axis2_array_list_create(env, 0);
         AXIS2_PARAM_SET_VALUE_LIST(param, env, value_list);
         
-        while(AXIS2_TRUE == AXIS2_OM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(childs, env))
+        while(AXIS2_TRUE == AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(childs, env))
         {
-            axis2_om_node_t *node = NULL;
-            axis2_om_element_t *element = NULL;
+            axiom_node_t *node = NULL;
+            axiom_element_t *element = NULL;
             axis2_param_t *param = NULL;
             axis2_char_t *pname = NULL;
             
-            node = AXIS2_OM_CHILD_ELEMENT_ITERATOR_NEXT(childs, env);
-            element = AXIS2_OM_NODE_GET_DATA_ELEMENT(node, env);
+            node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(childs, env);
+            element = AXIOM_NODE_GET_DATA_ELEMENT(node, env);
             param = axis2_param_create(env, NULL, NULL);
-            pname = AXIS2_OM_ELEMENT_GET_LOCALNAME(element, env);
+            pname = AXIOM_ELEMENT_GET_LOCALNAME(element, env);
             status = AXIS2_PARAM_SET_NAME(param, env, pname);
             if(AXIS2_SUCCESS != status)
             {
@@ -687,7 +687,7 @@
         axis2_char_t *para_test_value = NULL;
         axis2_char_t *temp = NULL;
 
-        temp = AXIS2_OM_ELEMENT_GET_TEXT(
+        temp = AXIOM_ELEMENT_GET_TEXT(
             param_element, env, param_node);
         para_test_value = AXIS2_STRDUP(temp, env);
         status = AXIS2_PARAM_SET_VALUE(param, env, para_test_value);
@@ -705,7 +705,7 @@
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_params(axis2_desc_builder_t *desc_builder,
                                 const axis2_env_t *env,
-                                axis2_om_children_qname_iterator_t *params,
+                                axiom_children_qname_iterator_t *params,
                                 axis2_param_container_t *param_container,
                                 axis2_param_container_t *parent )
 {
@@ -716,14 +716,14 @@
     AXIS2_PARAM_CHECK(env->error, param_container, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
     
-    while(AXIS2_FALSE != AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(params, env))
+    while(AXIS2_FALSE != AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(params, env))
     {
-        axis2_om_element_t *param_element = NULL;
-        axis2_om_node_t *param_node = NULL;
+        axiom_element_t *param_element = NULL;
+        axiom_node_t *param_node = NULL;
         axis2_param_t *param = NULL;
         axis2_param_t *parent_para = NULL;
-        axis2_om_attribute_t *para_name = NULL;
-        axis2_om_attribute_t *para_locked = NULL;  
+        axiom_attribute_t *para_name = NULL;
+        axiom_attribute_t *para_locked = NULL;  
         axis2_qname_t *att_locked = NULL;
         axis2_qname_t *att_qname = NULL;
         axis2_char_t *pname = NULL;
@@ -731,9 +731,9 @@
         /* This is to check whether some one has locked the parmter at the top 
          * level
          */
-        param_node = (axis2_om_node_t *)
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(params, env);
-        param_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(param_node, env);
+        param_node = (axiom_node_t *)
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(params, env);
+        param_element = AXIOM_NODE_GET_DATA_ELEMENT(param_node, env);
         param = axis2_param_create(env, NULL, NULL);
         /* TODO Setting param_element. Do not set element like following.
          * break it and set 
@@ -747,7 +747,7 @@
         
            /* Setting paramter name */
         att_qname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
-        para_name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(param_element, env, 
+        para_name = AXIOM_ELEMENT_GET_ATTRIBUTE(param_element, env, 
             att_qname);
         AXIS2_QNAME_FREE(att_qname, env);
         if(!para_name)
@@ -755,7 +755,7 @@
             AXIS2_PARAM_FREE(param, env);
             return AXIS2_FAILURE;
         }
-        pname = AXIS2_OM_ATTRIBUTE_GET_VALUE(para_name, env);
+        pname = AXIOM_ATTRIBUTE_GET_VALUE(para_name, env);
         status = AXIS2_PARAM_SET_NAME(param, env, pname);
         if(AXIS2_SUCCESS != status)
         {
@@ -768,7 +768,7 @@
 
         /* Setting locking attrib */
         att_locked = axis2_qname_create(env, AXIS2_ATTLOCKED, NULL, NULL);
-        para_locked = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(param_element, env, 
+        para_locked = AXIOM_ELEMENT_GET_ATTRIBUTE(param_element, env, 
             att_locked);
         AXIS2_QNAME_FREE(att_locked, env);
         if(parent)
@@ -782,7 +782,7 @@
         if(para_locked)
         {
             axis2_char_t *locked_value = NULL;
-            locked_value = AXIS2_OM_ATTRIBUTE_GET_VALUE(para_locked, env);
+            locked_value = AXIOM_ATTRIBUTE_GET_VALUE(para_locked, env);
             if(0 == AXIS2_STRCMP("true", locked_value))
             {
                 axis2_char_t *param_name = NULL;
@@ -848,12 +848,12 @@
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_op_module_refs(axis2_desc_builder_t *desc_builder,
                               const axis2_env_t *env,
-                              axis2_om_children_qname_iterator_t *module_refs, 
+                              axiom_children_qname_iterator_t *module_refs, 
                               axis2_op_t *op)
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
-    axis2_om_element_t *moduleref = NULL;
-    axis2_om_attribute_t *module_ref_attrib = NULL;
+    axiom_element_t *moduleref = NULL;
+    axiom_attribute_t *module_ref_attrib = NULL;
     axis2_qname_t *qref = NULL;
     axis2_status_t status = AXIS2_FAILURE;
         
@@ -861,13 +861,13 @@
     AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
     desc_builder_impl = AXIS2_INTF_TO_IMPL(desc_builder);
     
-    while(module_refs && AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(module_refs,
+    while(module_refs && AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(module_refs,
         env))
     {
-        moduleref = (axis2_om_element_t *)
-            AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(module_refs, env);
+        moduleref = (axiom_element_t *)
+            AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(module_refs, env);
         qref = axis2_qname_create(env, AXIS2_REF, NULL, NULL);
-        module_ref_attrib = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(moduleref, env, qref);
+        module_ref_attrib = AXIOM_ELEMENT_GET_ATTRIBUTE(moduleref, env, qref);
         AXIS2_QNAME_FREE(qref, env);
         if(NULL != module_ref_attrib)
         {
@@ -875,7 +875,7 @@
             axis2_qname_t *ref_qname = NULL;
             axis2_module_desc_t *module_desc = NULL;
             
-            ref_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(module_ref_attrib, env);
+            ref_name = AXIOM_ATTRIBUTE_GET_VALUE(module_ref_attrib, env);
             ref_qname = axis2_qname_create(env, ref_name, NULL, NULL);
             module_desc = AXIS2_DEP_ENGINE_GET_MODULE(desc_builder->engine, env, 
                 ref_qname);
@@ -905,9 +905,9 @@
 axis2_msg_recv_t *AXIS2_CALL
 axis2_desc_builder_load_msg_recv(axis2_desc_builder_t *desc_builder,
                                     const axis2_env_t *env,
-                                    struct axis2_om_element *recv_element)
+                                    struct axiom_element *recv_element)
 {
-    axis2_om_attribute_t *recv_name = NULL;
+    axiom_attribute_t *recv_name = NULL;
     axis2_char_t *class_name = NULL;
     axis2_msg_recv_t *msg_recv = NULL;
     axis2_qname_t *class_qname = NULL;
@@ -925,9 +925,9 @@
     AXIS2_PARAM_CHECK(env->error, recv_element, NULL);
 
     class_qname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
-    recv_name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(recv_element, env, class_qname);
+    recv_name = AXIOM_ELEMENT_GET_ATTRIBUTE(recv_element, env, class_qname);
     AXIS2_QNAME_FREE(class_qname, env);
-    class_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(recv_name, env);
+    class_name = AXIOM_ATTRIBUTE_GET_VALUE(recv_name, env);
     
     conf = AXIS2_DEP_ENGINE_GET_AXIS2_CONF(desc_builder->engine, env);
     if(!conf)

Modified: webservices/axis2/trunk/c/modules/core/deployment/module_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/module_builder.c?rev=413606&r1=413605&r2=413606&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/module_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/module_builder.c Mon Jun 12 01:26:30 2006
@@ -45,7 +45,7 @@
 axis2_array_list_t *AXIS2_CALL
 axis2_module_builder_process_ops(axis2_module_builder_t *module_builder,
             const axis2_env_t *env,
-            axis2_om_children_qname_iterator_t *op_itr);
+            axiom_children_qname_iterator_t *op_itr);
                                 
 /************************** End of function prototypes ************************/
 
@@ -150,8 +150,8 @@
                                         const axis2_env_t *env)
 {
     axis2_module_builder_impl_t *builder_impl = NULL;
-    axis2_om_element_t *module_element = NULL;
-    axis2_om_node_t *module_node = NULL;
+    axiom_element_t *module_element = NULL;
+    axiom_node_t *module_node = NULL;
     axis2_qname_t *qdllname = NULL;
     axis2_qname_t *qparamst = NULL;
     axis2_qname_t *qinflowst = NULL;
@@ -159,17 +159,17 @@
     axis2_qname_t *qinfaultflow = NULL;
     axis2_qname_t *qoutfaultflow = NULL;
     axis2_qname_t *qopst = NULL; 
-    axis2_om_attribute_t *module_dll_att = NULL;
-    axis2_om_children_qname_iterator_t *itr = NULL;
-    axis2_om_children_qname_iterator_t *op_itr = NULL;
-    axis2_om_element_t *in_flow_element = NULL;
-    axis2_om_node_t *in_flow_node = NULL;
-    axis2_om_element_t *out_flow_element = NULL;
-    axis2_om_node_t *out_flow_node = NULL;
-    axis2_om_element_t *in_fault_flow_element = NULL;
-    axis2_om_node_t *in_fault_flow_node = NULL;
-    axis2_om_element_t *out_fault_flow_element = NULL;
-    axis2_om_node_t *out_fault_flow_node = NULL;
+    axiom_attribute_t *module_dll_att = NULL;
+    axiom_children_qname_iterator_t *itr = NULL;
+    axiom_children_qname_iterator_t *op_itr = NULL;
+    axiom_element_t *in_flow_element = NULL;
+    axiom_node_t *in_flow_node = NULL;
+    axiom_element_t *out_flow_element = NULL;
+    axiom_node_t *out_flow_node = NULL;
+    axiom_element_t *in_fault_flow_element = NULL;
+    axiom_node_t *in_fault_flow_node = NULL;
+    axiom_element_t *out_fault_flow_element = NULL;
+    axiom_node_t *out_fault_flow_node = NULL;
     axis2_conf_t *parent = NULL;
     axis2_array_list_t *ops = NULL;
     axis2_param_container_t *parent_container = NULL;
@@ -183,14 +183,14 @@
     builder_impl = AXIS2_INTF_TO_IMPL(module_builder);
     
     module_node = AXIS2_DESC_BUILDER_BUILD_OM(module_builder->desc_builder, env);
-    module_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(module_node, env);
+    module_element = AXIOM_NODE_GET_DATA_ELEMENT(module_node, env);
     if(!module_element)
     {
         return AXIS2_FAILURE;
     }
     /* Setting Module Name */
     /*qattname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
-    module_name_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(module_element, env, 
+    module_name_att = AXIOM_ELEMENT_GET_ATTRIBUTE(module_element, env, 
         qattname);
     if(qattname)
         AXIS2_QNAME_FREE(qattname, env);
@@ -198,7 +198,7 @@
     {
         axis2_char_t *module_name = NULL;
         
-        module_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(module_name_att, env);
+        module_name = AXIOM_ATTRIBUTE_GET_VALUE(module_name_att, env);
         if(NULL != module_name && (0 != AXIS2_STRCMP("", module_name)))
         {
             axis2_qname_t *qmodule_name = NULL;
@@ -246,7 +246,7 @@
     /* Setting Module Dll Name , if it is there */
     
     qdllname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
-    module_dll_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(module_element, env, qdllname);
+    module_dll_att = AXIOM_ELEMENT_GET_ATTRIBUTE(module_element, env, qdllname);
     if(qdllname)
         AXIS2_QNAME_FREE(qdllname, env);
     
@@ -255,7 +255,7 @@
         axis2_char_t *class_name = NULL;
         
         
-        class_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(module_dll_att, env);
+        class_name = AXIOM_ATTRIBUTE_GET_VALUE(module_dll_att, env);
         if(NULL != class_name && (0 != AXIS2_STRCMP("", class_name)))
         {
             if(NULL != module_builder->desc_builder->engine)
@@ -275,7 +275,7 @@
     /* Processing service level paramters */
     
     qparamst = axis2_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-    itr = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(module_element, env,
+    itr = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(module_element, env,
         qparamst, module_node);
     if(qparamst)
         AXIS2_QNAME_FREE(qparamst, env);
@@ -288,7 +288,7 @@
 
     /* process INFLOW */
     qinflowst = axis2_qname_create(env, AXIS2_INFLOWST, NULL, NULL);
-    in_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
+    in_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
         env, qinflowst, module_node, &in_flow_node);
     if(qinflowst)
         AXIS2_QNAME_FREE(qinflowst, env);
@@ -310,7 +310,7 @@
     }
     
     qoutflowst = axis2_qname_create(env, AXIS2_OUTFLOWST, NULL, NULL);
-    out_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
+    out_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
         env, qoutflowst, module_node, &out_flow_node);
     if(qoutflowst)
         AXIS2_QNAME_FREE(qoutflowst, env);
@@ -331,7 +331,7 @@
     }
 
     qinfaultflow = axis2_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL);
-    in_fault_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
+    in_fault_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
         env, qinfaultflow, module_node, &in_fault_flow_node);
     if(qinfaultflow)
         AXIS2_QNAME_FREE(qinfaultflow, env);
@@ -352,7 +352,7 @@
     }
     
     qoutfaultflow = axis2_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL);
-    out_fault_flow_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
+    out_fault_flow_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(module_element,
         env, qoutfaultflow, module_node, &out_fault_flow_node);
     if(qoutfaultflow)
         AXIS2_QNAME_FREE(qoutfaultflow, env);
@@ -375,7 +375,7 @@
 
     /* processing Operations */
     qopst = axis2_qname_create(env, AXIS2_OPERATIONST, NULL, NULL);
-    op_itr = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(module_element, env,
+    op_itr = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(module_element, env,
         qopst, module_node);
     if(qopst)
         AXIS2_QNAME_FREE(qopst, env);
@@ -397,7 +397,7 @@
 axis2_array_list_t *AXIS2_CALL
 axis2_module_builder_process_ops(axis2_module_builder_t *module_builder,
             const axis2_env_t *env,
-            axis2_om_children_qname_iterator_t *op_itr)
+            axiom_children_qname_iterator_t *op_itr)
 {
     axis2_module_builder_impl_t *builder_impl = NULL;
     axis2_array_list_t *ops = NULL;
@@ -407,12 +407,12 @@
     builder_impl = AXIS2_INTF_TO_IMPL(module_builder);
     
     ops = axis2_array_list_create(env, 0);
-    while(AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(op_itr, env))
+    while(AXIS2_TRUE == AXIOM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(op_itr, env))
     {
-        axis2_om_element_t *op_element = NULL;
-        axis2_om_node_t *op_node = NULL;
-        axis2_om_attribute_t *op_name_att = NULL;
-        axis2_om_attribute_t *op_mep_att = NULL;
+        axiom_element_t *op_element = NULL;
+        axiom_node_t *op_node = NULL;
+        axiom_attribute_t *op_name_att = NULL;
+        axiom_attribute_t *op_mep_att = NULL;
         axis2_qname_t *qattname = NULL;
         axis2_char_t *mep_url = NULL;
         axis2_char_t *op_name = NULL;
@@ -421,19 +421,19 @@
         axis2_qname_t *qparamst = NULL;
         axis2_qname_t *qmodulest = NULL;
         axis2_qname_t *qmep = NULL;
-        axis2_om_children_qname_iterator_t *params = NULL;
-        axis2_om_children_qname_iterator_t *modules = NULL;
-        axis2_om_element_t *recv_element = NULL;
-        axis2_om_node_t *recv_node = NULL;
+        axiom_children_qname_iterator_t *params = NULL;
+        axiom_children_qname_iterator_t *modules = NULL;
+        axiom_element_t *recv_element = NULL;
+        axiom_node_t *recv_node = NULL;
         axis2_phases_info_t *info = NULL;
         axis2_op_t *op_desc = NULL;
         
-        op_node = (axis2_om_node_t *) AXIS2_OM_CHILDREN_QNAME_ITERATOR_NEXT(
+        op_node = (axiom_node_t *) AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(
             op_itr, env);
-        op_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(op_node, env);
+        op_element = AXIOM_NODE_GET_DATA_ELEMENT(op_node, env);
         /* getting operation name */
         qattname = axis2_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
-        op_name_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(op_element, env, qattname);
+        op_name_att = AXIOM_ELEMENT_GET_ATTRIBUTE(op_element, env, qattname);
         if(qattname)
             AXIS2_QNAME_FREE(qattname, env);
 
@@ -444,13 +444,13 @@
             return NULL;
         }
         qmep = axis2_qname_create(env, AXIS2_MEP, NULL, NULL);
-        op_mep_att = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(op_element, env, qmep);
+        op_mep_att = AXIOM_ELEMENT_GET_ATTRIBUTE(op_element, env, qmep);
         if(qmep)
             AXIS2_QNAME_FREE(qmep, env);
         
         if(NULL != op_mep_att)
         {
-            mep_url = AXIS2_OM_ATTRIBUTE_GET_VALUE(op_mep_att, env);
+            mep_url = AXIOM_ATTRIBUTE_GET_VALUE(op_mep_att, env);
         }
         if(NULL == mep_url)
         {
@@ -465,7 +465,7 @@
             op_desc = axis2_op_create(env);
         }
         
-        op_name = AXIS2_OM_ATTRIBUTE_GET_VALUE(op_name_att, env);
+        op_name = AXIOM_ATTRIBUTE_GET_VALUE(op_name_att, env);
         qopname = axis2_qname_create(env, op_name, NULL, NULL);
         AXIS2_OP_SET_QNAME(op_desc, env, qopname);
         if(qopname)
@@ -473,7 +473,7 @@
 
         /* Operation parameters */
         qparamst = axis2_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-        params = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(op_element, env, 
+        params = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(op_element, env, 
             qparamst, op_node);
         if(qparamst)
             AXIS2_QNAME_FREE(qparamst, env);
@@ -484,7 +484,7 @@
         
         /* loading the message receivers */
         qmsgrecv = axis2_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL);
-        recv_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(op_element, 
+        recv_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(op_element, 
             env, qmsgrecv, op_node, &recv_node);
         if(qmsgrecv)
             AXIS2_QNAME_FREE(qmsgrecv, env);
@@ -507,7 +507,7 @@
         }
         /* Process Module Refs */
         qmodulest = axis2_qname_create(env, AXIS2_MODULEST, NULL, NULL);
-        modules = AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(op_element, env, 
+        modules = AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(op_element, env, 
             qmodulest, op_node);
         if(qmodulest)
             AXIS2_QNAME_FREE(qmodulest, env);



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