axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From din...@apache.org
Subject svn commit: r515039 [2/5] - in /webservices/axis2/trunk/c: axiom/src/attachments/ axiom/src/om/ axiom/src/parser/libxml2/ axiom/src/soap/ axiom/src/util/ modules/core/addr/ modules/core/clientapi/ modules/core/context/ modules/core/deployment/ modules/...
Date Tue, 06 Mar 2007 09:15:33 GMT
Modified: webservices/axis2/trunk/c/modules/core/description/svc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/svc.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/svc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/svc.c Tue Mar  6 01:15:20 2007
@@ -282,30 +282,30 @@
         int i = 0;
         int size = 0;
 
-        size = AXIS2_ARRAY_LIST_SIZE(svc->module_list, env);
+        size = axis2_array_list_size(svc->module_list, env);
         for (i = 0; i < size; i++)
         {
             axis2_qname_t *qname = NULL;
-            qname = AXIS2_ARRAY_LIST_GET(svc->module_list, env, i);
+            qname = axis2_array_list_get(svc->module_list, env, i);
             if (qname)
             {
                 AXIS2_QNAME_FREE(qname, env);
                 qname = NULL;
             }
         }
-        AXIS2_ARRAY_LIST_FREE(svc->module_list, env);
+        axis2_array_list_free(svc->module_list, env);
         svc->module_list = NULL;
     }
 
     if (svc->schema_list)
     {
-        AXIS2_ARRAY_LIST_FREE(svc->schema_list, env);
+        axis2_array_list_free(svc->schema_list, env);
         svc->schema_list = NULL;
     }
 
     if (svc->engaged_modules)
     {
-        AXIS2_ARRAY_LIST_FREE(svc->engaged_modules, env);
+        axis2_array_list_free(svc->engaged_modules, env);
     }
 
     if (svc->axis_svc_name)
@@ -696,7 +696,7 @@
     if (status)
     {
         const axis2_qname_t *qname = NULL;
-        status = AXIS2_ARRAY_LIST_ADD(svc->engaged_modules, env, module_desc);
+        status = axis2_array_list_add(svc->engaged_modules, env, module_desc);
         qname = AXIS2_MODULE_DESC_GET_QNAME(module_desc, env);
         axis2_svc_add_module_qname(svc, env, qname);
     }
@@ -1354,7 +1354,7 @@
     AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE);
 
     qmodule_qname_l = AXIS2_QNAME_CLONE((axis2_qname_t *)module_qname, env);
-    return AXIS2_ARRAY_LIST_ADD(svc->module_list, env,
+    return axis2_array_list_add(svc->module_list, env,
             qmodule_qname_l);
 }
 
@@ -1494,12 +1494,12 @@
         return AXIS2_FAILURE;
     }
 
-    size = AXIS2_ARRAY_LIST_SIZE(svc->schema_list, env);
+    size = axis2_array_list_size(svc->schema_list, env);
     for (i = 0; i < size; i++)
     {
         xml_schema_t *schema = NULL;
         axis2_char_t *buffer = NULL;
-        schema = AXIS2_ARRAY_LIST_GET(svc->schema_list, env, i);
+        schema = axis2_array_list_get(svc->schema_list, env, i);
         buffer = XML_SCHEMA_SERIALIZE(schema, env);
         if (buffer)
         {
@@ -1538,7 +1538,7 @@
                 AXIS2_FAILURE);
         return NULL;
     }
-    schema = (xml_schema_t *)AXIS2_ARRAY_LIST_GET(svc->schema_list, env, index);
+    schema = (xml_schema_t *)axis2_array_list_get(svc->schema_list, env, index);
     prefix_map = XML_SCHEMA_GET_PREFIX_TO_NAMESPACE_MAP(schema, env);
     if (NULL == prefix_map)
     {
@@ -1582,7 +1582,7 @@
                 AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    AXIS2_ARRAY_LIST_ADD(svc->schema_list, env, schema);
+    axis2_array_list_add(svc->schema_list, env, schema);
     return axis2_svc_add_schema_ns(svc, env, XML_SCHEMA_GET_TARGET_NAMESPACE(
                 schema, env));
 }
@@ -1724,11 +1724,11 @@
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(svc->schema_list, env); i++)
+    for (i = 0; i < axis2_array_list_size(svc->schema_list, env); i++)
     {
         xml_schema_t *schema = NULL;
         xml_schema_element_t *schema_element = NULL;
-        schema = AXIS2_ARRAY_LIST_GET(svc->schema_list, env, i);
+        schema = axis2_array_list_get(svc->schema_list, env, i);
         if (schema)
         {
             schema_element = XML_SCHEMA_GET_ELEMENT_BY_QNAME(schema, env,

Modified: webservices/axis2/trunk/c/modules/core/description/svc_grp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/svc_grp.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/svc_grp.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/svc_grp.c Tue Mar  6 01:15:20 2007
@@ -138,13 +138,13 @@
 
     if (svc_grp->module_qnames)
     {
-        AXIS2_ARRAY_LIST_FREE(svc_grp->module_qnames, env);
+        axis2_array_list_free(svc_grp->module_qnames, env);
         svc_grp->module_qnames = NULL;
     }
 
     if (svc_grp->module_list)
     {
-        AXIS2_ARRAY_LIST_FREE(svc_grp->module_list, env);
+        axis2_array_list_free(svc_grp->module_list, env);
         svc_grp->module_list = NULL;
     }
 
@@ -395,7 +395,7 @@
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return AXIS2_ARRAY_LIST_ADD(svc_grp->module_qnames, env,
+    return axis2_array_list_add(svc_grp->module_qnames, env,
             module_qname);
 }
 
@@ -444,14 +444,14 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE);
 
-    size = AXIS2_ARRAY_LIST_SIZE(svc_grp->module_qnames, env);
+    size = axis2_array_list_size(svc_grp->module_qnames, env);
     if (AXIS2_TRUE != AXIS2_ERROR_GET_STATUS_CODE(env->error))
     {
         return AXIS2_FAILURE;
     }
     for (i = 0; size; i++)
     {
-        modu = AXIS2_ARRAY_LIST_GET(svc_grp->module_qnames, env, i);
+        modu = axis2_array_list_get(svc_grp->module_qnames, env, i);
         modu_local = AXIS2_QNAME_GET_LOCALPART(modu, env);
         module_name_local = AXIS2_QNAME_GET_LOCALPART(module_name, env);
         if (0 == AXIS2_STRCMP(modu_local, module_name_local))
@@ -535,7 +535,7 @@
         if (!svc_grp->module_list)
             return AXIS2_FAILURE;
     }
-    return AXIS2_ARRAY_LIST_ADD(svc_grp->module_list, env, moduleref);
+    return axis2_array_list_add(svc_grp->module_list, env, moduleref);
 }
 
 AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL

Modified: webservices/axis2/trunk/c/modules/core/engine/conf.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/conf.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/conf.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/conf.c Tue Mar  6 01:15:20 2007
@@ -469,11 +469,11 @@
                 handler = AXIS2_DISP_GET_BASE(uri_dispatch, env);
                 AXIS2_DISP_FREE(uri_dispatch, env);
                 AXIS2_PHASE_ADD_HANDLER_AT(phase, env, 0, handler);
-                AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+                axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
                 handler = NULL;
         }
 
-        status = AXIS2_ARRAY_LIST_ADD(config_impl->
+        status = axis2_array_list_add(config_impl->
                 in_phases_upto_and_including_post_dispatch, env, phase);
         if (AXIS2_FAILURE == status)
         {
@@ -488,7 +488,7 @@
             axis2_conf_free(&(config_impl->conf), env);
             return NULL;
         }
-        status = AXIS2_ARRAY_LIST_ADD(config_impl->
+        status = axis2_array_list_add(config_impl->
                 in_phases_upto_and_including_post_dispatch, env, phase);
         if (AXIS2_FAILURE == status)
         {
@@ -759,54 +759,54 @@
     if (config_impl->engaged_modules)
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(config_impl->engaged_modules,
+        for (i = 0; i < axis2_array_list_size(config_impl->engaged_modules,
                 env); i++)
         {
             axis2_qname_t *module_desc_qname = NULL;
             module_desc_qname = (axis2_qname_t *)
-                    AXIS2_ARRAY_LIST_GET(config_impl->engaged_modules, env, i);
+                    axis2_array_list_get(config_impl->engaged_modules, env, i);
             if (module_desc_qname)
                 AXIS2_QNAME_FREE(module_desc_qname, env);
 
             module_desc_qname = NULL;
         }
-        AXIS2_ARRAY_LIST_FREE(config_impl->engaged_modules, env);
+        axis2_array_list_free(config_impl->engaged_modules, env);
         config_impl->engaged_modules = NULL;
     }
 
     if (config_impl->out_phases)
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(config_impl->out_phases, env); i++)
+        for (i = 0; i < axis2_array_list_size(config_impl->out_phases, env); i++)
         {
             axis2_phase_t *phase = NULL;
             phase = (axis2_phase_t *)
-                    AXIS2_ARRAY_LIST_GET(config_impl->out_phases, env, i);
+                    axis2_array_list_get(config_impl->out_phases, env, i);
             if (phase)
                 AXIS2_PHASE_FREE(phase, env);
 
             phase = NULL;
 
         }
-        AXIS2_ARRAY_LIST_FREE(config_impl->out_phases, env);
+        axis2_array_list_free(config_impl->out_phases, env);
         config_impl->out_phases = NULL;
     }
 
     if (config_impl->in_fault_phases)
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(config_impl->in_fault_phases, env); i++)
+        for (i = 0; i < axis2_array_list_size(config_impl->in_fault_phases, env); i++)
         {
             axis2_phase_t *phase = NULL;
             phase = (axis2_phase_t *)
-                    AXIS2_ARRAY_LIST_GET(config_impl->in_fault_phases, env, i);
+                    axis2_array_list_get(config_impl->in_fault_phases, env, i);
             if (phase)
                 AXIS2_PHASE_FREE(phase, env);
 
             phase = NULL;
 
         }
-        AXIS2_ARRAY_LIST_FREE(config_impl->in_fault_phases, env);
+        axis2_array_list_free(config_impl->in_fault_phases, env);
         config_impl->in_fault_phases = NULL;
     }
 
@@ -816,11 +816,11 @@
          * phase_info 
          */
         /*int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(config_impl->out_fault_phases, env); i++)
+        for (i = 0; i < axis2_array_list_size(config_impl->out_fault_phases, env); i++)
         {
             axis2_phase_t *phase = NULL;
             phase = (axis2_phase_t *)
-                    AXIS2_ARRAY_LIST_GET(config_impl->out_fault_phases, env, i);
+                    axis2_array_list_get(config_impl->out_fault_phases, env, i);
 
             if (phase)
                 AXIS2_PHASE_FREE(phase, env);
@@ -828,18 +828,18 @@
             phase = NULL;
 
         }*/
-        AXIS2_ARRAY_LIST_FREE(config_impl->out_fault_phases, env);
+        axis2_array_list_free(config_impl->out_fault_phases, env);
         config_impl->out_fault_phases = NULL;
     }
 
     if (config_impl->in_phases_upto_and_including_post_dispatch)
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(config_impl->
+        for (i = 0; i < axis2_array_list_size(config_impl->
                 in_phases_upto_and_including_post_dispatch, env); i++)
         {
             axis2_phase_t *phase = NULL;
-            phase = (axis2_phase_t *) AXIS2_ARRAY_LIST_GET(config_impl->
+            phase = (axis2_phase_t *) axis2_array_list_get(config_impl->
                     in_phases_upto_and_including_post_dispatch, env, i);
 
             if (phase)
@@ -847,7 +847,7 @@
             phase = NULL;
 
         }
-        AXIS2_ARRAY_LIST_FREE(config_impl->
+        axis2_array_list_free(config_impl->
                 in_phases_upto_and_including_post_dispatch, env);
         config_impl->in_phases_upto_and_including_post_dispatch = NULL;
     }
@@ -910,18 +910,18 @@
     if (config_impl->handlers)
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(config_impl->handlers, env); i++)
+        for (i = 0; i < axis2_array_list_size(config_impl->handlers, env); i++)
         {
             axis2_handler_desc_t *handler_desc = NULL;
             handler_desc = (axis2_handler_desc_t *)
-                    AXIS2_ARRAY_LIST_GET(config_impl->handlers, env, i);
+                    axis2_array_list_get(config_impl->handlers, env, i);
             if (handler_desc)
                 AXIS2_HANDLER_DESC_FREE(handler_desc, env);
 
             handler_desc = NULL;
 
         }
-        AXIS2_ARRAY_LIST_FREE(config_impl->handlers, env);
+        axis2_array_list_free(config_impl->handlers, env);
         config_impl->handlers = NULL;
     }
 
@@ -1469,13 +1469,13 @@
     {
         def_mod_qname = AXIS2_MODULE_DESC_GET_QNAME(def_mod, env);
     }
-    size = AXIS2_ARRAY_LIST_SIZE(config_impl->engaged_modules, env);
+    size = axis2_array_list_size(config_impl->engaged_modules, env);
     for (i = 0; i < size; i++)
     {
         axis2_qname_t *qname = NULL;
 
 
-        qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(config_impl->
+        qname = (axis2_qname_t *) axis2_array_list_get(config_impl->
                 engaged_modules, env, i);
 
         if (AXIS2_TRUE == AXIS2_QNAME_EQUALS(module_name, env, qname) ||
@@ -1570,7 +1570,7 @@
     config_impl = AXIS2_INTF_TO_IMPL(conf);
     if (config_impl->out_phases)
     {
-        AXIS2_ARRAY_LIST_FREE(config_impl->out_phases, env);
+        axis2_array_list_free(config_impl->out_phases, env);
         config_impl->out_phases = NULL;
     }
     config_impl->out_phases = out_phases;
@@ -1600,7 +1600,7 @@
     config_impl = AXIS2_INTF_TO_IMPL(conf);
     if (config_impl->in_fault_phases)
     {
-        AXIS2_ARRAY_LIST_FREE(config_impl->in_fault_phases, env);
+        axis2_array_list_free(config_impl->in_fault_phases, env);
         config_impl->in_fault_phases = NULL;
     }
     config_impl->in_fault_phases = list;
@@ -1621,7 +1621,7 @@
     config_impl = AXIS2_INTF_TO_IMPL(conf);
     if (config_impl->out_fault_phases)
     {
-        AXIS2_ARRAY_LIST_FREE(config_impl->out_fault_phases, env);
+        axis2_array_list_free(config_impl->out_fault_phases, env);
         config_impl->out_fault_phases = NULL;
     }
     config_impl->out_fault_phases = list;
@@ -1710,7 +1710,7 @@
     handler = AXIS2_DISP_GET_BASE(soap_msg_body_based_dispatch, env);
     AXIS2_DISP_FREE(soap_msg_body_based_dispatch, env);
     AXIS2_PHASE_ADD_HANDLER_AT(dispatch, env, 0, handler);
-    AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+    axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
     handler = NULL;
 
 
@@ -1724,7 +1724,7 @@
     handler = AXIS2_DISP_GET_BASE(add_dispatch, env);
     AXIS2_DISP_FREE(add_dispatch, env);
     AXIS2_PHASE_ADD_HANDLER_AT(dispatch, env, 1, handler);
-    AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+    axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
     handler = NULL;
 
     /*uri_dispatch = axis2_req_uri_disp_create(env);
@@ -1736,7 +1736,7 @@
     handler = AXIS2_DISP_GET_BASE(uri_dispatch, env);
     AXIS2_DISP_FREE(uri_dispatch, env);
     AXIS2_PHASE_ADD_HANDLER_AT(dispatch, env, 1, handler);
-    AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+    axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
     handler = NULL;*/
 
     soap_action_based_dispatch = axiom_soap_action_disp_create(env);
@@ -1748,10 +1748,10 @@
     handler = AXIS2_DISP_GET_BASE(soap_action_based_dispatch, env);
     AXIS2_DISP_FREE(soap_action_based_dispatch, env);
     AXIS2_PHASE_ADD_HANDLER_AT(dispatch, env, 2, handler);
-    AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+    axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
     handler = NULL;
 
-    status = AXIS2_ARRAY_LIST_ADD(config_impl->
+    status = axis2_array_list_add(config_impl->
             in_phases_upto_and_including_post_dispatch, env, dispatch);
     if (AXIS2_SUCCESS != status)
     {
@@ -1770,14 +1770,14 @@
     handler = AXIS2_DISP_CHECKER_GET_BASE(disp_checker, env);
     AXIS2_DISP_CHECKER_FREE(disp_checker, env);
     AXIS2_PHASE_ADD_HANDLER_AT(post_dispatch, env, 0, handler);
-    AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+    axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
     handler = NULL;
 
     handler = axis2_ctx_handler_create(env, NULL);
     AXIS2_PHASE_ADD_HANDLER_AT(post_dispatch, env, 1, handler);
-    AXIS2_ARRAY_LIST_ADD(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
+    axis2_array_list_add(config_impl->handlers, env, AXIS2_HANDLER_GET_HANDLER_DESC(handler, env));
 
-    status = AXIS2_ARRAY_LIST_ADD(config_impl->
+    status = axis2_array_list_add(config_impl->
             in_phases_upto_and_including_post_dispatch, env, post_dispatch);
     if (AXIS2_SUCCESS != status)
     {
@@ -1804,7 +1804,7 @@
     AXIS2_PARAM_CHECK(env->error, dispatch, AXIS2_FAILURE);
     config_impl = AXIS2_INTF_TO_IMPL(conf);
 
-    status = AXIS2_ARRAY_LIST_ADD(config_impl->
+    status = axis2_array_list_add(config_impl->
             in_phases_upto_and_including_post_dispatch, env, dispatch);
     if (AXIS2_FAILURE == status)
     {
@@ -1823,7 +1823,7 @@
     handler = AXIS2_DISP_CHECKER_GET_BASE(disp_checker, env);
     AXIS2_PHASE_ADD_HANDLER_AT(post_dispatch, env, 0, handler);
 
-    status = AXIS2_ARRAY_LIST_ADD(config_impl->
+    status = axis2_array_list_add(config_impl->
             in_phases_upto_and_including_post_dispatch, env, post_dispatch);
     if (AXIS2_FAILURE == status)
     {
@@ -1903,13 +1903,13 @@
         int i = 0;
         const axis2_qname_t *module_qname = NULL;
 
-        size = AXIS2_ARRAY_LIST_SIZE(config_impl->engaged_modules, env);
+        size = axis2_array_list_size(config_impl->engaged_modules, env);
         module_qname = AXIS2_MODULE_DESC_GET_QNAME(module_desc, env);
         for (i = 0; i < size; i++)
         {
             axis2_qname_t *qname = NULL;
 
-            qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(config_impl->
+            qname = (axis2_qname_t *) axis2_array_list_get(config_impl->
                     engaged_modules, env, i);
             if (AXIS2_TRUE == AXIS2_QNAME_EQUALS(module_qname, env, qname))
             {
@@ -1943,7 +1943,7 @@
         }
         module_qname = AXIS2_MODULE_DESC_GET_QNAME(module_desc, env);
         module_qref_l = AXIS2_QNAME_CLONE((axis2_qname_t *)module_qname, env);
-        status = AXIS2_ARRAY_LIST_ADD(config_impl->engaged_modules, env,
+        status = axis2_array_list_add(config_impl->engaged_modules, env,
                 module_qref_l);
     }
     if (is_new_module)

Modified: webservices/axis2/trunk/c/modules/core/engine/engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/engine.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/engine.c Tue Mar  6 01:15:20 2007
@@ -755,11 +755,11 @@
     AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
 
     if (phases)
-        count = AXIS2_ARRAY_LIST_SIZE(phases, env);
+        count = axis2_array_list_size(phases, env);
     for (i = 0; (i < count && !(AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))); i++)
     {
         axis2_phase_t *phase = (axis2_phase_t *)
-                AXIS2_ARRAY_LIST_GET(phases, env, i);
+                axis2_array_list_get(phases, env, i);
 
         AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                 "Invoking phase %s", AXIS2_PHASE_GET_NAME(phase, env));
@@ -791,11 +791,11 @@
 
     AXIS2_MSG_CTX_SET_PAUSED(msg_ctx, env, AXIS2_FALSE);
 
-    count = AXIS2_ARRAY_LIST_SIZE(phases, env);
+    count = axis2_array_list_size(phases, env);
 
     for (i = 0; i < count && !(AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env)); i++)
     {
-        axis2_phase_t *phase = (axis2_phase_t *) AXIS2_ARRAY_LIST_GET(phases,
+        axis2_phase_t *phase = (axis2_phase_t *) axis2_array_list_get(phases,
                 env, i);
         const axis2_char_t *phase_name = AXIS2_PHASE_GET_NAME(phase, env);
         const axis2_char_t *paused_phase_name = AXIS2_MSG_CTX_GET_PAUSED_PHASE_NAME(

Modified: webservices/axis2/trunk/c/modules/core/engine/phase.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/phase.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/phase.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/phase.c Tue Mar  6 01:15:20 2007
@@ -283,7 +283,7 @@
             index,
             phase_impl->name);
 
-    return AXIS2_ARRAY_LIST_ADD_AT(phase_impl->handlers, env, index, handler);
+    return axis2_array_list_add_at(phase_impl->handlers, env, index, handler);
 }
 
 axis2_status_t AXIS2_CALL
@@ -302,7 +302,7 @@
             axis2_string_get_buffer(AXIS2_HANDLER_GET_NAME(handler, env), env),
             phase_impl->name);
 
-    /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+    /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
     return add_unique(env, phase_impl->handlers, handler);
 }
 
@@ -341,7 +341,7 @@
         }
     }
     /* Invoking the rest of handlers except first_handler and last_handler */
-    size = AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env);
+    size = axis2_array_list_size(phase_impl->handlers, env);
 
     while (index < size)
     {
@@ -352,7 +352,7 @@
         else
         {
             axis2_handler_t *handler = (axis2_handler_t*)
-                    AXIS2_ARRAY_LIST_GET(phase_impl->handlers, env, index);
+                    axis2_array_list_get(phase_impl->handlers, env, index);
             if (handler)
             {
                 AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
@@ -407,7 +407,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_ARRAY_LIST_SIZE(AXIS2_INTF_TO_IMPL(phase)->handlers, env);
+    return axis2_array_list_size(AXIS2_INTF_TO_IMPL(phase)->handlers, env);
 }
 
 
@@ -559,7 +559,7 @@
 
         if (first && last)
         {
-            if (AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env) > 0)
+            if (axis2_array_list_size(phase_impl->handlers, env) > 0)
             {
                 AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_RULES, AXIS2_FAILURE);
                 return AXIS2_FAILURE;
@@ -572,7 +572,7 @@
                 return AXIS2_FAILURE;
             }
 
-            /*status = AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+            /*status = axis2_array_list_add(phase_impl->handlers, env, handler);*/
             status = add_unique(env, phase_impl->handlers, handler);
             if (status == AXIS2_SUCCESS)
                 phase_impl->is_one_handler = AXIS2_TRUE;
@@ -762,16 +762,16 @@
 
         if (AXIS2_STRCMP(before, handler_name) == 0)
         {
-            /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+            /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
             return add_unique(env, phase_impl->handlers, handler);
         }
     }
 
-    size = AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env);
+    size = axis2_array_list_size(phase_impl->handlers, env);
 
     for (i = 0; i < size; i++)
     {
-        axis2_handler_t *temp_handler = (axis2_handler_t *) AXIS2_ARRAY_LIST_GET(phase_impl->handlers, env, i);
+        axis2_handler_t *temp_handler = (axis2_handler_t *) axis2_array_list_get(phase_impl->handlers, env, i);
         if (temp_handler)
         {
             handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(temp_handler, env);
@@ -790,12 +790,12 @@
 
             if (AXIS2_STRCMP(before, handler_name) == 0)
             {
-                return AXIS2_ARRAY_LIST_ADD_AT(phase_impl->handlers, env, i, handler);
+                return axis2_array_list_add_at(phase_impl->handlers, env, i, handler);
             }
         }
     }
     /* add as the last handler */
-    /* return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler); */
+    /* return axis2_array_list_add(phase_impl->handlers, env, handler); */
     return add_unique(env, phase_impl->handlers, handler);
 }
 
@@ -856,15 +856,15 @@
 
         if (AXIS2_STRCMP(after, handler_name) == 0)
         {
-            return AXIS2_ARRAY_LIST_ADD_AT(phase_impl->handlers, env, 0, handler);
+            return axis2_array_list_add_at(phase_impl->handlers, env, 0, handler);
         }
     }
 
-    size = AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env);
+    size = axis2_array_list_size(phase_impl->handlers, env);
 
     for (i = 0; i < size; i++)
     {
-        axis2_handler_t *temp_handler = (axis2_handler_t *) AXIS2_ARRAY_LIST_GET(phase_impl->handlers, env, i);
+        axis2_handler_t *temp_handler = (axis2_handler_t *) axis2_array_list_get(phase_impl->handlers, env, i);
         if (temp_handler)
         {
             handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(temp_handler, env);
@@ -885,20 +885,20 @@
             {
                 if (i == (size - 1))
                 {
-                    /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+                    /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
                     return add_unique(env, phase_impl->handlers, handler);
                 }
                 else
-                    return AXIS2_ARRAY_LIST_ADD_AT(phase_impl->handlers, env, i + 1, handler);
+                    return axis2_array_list_add_at(phase_impl->handlers, env, i + 1, handler);
             }
         }
     }
 
     if (size > 0)
-        return AXIS2_ARRAY_LIST_ADD_AT(phase_impl->handlers, env, 0, handler);
+        return axis2_array_list_add_at(phase_impl->handlers, env, 0, handler);
     else
     {
-        /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+        /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
         return add_unique(env, phase_impl->handlers, handler);
     }
 }
@@ -990,7 +990,7 @@
         if (AXIS2_STRCMP(before_handler_name, before_name) == 0 &&
                 AXIS2_STRCMP(after_handler_name, after_name) == 0)
         {
-            /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+            /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
             return add_unique(env, phase_impl->handlers, handler);
         }
     }
@@ -1001,7 +1001,7 @@
             after = 0;
     }
 
-    size = AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env);
+    size = axis2_array_list_size(phase_impl->handlers, env);
 
     if (after_handler_name)
     {
@@ -1011,7 +1011,7 @@
 
     for (i = 0; i < size; i++)
     {
-        axis2_handler_t *temp_handler = (axis2_handler_t *) AXIS2_ARRAY_LIST_GET(phase_impl->handlers, env, i);
+        axis2_handler_t *temp_handler = (axis2_handler_t *) axis2_array_list_get(phase_impl->handlers, env, i);
         if (temp_handler)
         {
             handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(temp_handler, env);
@@ -1046,17 +1046,17 @@
             {
                 if (after + 1 < size)
                 {
-                    return AXIS2_ARRAY_LIST_ADD_AT(phase_impl->handlers, env, after + 1, handler);
+                    return axis2_array_list_add_at(phase_impl->handlers, env, after + 1, handler);
                 }
                 else
                 {
-                    /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+                    /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
                     return add_unique(env, phase_impl->handlers, handler);
                 }
             }
         }
     }
-    /*return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+    /*return axis2_array_list_add(phase_impl->handlers, env, handler);*/
     return add_unique(env, phase_impl->handlers, handler);
 }
 
@@ -1109,7 +1109,7 @@
             status = axis2_phase_insert_after(phase, env, handler);
             break;
         case 3: /*AXIS2_ANYWHERE:*/
-            /*status = AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);*/
+            /*status = axis2_array_list_add(phase_impl->handlers, env, handler);*/
             status = add_unique(env, phase_impl->handlers, handler);
             break;
         default:
@@ -1145,10 +1145,10 @@
 
     AXIS2_MSG_CTX_SET_PAUSED_PHASE_NAME(msg_ctx, env, phase_impl->name);
 
-    size = AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env);
+    size = axis2_array_list_size(phase_impl->handlers, env);
     for (i = paused_handler_index; i < size; i++)
     {
-        axis2_handler_t *handler = (axis2_handler_t *) AXIS2_ARRAY_LIST_GET(
+        axis2_handler_t *handler = (axis2_handler_t *) axis2_array_list_get(
                     phase_impl->handlers, env, i);
         if (handler)
         {
@@ -1194,7 +1194,7 @@
 
     if (phase_impl->handlers)
     {
-        AXIS2_ARRAY_LIST_FREE(phase_impl->handlers, env);
+        axis2_array_list_free(phase_impl->handlers, env);
         phase_impl->handlers = NULL;
     }
 
@@ -1215,13 +1215,13 @@
     const axis2_string_t *handler_name = NULL;
 
     handler_name = AXIS2_HANDLER_GET_NAME(handler, env);
-    size = AXIS2_ARRAY_LIST_SIZE(list, env);
+    size = axis2_array_list_size(list, env);
     for (i = 0; i < size; i++)
     {
         axis2_handler_t *obj = NULL;
         const axis2_string_t *obj_name = NULL;
 
-        obj = (axis2_handler_t *) AXIS2_ARRAY_LIST_GET(list, env, i);
+        obj = (axis2_handler_t *) axis2_array_list_get(list, env, i);
         obj_name = AXIS2_HANDLER_GET_NAME(obj, env);
         if (obj == handler)
         {
@@ -1236,7 +1236,7 @@
         }
     }
     if (AXIS2_TRUE == add_handler)
-        AXIS2_ARRAY_LIST_ADD(list, env, handler);
+        axis2_array_list_add(list, env, handler);
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c Tue Mar  6 01:15:20 2007
@@ -157,13 +157,13 @@
     AXIS2_PARAM_CHECK(env->error, phase_name, AXIS2_FALSE);
     phase_holder_impl = AXIS2_INTF_TO_IMPL(phase_holder);
 
-    size = AXIS2_ARRAY_LIST_SIZE(phase_holder_impl->phase_list, env);
+    size = axis2_array_list_size(phase_holder_impl->phase_list, env);
 
     for (i = 0; i < size; i++)
     {
         const axis2_char_t *phase_name_l = NULL;
 
-        phase = (axis2_phase_t *) AXIS2_ARRAY_LIST_GET(phase_holder_impl->
+        phase = (axis2_phase_t *) axis2_array_list_get(phase_holder_impl->
                 phase_list, env, i);
         phase_name_l = AXIS2_PHASE_GET_NAME(phase, env);
         if (0 == AXIS2_STRCMP(phase_name_l, phase_name))
@@ -226,12 +226,12 @@
 
     phase_holder_impl = AXIS2_INTF_TO_IMPL(phase_holder);
 
-    size = AXIS2_ARRAY_LIST_SIZE(phase_holder_impl->phase_list, env);
+    size = axis2_array_list_size(phase_holder_impl->phase_list, env);
 
     for (i = 0; i < size; i++)
     {
         const axis2_char_t *phase_name_l = NULL;
-        phase = (axis2_phase_t *) AXIS2_ARRAY_LIST_GET(phase_holder_impl->
+        phase = (axis2_phase_t *) axis2_array_list_get(phase_holder_impl->
                 phase_list, env, i);
         phase_name_l = AXIS2_PHASE_GET_NAME(phase, env);
         if (0 == AXIS2_STRCMP(phase_name_l, phase_name))
@@ -260,11 +260,11 @@
     AXIS2_PARAM_CHECK(env->error, phase, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, handlers, AXIS2_FAILURE);
 
-    size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+    size = axis2_array_list_size(handlers, env);
 
     for (i = 0; i < size; i++)
     {
-        handler_desc = (axis2_handler_desc_t *) AXIS2_ARRAY_LIST_GET(
+        handler_desc = (axis2_handler_desc_t *) axis2_array_list_get(
                     handlers, env, i);
         status = AXIS2_HANDLER_INIT(handler, env, handler_desc);
         if (AXIS2_FAILURE == status)

Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c Tue Mar  6 01:15:20 2007
@@ -338,7 +338,7 @@
     moduleqnames = AXIS2_CONF_GET_ALL_ENGAGED_MODULES(
                 resolver_impl->axis2_config, env);
 
-    size = AXIS2_ARRAY_LIST_SIZE(moduleqnames, env);
+    size = axis2_array_list_size(moduleqnames, env);
     status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
     if (AXIS2_SUCCESS != status)
     {
@@ -350,7 +350,7 @@
         axis2_qname_t *modulename = NULL;
         axis2_module_desc_t *module_desc = NULL;
 
-        modulename = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(moduleqnames, env,
+        modulename = (axis2_qname_t *) axis2_array_list_get(moduleqnames, env,
                 i);
         AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "module name is:%s",
                 AXIS2_QNAME_GET_LOCALPART(modulename, env));
@@ -437,12 +437,12 @@
                         if (!all_handlers)
                             return AXIS2_FAILURE;
                     }
-                    status = AXIS2_ARRAY_LIST_ADD(all_handlers, env, metadata);
+                    status = axis2_array_list_add(all_handlers, env, metadata);
                     if (AXIS2_SUCCESS != status)
                     {
                         if (all_handlers)
                         {
-                            AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+                            axis2_array_list_free(all_handlers, env);
                             all_handlers = NULL;
                         }
                         return status;
@@ -515,7 +515,7 @@
         {
             if (all_handlers)
             {
-                AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+                axis2_array_list_free(all_handlers, env);
                 all_handlers = NULL;
             }
             return AXIS2_ERROR_GET_STATUS_CODE(env->error);
@@ -548,7 +548,7 @@
             {
                 if (all_handlers)
                 {
-                    AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+                    axis2_array_list_free(all_handlers, env);
                     all_handlers = NULL;
                 }
                 AXIS2_ERROR_SET(env->error,
@@ -565,7 +565,7 @@
                         return AXIS2_FAILURE;
                 }
 
-                status = AXIS2_ARRAY_LIST_ADD(all_handlers, env, metadata);
+                status = axis2_array_list_add(all_handlers, env, metadata);
 
                 if (AXIS2_SUCCESS != status)
                 {
@@ -573,16 +573,16 @@
                     {
                         int size = 0;
                         int i = 0;
-                        size = AXIS2_ARRAY_LIST_SIZE(all_handlers, env);
+                        size = axis2_array_list_size(all_handlers, env);
                         for (i = 0; i < size; i++)
                         {
                             axis2_handler_desc_t *handler_desc = NULL;
 
-                            handler_desc = AXIS2_ARRAY_LIST_GET(all_handlers,
+                            handler_desc = axis2_array_list_get(all_handlers,
                                     env, i);
                             AXIS2_HANDLER_DESC_FREE(handler_desc, env);
                         }
-                        AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+                        axis2_array_list_free(all_handlers, env);
                         all_handlers = NULL;
                     }
                     return status;
@@ -637,7 +637,7 @@
         }
     }
 
-    size = AXIS2_ARRAY_LIST_SIZE(all_handlers, env);
+    size = axis2_array_list_size(all_handlers, env);
     if (AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
     {
         return AXIS2_ERROR_GET_STATUS_CODE(env->error);
@@ -648,7 +648,7 @@
         axis2_handler_desc_t *metadata = NULL;
 
         metadata = (axis2_handler_desc_t *)
-                AXIS2_ARRAY_LIST_GET(all_handlers, env, i);
+                axis2_array_list_get(all_handlers, env, i);
         if (phase_holder)
         {
             status = AXIS2_PHASE_HOLDER_ADD_HANDLER(phase_holder,
@@ -660,7 +660,7 @@
 
     /* Free the locally created all_handlers list */
     if (all_handlers)
-        AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+        axis2_array_list_free(all_handlers, env);
     if(phase_holder)
         AXIS2_PHASE_HOLDER_FREE(phase_holder, env);
 
@@ -794,17 +794,17 @@
                         int i = 0;
                         int size = 0;
 
-                        size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+                        size = axis2_array_list_size(handlers, env);
                         for (i = 0; i < size; i++)
                         {
-                            handler_d = AXIS2_ARRAY_LIST_GET(handlers, env, i);
+                            handler_d = axis2_array_list_get(handlers, env, i);
                             AXIS2_HANDLER_DESC_FREE(handler_d, env);
                         }
-                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                        axis2_array_list_free(handlers, env);
                     }
                     return status;
                 }
-                status = AXIS2_ARRAY_LIST_ADD(handlers, env, metadata);
+                status = axis2_array_list_add(handlers, env, metadata);
                 if (AXIS2_SUCCESS != status)
                 {
                     if (handlers)
@@ -813,13 +813,13 @@
                         int i = 0;
                         int size = 0;
 
-                        size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+                        size = axis2_array_list_size(handlers, env);
                         for (i = 0; i < size; i++)
                         {
-                            handler_d = AXIS2_ARRAY_LIST_GET(handlers, env, i);
+                            handler_d = axis2_array_list_get(handlers, env, i);
                             AXIS2_HANDLER_DESC_FREE(handler_d, env);
                         }
-                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                        axis2_array_list_free(handlers, env);
                     }
                     return status;
                 }
@@ -833,13 +833,13 @@
                     int i = 0;
                     int size = 0;
 
-                    size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+                    size = axis2_array_list_size(handlers, env);
                     for (i = 0; i < size; i++)
                     {
-                        handler_d = AXIS2_ARRAY_LIST_GET(handlers, env, i);
+                        handler_d = axis2_array_list_get(handlers, env, i);
                         AXIS2_HANDLER_DESC_FREE(handler_d, env);
                     }
-                    AXIS2_ARRAY_LIST_FREE(handlers, env);
+                    axis2_array_list_free(handlers, env);
                 }
                 AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY,
                         AXIS2_FAILURE);
@@ -860,7 +860,7 @@
     }
     if (handlers)
     {
-        AXIS2_ARRAY_LIST_FREE(handlers, env);
+        axis2_array_list_free(handlers, env);
     }
     return status;
 }
@@ -932,18 +932,18 @@
                         int i = 0;
                         int size = 0;
 
-                        size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+                        size = axis2_array_list_size(handlers, env);
                         for (i = 0; i < size; i++)
                         {
-                            handler_d = AXIS2_ARRAY_LIST_GET(handlers, env, i);
+                            handler_d = axis2_array_list_get(handlers, env, i);
                             AXIS2_HANDLER_DESC_FREE(handler_d, env);
                         }
-                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                        axis2_array_list_free(handlers, env);
                     }
                     return status;
                 }
 
-                status = AXIS2_ARRAY_LIST_ADD(handlers, env, metadata);
+                status = axis2_array_list_add(handlers, env, metadata);
                 if (AXIS2_FAILURE == status)
                 {
                     if (handlers)
@@ -952,13 +952,13 @@
                         int i = 0;
                         int size = 0;
 
-                        size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+                        size = axis2_array_list_size(handlers, env);
                         for (i = 0; i < size; i++)
                         {
-                            handler_d = AXIS2_ARRAY_LIST_GET(handlers, env, i);
+                            handler_d = axis2_array_list_get(handlers, env, i);
                             AXIS2_HANDLER_DESC_FREE(handler_d, env);
                         }
-                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                        axis2_array_list_free(handlers, env);
                     }
                     return status;
                 }
@@ -972,13 +972,13 @@
                     int i = 0;
                     int size = 0;
 
-                    size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
+                    size = axis2_array_list_size(handlers, env);
                     for (i = 0; i < size; i++)
                     {
-                        handler_d = AXIS2_ARRAY_LIST_GET(handlers, env, i);
+                        handler_d = axis2_array_list_get(handlers, env, i);
                         AXIS2_HANDLER_DESC_FREE(handler_d, env);
                     }
-                    AXIS2_ARRAY_LIST_FREE(handlers, env);
+                    axis2_array_list_free(handlers, env);
                 }
                 AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
                 return AXIS2_FAILURE;
@@ -995,7 +995,7 @@
         }
     }
     if (handlers)
-        AXIS2_ARRAY_LIST_FREE(handlers, env);
+        axis2_array_list_free(handlers, env);
     return status;
 }
 
@@ -1125,14 +1125,14 @@
         modules = AXIS2_OP_GET_ALL_MODULES(op_desc, env);
         module_desc_qname = AXIS2_MODULE_DESC_GET_QNAME(module_desc, env);
         if (modules)
-            size = AXIS2_ARRAY_LIST_SIZE(modules, env);
+            size = axis2_array_list_size(modules, env);
         for (j = 0; j < size; j++)
         {
             axis2_module_desc_t *module_desc_l = NULL;
             const axis2_qname_t *module_desc_qname_l = NULL;
 
             module_desc_l = (axis2_module_desc_t *)
-                    AXIS2_ARRAY_LIST_GET(modules, env, j);
+                    axis2_array_list_get(modules, env, j);
 
             module_desc_qname_l = AXIS2_MODULE_DESC_GET_QNAME(module_desc_l ,
                     env);
@@ -1456,13 +1456,13 @@
         op_desc = (axis2_op_t *) v;
         modules = AXIS2_OP_GET_ALL_MODULES(op_desc, env);
         if (modules)
-            size = AXIS2_ARRAY_LIST_SIZE(modules, env);
+            size = axis2_array_list_size(modules, env);
         for (j = 0; j < size; j++)
         {
             axis2_module_desc_t *module_desc_l = NULL;
             const axis2_qname_t *module_d_qname_l = NULL;
 
-            module_desc_l = AXIS2_ARRAY_LIST_GET(modules, env, j);
+            module_desc_l = axis2_array_list_get(modules, env, j);
             module_d_qname_l = AXIS2_MODULE_DESC_GET_QNAME(module_desc_l, env);
             if (AXIS2_TRUE == AXIS2_QNAME_EQUALS(module_d_qname, env,
                     module_d_qname_l))

Modified: webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c (original)
+++ webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c Tue Mar  6 01:15:20 2007
@@ -162,14 +162,14 @@
                     function_arr = svc_obj->func_array;
                     if (function_arr)
                     {
-                        size = AXIS2_ARRAY_LIST_SIZE(function_arr, env);
+                        size = axis2_array_list_size(function_arr, env);
                     }
 
                     for (i = 0; i < size; i++)
                     {
                         axis2_char_t *function_name = NULL;
 
-                        function_name = (axis2_char_t *) AXIS2_ARRAY_LIST_GET(
+                        function_name = (axis2_char_t *) axis2_array_list_get(
                                     function_arr, env, i);
                         if (0 == AXIS2_STRCMP(function_name, local_name))
                         {

Modified: webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_request.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_request.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_request.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_request.c Tue Mar  6 01:15:20 2007
@@ -169,7 +169,7 @@
 
         for (i = 0; i < http_hdr_count; i++)
         {
-            AXIS2_ARRAY_LIST_ADD(simple_request_impl->header_group, env,
+            axis2_array_list_add(simple_request_impl->header_group, env,
                     (void *)http_headers[i]);
         }
     }
@@ -245,15 +245,15 @@
     {
         int i = 0;
         axis2_http_header_t *tmp = NULL;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(simple_request_impl->header_group,
+        for (i = 0; i < axis2_array_list_size(simple_request_impl->header_group,
                 env); i++)
         {
-            tmp = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(
+            tmp = (axis2_http_header_t *)axis2_array_list_get(
                         simple_request_impl->header_group, env, i);
             AXIS2_HTTP_HEADER_FREE(tmp, env);
 
         }
-        AXIS2_ARRAY_LIST_FREE(simple_request_impl->header_group, env);
+        axis2_array_list_free(simple_request_impl->header_group, env);
         simple_request_impl->header_group = NULL;
     }
 
@@ -309,7 +309,7 @@
         return AXIS2_FALSE;
     }
 
-    count = AXIS2_ARRAY_LIST_SIZE(simple_request_impl->header_group, env);
+    count = axis2_array_list_size(simple_request_impl->header_group, env);
 
     if (0 == count)
     {
@@ -319,7 +319,7 @@
     for (i = 0; i < count; i++)
     {
         header_name = AXIS2_HTTP_HEADER_GET_NAME((axis2_http_header_t *)
-                AXIS2_ARRAY_LIST_GET(simple_request_impl->header_group,
+                axis2_array_list_get(simple_request_impl->header_group,
                         env, i), env);
         if (0 == AXIS2_STRCASECMP(name, header_name))
             return AXIS2_TRUE;
@@ -361,19 +361,19 @@
     {
         return NULL;
     }
-    if (0 == AXIS2_ARRAY_LIST_SIZE(header_group, env))
+    if (0 == axis2_array_list_size(header_group, env))
     {
         return NULL;
     }
 
 
-    count = AXIS2_ARRAY_LIST_SIZE(header_group, env);
+    count = axis2_array_list_size(header_group, env);
 
 
     for (i = 0; i < count; i++)
     {
 
-        tmp_header = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(header_group,
+        tmp_header = (axis2_http_header_t *)axis2_array_list_get(header_group,
                 env, i);
         tmp_name = AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env);
         if (0 == AXIS2_STRCASECMP(str, tmp_name))
@@ -411,17 +411,17 @@
         return AXIS2_SUCCESS;
     }
 
-    count = AXIS2_ARRAY_LIST_SIZE(header_group, env);
+    count = axis2_array_list_size(header_group, env);
 
     for (i = 0; i < count; i++)
     {
-        tmp_header = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(header_group,
+        tmp_header = (axis2_http_header_t *)axis2_array_list_get(header_group,
                 env, i);
         tmp_name = AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env);
         if (0 == AXIS2_STRCASECMP(str, tmp_name))
         {
             AXIS2_HTTP_HEADER_FREE(tmp_header, env);
-            AXIS2_ARRAY_LIST_REMOVE(header_group, env, i);
+            axis2_array_list_remove(header_group, env, i);
             break;
         }
     }
@@ -445,7 +445,7 @@
     {
         simple_request_impl->header_group = axis2_array_list_create(env, 1);
     }
-    return AXIS2_ARRAY_LIST_ADD(AXIS2_INTF_TO_IMPL(simple_request)->header_group,
+    return axis2_array_list_add(AXIS2_INTF_TO_IMPL(simple_request)->header_group,
             env, header);
 }
 

Modified: webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_response.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_response.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_response.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/common/http_simple_response.c Tue Mar  6 01:15:20 2007
@@ -178,7 +178,7 @@
 
         for (i = 0; i < http_hdr_count; i++)
         {
-            AXIS2_ARRAY_LIST_ADD(simple_response_impl->header_group, env,
+            axis2_array_list_add(simple_response_impl->header_group, env,
                     (void *)http_headers[i]);
         }
     }
@@ -270,17 +270,17 @@
     {
         int i = 0;
         axis2_http_header_t *tmp = NULL;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(simple_response_impl->header_group,
+        for (i = 0; i < axis2_array_list_size(simple_response_impl->header_group,
                 env); i++)
         {
-            tmp = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(
+            tmp = (axis2_http_header_t *)axis2_array_list_get(
                         simple_response_impl->header_group, env, i);
             if (tmp)
             {
                 AXIS2_HTTP_HEADER_FREE(tmp, env);
             }
         }
-        AXIS2_ARRAY_LIST_FREE(simple_response_impl->header_group, env);
+        axis2_array_list_free(simple_response_impl->header_group, env);
         simple_response_impl->header_group = NULL;
     }
     if (simple_response->ops)
@@ -422,16 +422,16 @@
     {
         return NULL;
     }
-    if (0 == AXIS2_ARRAY_LIST_SIZE(header_group, env))
+    if (0 == axis2_array_list_size(header_group, env))
     {
         return NULL;
     }
 
-    count = AXIS2_ARRAY_LIST_SIZE(header_group, env);
+    count = axis2_array_list_size(header_group, env);
 
     for (i = 0; i < count; i++)
     {
-        tmp_header = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(header_group,
+        tmp_header = (axis2_http_header_t *)axis2_array_list_get(header_group,
                 env, i);
         tmp_name = AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env);
         if (0 == AXIS2_STRCASECMP(str, tmp_name))
@@ -470,18 +470,18 @@
         return AXIS2_SUCCESS;
     }
 
-    count = AXIS2_ARRAY_LIST_SIZE(header_group, env);
+    count = axis2_array_list_size(header_group, env);
 
 
     for (i = 0; i < count; i++)
     {
-        tmp_header = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(header_group,
+        tmp_header = (axis2_http_header_t *)axis2_array_list_get(header_group,
                 env, i);
         tmp_name = AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env);
         if (0 == AXIS2_STRCASECMP(str, tmp_name))
         {
             AXIS2_HTTP_HEADER_FREE(tmp_header, env);
-            AXIS2_ARRAY_LIST_REMOVE(header_group, env, i);
+            axis2_array_list_remove(header_group, env, i);
             break;
         }
     }
@@ -510,7 +510,7 @@
     if (NULL == simple_response_impl->header_group)
     {
         simple_response_impl->header_group = axis2_array_list_create(env, 10);
-        AXIS2_ARRAY_LIST_ADD(simple_response_impl->header_group, env, header);
+        axis2_array_list_add(simple_response_impl->header_group, env, header);
         return AXIS2_SUCCESS;
     }
 
@@ -519,21 +519,21 @@
      */
     header_group = AXIS2_INTF_TO_IMPL(simple_response)->header_group;
 
-    count = AXIS2_ARRAY_LIST_SIZE(header_group, env);
+    count = axis2_array_list_size(header_group, env);
     for (i = 0; i < count; i++)
     {
-        tmp_header = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(header_group,
+        tmp_header = (axis2_http_header_t *)axis2_array_list_get(header_group,
                 env, i);
         tmp_name = AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env);
         if (0 == AXIS2_STRCASECMP(AXIS2_HTTP_HEADER_GET_NAME(header, env),
                 tmp_name))
         {
             AXIS2_HTTP_HEADER_FREE(tmp_header, env);
-            AXIS2_ARRAY_LIST_REMOVE(header_group, env, i);
+            axis2_array_list_remove(header_group, env, i);
             break;
         }
     }
-    AXIS2_ARRAY_LIST_ADD(simple_response_impl->header_group, env,
+    axis2_array_list_add(simple_response_impl->header_group, env,
             (void *)header);
     return AXIS2_SUCCESS;
 }
@@ -716,7 +716,7 @@
     {
         return AXIS2_FALSE;
     }
-    count = AXIS2_ARRAY_LIST_SIZE(simple_response_impl->header_group, env);
+    count = axis2_array_list_size(simple_response_impl->header_group, env);
     if (0 == count)
     {
         return AXIS2_FALSE;
@@ -725,7 +725,7 @@
     for (i = 0; i < count; i++)
     {
         header_name = AXIS2_HTTP_HEADER_GET_NAME((axis2_http_header_t *)
-                AXIS2_ARRAY_LIST_GET(simple_response_impl->header_group,
+                axis2_array_list_get(simple_response_impl->header_group,
                         env, i), env);
         if (0 == AXIS2_STRCASECMP(name, header_name))
             return AXIS2_TRUE;

Modified: webservices/axis2/trunk/c/modules/core/transport/http/common/http_worker.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/common/http_worker.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/common/http_worker.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/common/http_worker.c Tue Mar  6 01:15:20 2007
@@ -569,7 +569,7 @@
     {
         return NULL;
     }
-    hdr_count = AXIS2_ARRAY_LIST_SIZE(header_list, env);
+    hdr_count = axis2_array_list_size(header_list, env);
     if (0 == hdr_count)
     {
         return NULL;
@@ -578,7 +578,7 @@
     for (i = 0; i < hdr_count; i++)
     {
         axis2_http_header_t *tmp_hdr = NULL;
-        tmp_hdr = AXIS2_ARRAY_LIST_GET(header_list, env, i);
+        tmp_hdr = axis2_array_list_get(header_list, env, i);
         if (NULL == tmp_hdr)
         {
             continue;

Modified: webservices/axis2/trunk/c/modules/core/transport/http/receiver/simple_http_svr_conn.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/receiver/simple_http_svr_conn.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/receiver/simple_http_svr_conn.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/receiver/simple_http_svr_conn.c Tue Mar  6 01:15:20 2007
@@ -519,10 +519,10 @@
 
     if (headers)
     {
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(headers, env); i++)
+        for (i = 0; i < axis2_array_list_size(headers, env); i++)
         {
             axis2_http_header_t *header = NULL;
-            header = (axis2_http_header_t *)AXIS2_ARRAY_LIST_GET(headers, env,
+            header = (axis2_http_header_t *)axis2_array_list_get(headers, env,
                     i);
             if (header)
             {

Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c Tue Mar  6 01:15:20 2007
@@ -386,14 +386,14 @@
     headers = AXIS2_HTTP_SIMPLE_REQUEST_GET_HEADERS(request, env);
     if (headers)
     {
-        int header_count = AXIS2_ARRAY_LIST_SIZE(headers, env);
+        int header_count = axis2_array_list_size(headers, env);
         int i = 0;
         char *str_header2 = NULL;
         for (i = 0; i < header_count; i++)
         {
             axis2_char_t *header_ext_form = NULL;
             axis2_http_header_t *tmp_header = (axis2_http_header_t *)
-                    AXIS2_ARRAY_LIST_GET(headers, env, i);
+                    axis2_array_list_get(headers, env, i);
             if (NULL == tmp_header)
             {
                 continue;

Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/http_sender.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/sender/http_sender.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/sender/http_sender.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/sender/http_sender.c Tue Mar  6 01:15:20 2007
@@ -730,9 +730,9 @@
     {
         return AXIS2_SUCCESS;
     }
-    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(headers, env); i++)
+    for (i = 0; i < axis2_array_list_size(headers, env); i++)
     {
-        axis2_http_header_t *header = AXIS2_ARRAY_LIST_GET(headers, env, i);
+        axis2_http_header_t *header = axis2_array_list_get(headers, env, i);
         axis2_char_t *name = AXIS2_HTTP_HEADER_GET_NAME((axis2_http_header_t *)
 														header, env);
         if (name)
@@ -1161,17 +1161,17 @@
 				memset (encoded_value, 0, strlen (value));
 				encoded_value = axis2_url_encode (env, encoded_value, value, strlen (value));
 
-				AXIS2_ARRAY_LIST_ADD(param_list, env, axis2_strcat(env, name, "=",
+				axis2_array_list_add(param_list, env, axis2_strcat(env, name, "=",
 																   encoded_value, NULL));
 			}
 		}
 	}
-    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(param_list, env); i++)
+    for (i = 0; i < axis2_array_list_size(param_list, env); i++)
     {
         axis2_char_t *tmp_string = NULL;
         axis2_char_t *pair = NULL;
 
-        pair = AXIS2_ARRAY_LIST_GET(param_list, env, i);
+        pair = axis2_array_list_get(param_list, env, i);
 		if(i ==0)
 			tmp_string = AXIS2_STRACAT(param_string, pair, env);
 		else
@@ -1185,7 +1185,7 @@
         AXIS2_FREE(env->allocator, pair);
         param_string = tmp_string;
     }
-    AXIS2_ARRAY_LIST_FREE(param_list, env);
+    axis2_array_list_free(param_list, env);
     return param_string;
 }
 

Modified: webservices/axis2/trunk/c/modules/mod_addr/addr_in_handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/mod_addr/addr_in_handler.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/mod_addr/addr_in_handler.c (original)
+++ webservices/axis2/trunk/c/modules/mod_addr/addr_in_handler.c Tue Mar  6 01:15:20 2007
@@ -185,7 +185,7 @@
             /* extract service group context, if available */
             axis2_addr_in_extract_svc_grp_ctx_id(env, soap_header, msg_ctx);
 
-            AXIS2_ARRAY_LIST_FREE(addr_headers, env);
+            axis2_array_list_free(addr_headers, env);
             return status;
         }
     }
@@ -729,8 +729,8 @@
     sub_codes = axis2_array_list_create(env, 2);
     if (sub_codes)
     {
-        AXIS2_ARRAY_LIST_ADD(sub_codes, env, "wsa:InvalidAddressingHeader");
-        AXIS2_ARRAY_LIST_ADD(sub_codes, env, "wsa:InvalidCardinality");
+        axis2_array_list_add(sub_codes, env, "wsa:InvalidAddressingHeader");
+        axis2_array_list_add(sub_codes, env, "wsa:InvalidCardinality");
     }
 
     envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env,

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?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/modules/mod_addr/addr_out_handler.c (original)
+++ webservices/axis2/trunk/c/modules/mod_addr/addr_out_handler.c Tue Mar  6 01:15:20 2007
@@ -591,7 +591,7 @@
             &header_block_node, addr_ns);
 
     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)
+    if (ref_param_list && axis2_array_list_size(ref_param_list, env) > 0)
     {
         axiom_node_t *reference_node = NULL;
         axiom_element_t *reference_ele = NULL;
@@ -610,9 +610,9 @@
         if (ref_attribute_list)
         {
             int j = 0;
-            for (j = 0; j < AXIS2_ARRAY_LIST_SIZE(ref_attribute_list, env); j++)
+            for (j = 0; j < axis2_array_list_size(ref_attribute_list, env); j++)
             {
-                axiom_attribute_t *attr = (axiom_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)
                 {
                     AXIOM_ELEMENT_ADD_ATTRIBUTE(reference_ele, env, attr, reference_node);
@@ -620,9 +620,9 @@
             }
         }
 
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(ref_param_list, env); i++)
+        for (i = 0; i < axis2_array_list_size(ref_param_list, env); i++)
         {
-            axiom_node_t *ref_node = (axiom_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)
             {
                 AXIOM_NODE_ADD_CHILD(reference_node, env, ref_node);
@@ -632,7 +632,7 @@
     }
 
     meta_data_list = AXIS2_ENDPOINT_REF_GET_METADATA_LIST(endpoint_ref, env);
-    if (meta_data_list && AXIS2_ARRAY_LIST_SIZE(meta_data_list, env) > 0)
+    if (meta_data_list && axis2_array_list_size(meta_data_list, env) > 0)
     {
         axiom_node_t *reference_node = NULL;
         axiom_element_t *reference_ele = NULL;
@@ -654,9 +654,9 @@
         if (meta_attribute_list)
         {
             int j = 0;
-            for (j = 0; j < AXIS2_ARRAY_LIST_SIZE(meta_attribute_list, env); j++)
+            for (j = 0; j < axis2_array_list_size(meta_attribute_list, env); j++)
             {
-                axiom_attribute_t *attr = (axiom_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)
                 {
                     AXIOM_ELEMENT_ADD_ATTRIBUTE(reference_ele, env, attr, reference_node);
@@ -664,9 +664,9 @@
             }
         }
 
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(meta_data_list, env); i ++)
+        for (i = 0; i < axis2_array_list_size(meta_data_list, env); i ++)
         {
-            axiom_node_t *ref_node = (axiom_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)
             {
                 AXIOM_NODE_ADD_CHILD(reference_node, env, ref_node);
@@ -675,12 +675,12 @@
     }
 
     extension_list = AXIS2_ENDPOINT_REF_GET_REF_EXTENSION_LIST(endpoint_ref, env);
-    if (extension_list && AXIS2_ARRAY_LIST_SIZE(extension_list, env) > 0)
+    if (extension_list && axis2_array_list_size(extension_list, env) > 0)
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(extension_list, env); i ++)
+        for (i = 0; i < axis2_array_list_size(extension_list, env); i ++)
         {
-            axiom_node_t *ref_node = (axiom_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)
             {
                 AXIOM_NODE_ADD_CHILD(header_block_node, env, ref_node);

Modified: webservices/axis2/trunk/c/rampart/samples/server/sec_echo/echo_skeleton.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/samples/server/sec_echo/echo_skeleton.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/samples/server/sec_echo/echo_skeleton.c (original)
+++ webservices/axis2/trunk/c/rampart/samples/server/sec_echo/echo_skeleton.c Tue Mar  6 01:15:20 2007
@@ -73,7 +73,7 @@
     /* Add the implemented operation names of the service to
      * the array list of functions 
      */
-    AXIS2_ARRAY_LIST_ADD(svc_skeleton->func_array, env, "echoString");
+    axis2_array_list_add(svc_skeleton->func_array, env, "echoString");
     /* Any initialization stuff of echo service should go here */
     return AXIS2_SUCCESS;
 }
@@ -122,7 +122,7 @@
     /* Free the function array */
     if (svc_skeleton->func_array)
     {
-        AXIS2_ARRAY_LIST_FREE(svc_skeleton->func_array, env);
+        axis2_array_list_free(svc_skeleton->func_array, env);
         svc_skeleton->func_array = NULL;
     }
 

Modified: webservices/axis2/trunk/c/rampart/src/handlers/rampart_in_handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/handlers/rampart_in_handler.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/handlers/rampart_in_handler.c (original)
+++ webservices/axis2/trunk/c/rampart/src/handlers/rampart_in_handler.c Tue Mar  6 01:15:20 2007
@@ -201,13 +201,13 @@
                 if (action_list)
                 {
 
-                    if (AXIS2_ARRAY_LIST_IS_EMPTY(action_list, env))
+                    if (axis2_array_list_is_empty(action_list, env))
                     {
                         AXIS2_LOG_INFO(env->log, 
 						"[rampart][rampart_in_handler] No actions defined.");
                     }
 
-                    param_action = (axis2_param_t*) AXIS2_ARRAY_LIST_GET(action_list,
+                    param_action = (axis2_param_t*) axis2_array_list_get(action_list,
 						env, 0);
 
                     if (param_action)

Modified: webservices/axis2/trunk/c/rampart/src/omxmlsec/c14n/c14n.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/omxmlsec/c14n/c14n.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/omxmlsec/c14n/c14n.c (original)
+++ webservices/axis2/trunk/c/rampart/src/omxmlsec/c14n/c14n.c Tue Mar  6 01:15:20 2007
@@ -1404,7 +1404,7 @@
 {
     axis2_bool_t vu = c14n_ns_visibly_utilized(ele, node, ns, ctx);
 
-    if (vu || (ctx->ns_prefixes && AXIS2_ARRAY_LIST_CONTAINS(
+    if (vu || (ctx->ns_prefixes && axis2_array_list_contains(
                 (axis2_array_list_t*)(ctx->ns_prefixes), ctx->env, 
                 (void*)(AXIOM_NAMESPACE_GET_PREFIX((axiom_namespace_t*)ns,
                         ctx->env)))))

Modified: webservices/axis2/trunk/c/rampart/src/omxmlsec/tokens/token_reference_list.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/omxmlsec/tokens/token_reference_list.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/omxmlsec/tokens/token_reference_list.c (original)
+++ webservices/axis2/trunk/c/rampart/src/omxmlsec/tokens/token_reference_list.c Tue Mar  6 01:15:20 2007
@@ -60,12 +60,12 @@
     if(!ref_list_node) {return AXIS2_FAILURE;}
 
     /*Build the list*/
-    for(i=0 ; i < AXIS2_ARRAY_LIST_SIZE(id_list, env); i++){ 
+    for(i=0 ; i < axis2_array_list_size(id_list, env); i++){ 
         axiom_node_t *data_ref_node = NULL;
         axis2_char_t *id = NULL;
         
         /*We need to prepend # to the id in the list to create the reference*/
-        id = AXIS2_STRACAT("#",(axis2_char_t*)AXIS2_ARRAY_LIST_GET(id_list, env, i), env);
+        id = AXIS2_STRACAT("#",(axis2_char_t*)axis2_array_list_get(id_list, env, i), env);
         data_ref_node = oxs_token_build_data_reference_element(env, ref_list_node, id);
 
         if(!data_ref_node) {return AXIS2_FAILURE;}
@@ -112,7 +112,7 @@
         dref_node = AXIOM_CHILDREN_QNAME_ITERATOR_NEXT(iter, env);
         dref_val = oxs_token_get_data_reference(env, dref_node);
 
-        AXIS2_ARRAY_LIST_ADD(list, env, dref_val);
+        axis2_array_list_add(list, env, dref_val);
     }
 
     return list;

Modified: webservices/axis2/trunk/c/rampart/src/omxmlsec/xml_signature.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/omxmlsec/xml_signature.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/omxmlsec/xml_signature.c (original)
+++ webservices/axis2/trunk/c/rampart/src/omxmlsec/xml_signature.c Tue Mar  6 01:15:20 2007
@@ -93,7 +93,7 @@
     int i = 0;
     
     printf("oxs_xml_sig_transform_n_digest\n %s", axiom_node_to_string(node, env));
-    if((transforms) && (0 < AXIS2_ARRAY_LIST_SIZE(transforms, env))){
+    if((transforms) && (0 < axis2_array_list_size(transforms, env))){
         oxs_tr_dtype_t output_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;/*This will always be the current dtype*/
         void *tr_output = NULL;
         output_dtype = OXS_TRANSFORM_TYPE_NODE; /*We always begin with a node*/
@@ -101,7 +101,7 @@
         tr_output = node; /*The first transformation is applied to the node*/
 
         /*LOOP: Apply transforms. For example exclusive C14N*/
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(transforms, env); i++){
+        for (i = 0; i < axis2_array_list_size(transforms, env); i++){
             oxs_transform_t *tr = NULL;
             oxs_transform_tr_func tr_func = NULL;
             oxs_tr_dtype_t input_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;
@@ -109,7 +109,7 @@
             axis2_char_t *tr_id = NULL;
 
             /*Get the ith transform*/
-            tr = (oxs_transform_t*)AXIS2_ARRAY_LIST_GET(transforms, env, i);
+            tr = (oxs_transform_t*)axis2_array_list_get(transforms, env, i);
             tr_id = oxs_transform_get_id(tr, env);
             tr_func = oxs_transform_get_transform_function(tr, env);
             input_dtype = oxs_transform_get_input_data_type(tr, env);
@@ -197,16 +197,16 @@
     digest = oxs_xml_sig_transform_n_digest(env, node, transforms, digest_mtd);
     
     /*Build ds:Transforms node and its children*/
-    if((transforms) && (0 < AXIS2_ARRAY_LIST_SIZE(transforms, env))){
+    if((transforms) && (0 < axis2_array_list_size(transforms, env))){
         axiom_node_t *transforms_node = NULL;
 
         transforms_node = oxs_token_build_transforms_element(env, reference_node);
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(transforms, env); i++){
+        for (i = 0; i < axis2_array_list_size(transforms, env); i++){
             oxs_transform_t *tr = NULL;
             axis2_char_t *tr_id = NULL;    
 
             /*Get the ith transform*/
-            tr = (oxs_transform_t*)AXIS2_ARRAY_LIST_GET(transforms, env, i);
+            tr = (oxs_transform_t*)axis2_array_list_get(transforms, env, i);
             tr_id = oxs_transform_get_id(tr, env);
             oxs_token_build_transform_element(env, transforms_node, tr_id);
         }
@@ -295,7 +295,7 @@
     sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx , env);
 
     /*For each and every signature part in sig ctx,*/
-    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(sign_parts, env); i++){
+    for (i = 0; i < axis2_array_list_size(sign_parts, env); i++){
         oxs_sign_part_t *sign_part =  NULL;
 
         /*TODO Get ith sign_part*/
@@ -376,7 +376,7 @@
                     return AXIS2_FAILURE;
                 }
                 /*Add the transform to the list*/
-                AXIS2_ARRAY_LIST_ADD(tr_list, env, tr);
+                axis2_array_list_add(tr_list, env, tr);
             }else{
                 /*<ds:Transforms> cant have any other element*/
                 oxs_error(env, ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"<ds:Transforms> cannot have node %s ", node_name );        
@@ -560,7 +560,7 @@
     /*Get the sign_part list*/
     sign_parts =  oxs_sign_ctx_get_sign_parts(sign_ctx, env);
     /*For each and every signature part in sig ctx,*/
-    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(sign_parts, env); i++){
+    for (i = 0; i < axis2_array_list_size(sign_parts, env); i++){
         oxs_sign_part_t *sign_part =  NULL;
 
         /*Get ith sign_part*/

Modified: webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_elements.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_elements.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_elements.c (original)
+++ webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_elements.c Tue Mar  6 01:15:20 2007
@@ -70,18 +70,18 @@
         if(signed_encrypted_elements->xpath_expressions)
         {
             int i = 0;
-            for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(signed_encrypted_elements->xpath_expressions,
+            for (i = 0; i < axis2_array_list_size(signed_encrypted_elements->xpath_expressions,
                 env); i++)
             {
                 axis2_char_t *expression = NULL;
                 expression = (axis2_char_t *)
-                    AXIS2_ARRAY_LIST_GET(signed_encrypted_elements->xpath_expressions,env, i);
+                    axis2_array_list_get(signed_encrypted_elements->xpath_expressions,env, i);
                 if (expression)
                     AXIS2_FREE(env->allocator,expression);
 
                 expression = NULL;
             }
-            AXIS2_ARRAY_LIST_FREE(signed_encrypted_elements->xpath_expressions, env);
+            axis2_array_list_free(signed_encrypted_elements->xpath_expressions, env);
             signed_encrypted_elements->xpath_expressions = NULL;
 
         }
@@ -133,7 +133,7 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error,expression,AXIS2_FAILURE);
 
-    AXIS2_ARRAY_LIST_ADD(signed_encrypted_elements->xpath_expressions,env,expression);    
+    axis2_array_list_add(signed_encrypted_elements->xpath_expressions,env,expression);    
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_parts.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_parts.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_parts.c (original)
+++ webservices/axis2/trunk/c/rampart/src/secpolicy/model/signed_encrypted_parts.c Tue Mar  6 01:15:20 2007
@@ -68,18 +68,18 @@
         if(signed_encrypted_parts->headers)
         {
             int i = 0;
-            for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(signed_encrypted_parts->headers,
+            for (i = 0; i < axis2_array_list_size(signed_encrypted_parts->headers,
                 env); i++)
             {
                 rp_header_t *header = NULL;
                 header = (rp_header_t *)
-                    AXIS2_ARRAY_LIST_GET(signed_encrypted_parts->headers,env, i);
+                    axis2_array_list_get(signed_encrypted_parts->headers,env, i);
                 if (header)
                     rp_header_free(header, env);
 
                 header = NULL;
             }
-            AXIS2_ARRAY_LIST_FREE(signed_encrypted_parts->headers, env);
+            axis2_array_list_free(signed_encrypted_parts->headers, env);
             signed_encrypted_parts->headers = NULL;
 
         }
@@ -152,7 +152,7 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error,header,AXIS2_FAILURE);
         
-    AXIS2_ARRAY_LIST_ADD(signed_encrypted_parts->headers,env,header);    
+    axis2_array_list_add(signed_encrypted_parts->headers,env,header);    
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/rampart/src/secpolicy/model/supporting_tokens.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/secpolicy/model/supporting_tokens.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/secpolicy/model/supporting_tokens.c (original)
+++ webservices/axis2/trunk/c/rampart/src/secpolicy/model/supporting_tokens.c Tue Mar  6 01:15:20 2007
@@ -75,18 +75,18 @@
         if(supporting_tokens->tokens)
         {
             int i = 0;
-            for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(supporting_tokens->tokens,
+            for (i = 0; i < axis2_array_list_size(supporting_tokens->tokens,
                 env); i++)
             {
                 rp_property_t *token = NULL;
                 token = (rp_property_t *)
-                    AXIS2_ARRAY_LIST_GET(supporting_tokens->tokens,env, i);
+                    axis2_array_list_get(supporting_tokens->tokens,env, i);
                 if (token)
                     rp_property_free(token, env);
 
                 token = NULL;
             }
-            AXIS2_ARRAY_LIST_FREE(supporting_tokens->tokens, env);
+            axis2_array_list_free(supporting_tokens->tokens, env);
             supporting_tokens->tokens = NULL;
 
         }
@@ -142,7 +142,7 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error,token,AXIS2_FAILURE);
     
-    AXIS2_ARRAY_LIST_ADD(supporting_tokens->tokens,env,token);
+    axis2_array_list_add(supporting_tokens->tokens,env,token);
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/rampart/src/util/rampart_context.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/util/rampart_context.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/util/rampart_context.c (original)
+++ webservices/axis2/trunk/c/rampart/src/util/rampart_context.c Tue Mar  6 01:15:20 2007
@@ -678,11 +678,11 @@
     else
     {
         int i = 0;
-        for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(array_list,env); i++)
+        for (i = 0; i < axis2_array_list_size(array_list,env); i++)
         {
             rp_property_t *token = NULL;
             token = (rp_property_t *)
-                   AXIS2_ARRAY_LIST_GET(array_list,env, i);
+                   axis2_array_list_get(array_list,env, i);
             if (token)
             {
                 if(rp_property_get_type(token,env)==RP_TOKEN_USERNAME)
@@ -732,17 +732,17 @@
         if(!soap_header_blocks)
             return AXIS2_FAILURE;
 
-        for(i=0 ; i<AXIS2_ARRAY_LIST_SIZE(soap_header_blocks,env); i++)
+        for(i=0 ; i<axis2_array_list_size(soap_header_blocks,env); i++)
         {
             axiom_soap_header_block_t *header_block = NULL;
             axiom_node_t *node = NULL;
-            header_block = (axiom_soap_header_block_t *)AXIS2_ARRAY_LIST_GET(soap_header_blocks,env,i);
+            header_block = (axiom_soap_header_block_t *)axis2_array_list_get(soap_header_blocks,env,i);
             if(header_block)
             {
                 node = AXIOM_SOAP_HEADER_BLOCK_GET_BASE_NODE(header_block,env);
                 if(node)
                 {    
-                    AXIS2_ARRAY_LIST_ADD(nodes_to_encrypt,env,node);
+                    axis2_array_list_add(nodes_to_encrypt,env,node);
                     return AXIS2_SUCCESS;
                 }
             }
@@ -776,7 +776,7 @@
                         namespace_uri = AXIOM_NAMESPACE_GET_URI(ns, env);
                         if (AXIS2_STRCMP(namespace_uri,namespace) == 0)
                         {
-                            AXIS2_ARRAY_LIST_ADD(nodes_to_encrypt,env,ret_node);
+                            axis2_array_list_add(nodes_to_encrypt,env,ret_node);
                             return AXIS2_SUCCESS;
                         }
 
@@ -1030,7 +1030,7 @@
         return AXIS2_FAILURE;
     
     parts = rp_signed_encrypted_parts_get_headers(encrypted_parts,env);
-    if(!parts || (AXIS2_ARRAY_LIST_SIZE(parts,env)==0))
+    if(!parts || (axis2_array_list_size(parts,env)==0))
     {
         if(rp_signed_encrypted_parts_get_body(encrypted_parts,env))
         {
@@ -1042,7 +1042,7 @@
             body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, env);
             body_node = AXIOM_SOAP_BODY_GET_BASE_NODE(body, env);
             body_child_node = AXIOM_NODE_GET_FIRST_CHILD(body_node, env);
-            AXIS2_ARRAY_LIST_ADD(nodes_to_encrypt, env, body_child_node);
+            axis2_array_list_add(nodes_to_encrypt, env, body_child_node);
             return AXIS2_SUCCESS;
         }
         else
@@ -1054,10 +1054,10 @@
     else
     {
         int i = 0;
-        for(i=0; i<AXIS2_ARRAY_LIST_SIZE(parts,env); i++)
+        for(i=0; i<axis2_array_list_size(parts,env); i++)
         {
             rp_header_t *header = NULL;
-            header = (rp_header_t *)AXIS2_ARRAY_LIST_GET(parts,env,i);
+            header = (rp_header_t *)axis2_array_list_get(parts,env,i);
             if(header)
             {
                 status = rampart_context_set_nodes_to_encrypt(header,env,soap_envelope,nodes_to_encrypt);
@@ -1076,7 +1076,7 @@
             body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, env);
             body_node = AXIOM_SOAP_BODY_GET_BASE_NODE(body, env);
             body_child_node = AXIOM_NODE_GET_FIRST_CHILD(body_node, env);
-            AXIS2_ARRAY_LIST_ADD(nodes_to_encrypt, env, body_child_node);
+            axis2_array_list_add(nodes_to_encrypt, env, body_child_node);
             return AXIS2_SUCCESS;
         }
         
@@ -1098,7 +1098,7 @@
         return AXIS2_FALSE;
     
     parts = rp_signed_encrypted_parts_get_headers(encrypted_parts,env);
-    if(!parts || (AXIS2_ARRAY_LIST_SIZE(parts,env)==0))
+    if(!parts || (axis2_array_list_size(parts,env)==0))
     {
         if(rp_signed_encrypted_parts_get_body(encrypted_parts,env))
             return AXIS2_TRUE;       

Modified: webservices/axis2/trunk/c/rampart/src/util/rampart_encryption.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/rampart/src/util/rampart_encryption.c?view=diff&rev=515039&r1=515038&r2=515039
==============================================================================
--- webservices/axis2/trunk/c/rampart/src/util/rampart_encryption.c (original)
+++ webservices/axis2/trunk/c/rampart/src/util/rampart_encryption.c Tue Mar  6 01:15:20 2007
@@ -66,7 +66,7 @@
         body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, env);
         body_node = AXIOM_SOAP_BODY_GET_BASE_NODE(body, env);
         body_child_node = AXIOM_NODE_GET_FIRST_CHILD(body_node, env);
-        AXIS2_ARRAY_LIST_ADD(nodes_to_encrypt, env, body_child_node);
+        axis2_array_list_add(nodes_to_encrypt, env, body_child_node);
         return AXIS2_SUCCESS;
     }else if(0 == AXIS2_STRCMP(encryption_parts, "Header")){
         AXIS2_LOG_INFO(env->log, "[rampart][rampart_encryption] We do not encrypt SOAP headers");
@@ -81,15 +81,15 @@
         AXIS2_LOG_INFO(env->log, "[rampart][rampart_encryption] EncryptionParts specified = %s", encryption_parts);
         envelope_node = AXIOM_SOAP_ENVELOPE_GET_BASE_NODE(soap_envelope, env);
         str_list = axis2_tokenize(env, encryption_parts, ' ');
-        size = AXIS2_ARRAY_LIST_SIZE(str_list, env);
+        size = axis2_array_list_size(str_list, env);
         for(i=0 ; i < size ; i++ ){
-            local_name = AXIS2_ARRAY_LIST_GET(str_list, env, i);
+            local_name = axis2_array_list_get(str_list, env, i);
             if(0 == AXIS2_STRCMP(local_name, "Security")){
                 AXIS2_LOG_INFO(env->log, "[rampart][rampart_encryption] We do not encrypt %s", local_name);
                 continue;
             }
             node = oxs_axiom_get_node_by_local_name(env, envelope_node, local_name);
-            AXIS2_ARRAY_LIST_ADD(nodes_to_encrypt, env, node);
+            axis2_array_list_add(nodes_to_encrypt, env, node);
         }
         return AXIS2_SUCCESS;
     }
@@ -133,7 +133,7 @@
 
     status = rampart_context_get_nodes_to_encrypt(rampart_context,env,soap_envelope,nodes_to_encrypt);
 
-    if((status!=AXIS2_SUCCESS)||(AXIS2_ARRAY_LIST_SIZE(nodes_to_encrypt,env)==0))
+    if((status!=AXIS2_SUCCESS)||(axis2_array_list_size(nodes_to_encrypt,env)==0))
     {
         AXIS2_LOG_INFO(env->log, "[rampart][rampart_encryption] No parts specified or specified parts can't be found for encryprion.");
         return AXIS2_SUCCESS;
@@ -174,7 +174,7 @@
     id_list = axis2_array_list_create(env, 5);
 
     /*Repeat until all encryption parts are encrypted*/
-    for(i=0 ; i < AXIS2_ARRAY_LIST_SIZE(nodes_to_encrypt, env); i++){
+    for(i=0 ; i < axis2_array_list_size(nodes_to_encrypt, env); i++){
         axiom_node_t *node_to_enc = NULL;
         axiom_node_t *parent_of_node_to_enc = NULL;
         axiom_node_t *enc_data_node = NULL;
@@ -183,7 +183,7 @@
         axis2_status_t enc_status = AXIS2_FAILURE;
         
         /*Get the node to be encrypted*/
-        node_to_enc = (axiom_node_t *)AXIS2_ARRAY_LIST_GET(nodes_to_encrypt, env, i);
+        node_to_enc = (axiom_node_t *)axis2_array_list_get(nodes_to_encrypt, env, i);
         if(!node_to_enc){
             return AXIS2_FAILURE;
         }
@@ -198,7 +198,7 @@
         id = oxs_util_generate_id(env,(axis2_char_t*)OXS_ENCDATA_ID);
         enc_data_node = oxs_token_build_encrypted_data_element(env, parent_of_node_to_enc, OXS_TYPE_ENC_ELEMENT, id );
         enc_status = oxs_xml_enc_encrypt_node(env, enc_ctx, node_to_enc, &enc_data_node);
-        AXIS2_ARRAY_LIST_ADD(id_list, env, id);
+        axis2_array_list_add(id_list, env, id);
         if(AXIS2_FAILURE == enc_status){
             return AXIS2_FAILURE;
         }



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


Mime
View raw message