You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sh...@apache.org on 2009/08/18 12:15:53 UTC

svn commit: r805347 [9/31] - in /webservices/axis2/trunk/c/src: core/addr/ core/clientapi/ core/context/ core/deployment/ core/description/ core/engine/ core/phaseresolver/ core/receivers/ core/transport/amqp/receiver/ core/transport/amqp/receiver/qpid...

Modified: webservices/axis2/trunk/c/src/core/deployment/repos_listener.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/deployment/repos_listener.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/deployment/repos_listener.c (original)
+++ webservices/axis2/trunk/c/src/core/deployment/repos_listener.c Tue Aug 18 10:15:49 2009
@@ -35,24 +35,23 @@
     axis2_conf_t *conf;
 };
 
-static axis2_status_t axis2_repos_listener_search(
+static axis2_status_t
+axis2_repos_listener_search(
     axis2_repos_listener_t * repos_listener,
     const axutil_env_t * env,
     axis2_char_t * folder_name,
     int type);
 
-
 AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL
 axis2_repos_listener_create(
     const axutil_env_t * env)
 {
     axis2_repos_listener_t *repos_listener = NULL;
 
-    repos_listener = (axis2_repos_listener_t *)
-        AXIS2_MALLOC(env->allocator,
-                     sizeof (axis2_repos_listener_t));
+    repos_listener = (axis2_repos_listener_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(axis2_repos_listener_t));
 
-    if (!repos_listener)
+    if(!repos_listener)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -87,19 +86,19 @@
     axis2_conf_t *conf;
     axis2_bool_t file_flag;
 
-    repos_listener = (axis2_repos_listener_t *) axis2_repos_listener_create(env);
+    repos_listener = (axis2_repos_listener_t *)axis2_repos_listener_create(env);
 
-    if (!repos_listener)
+    if(!repos_listener)
     {
         return NULL;
     }
 
-    file_flag = axis2_dep_engine_get_file_flag (dep_engine, env);
+    file_flag = axis2_dep_engine_get_file_flag(dep_engine, env);
 
-    if (!file_flag)
+    if(!file_flag)
     {
         repos_listener->folder_name = axutil_strdup(env, folder_name);
-        if (!repos_listener->folder_name)
+        if(!repos_listener->folder_name)
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return NULL;
@@ -107,52 +106,51 @@
     }
 
     repos_listener->info_list = axis2_ws_info_list_create_with_dep_engine(env, dep_engine);
-    if (!repos_listener->info_list)
+    if(!repos_listener->info_list)
     {
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating ws info list failed");
         return NULL;
     }
-    
+
     /* Here dep_engine's conf will set to repo_listner. Then we could get
      * details of the axis2.xml through axis2 configuration. 
      */
 
-    conf = axis2_dep_engine_get_axis_conf (dep_engine, env);
-    if (!conf)
+    conf = axis2_dep_engine_get_axis_conf(dep_engine, env);
+    if(!conf)
     {
-        AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, 
-                "Deployment engines axis2 configuration not available");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Deployment engines axis2 configuration not available");
 
         return NULL;
     }
-    axis2_repos_listener_set_conf (repos_listener, env, conf);
+    axis2_repos_listener_set_conf(repos_listener, env, conf);
 
     status = axis2_repos_listener_init(repos_listener, env);
-    if (AXIS2_SUCCESS != status)
+    if(AXIS2_SUCCESS != status)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOS_LISTENER_INIT_FAILED, AXIS2_FAILURE);
-        AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Repository listener initialization failed");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository listener initialization failed");
 
         return NULL;
     }
     return repos_listener;
 }
 
-
 AXIS2_EXTERN void AXIS2_CALL
 axis2_repos_listener_free(
     axis2_repos_listener_t * repos_listener,
     const axutil_env_t * env)
 {
-    if (!repos_listener)
+    if(!repos_listener)
         return;
 
-    if (repos_listener->folder_name)
+    if(repos_listener->folder_name)
     {
         AXIS2_FREE(env->allocator, repos_listener->folder_name);
     }
 
-    if (repos_listener->info_list)
+    if(repos_listener->info_list)
     {
         axis2_ws_info_list_free(repos_listener->info_list, env);
     }
@@ -176,20 +174,20 @@
     axutil_param_t *module_param;
     axis2_char_t *module_dir;
 
-    AXIS2_PARAM_CHECK (env->error, repos_listener, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE);
 
-    conf = axis2_repos_listener_get_conf (repos_listener, env);
+    conf = axis2_repos_listener_get_conf(repos_listener, env);
 
     /* Configuration  is needed only to decide we are using axis2.xml. Other
      * case we don't need. Hence even if conf is NULL we can continue.
      */
 
-    if (conf)
+    if(conf)
     {
-        axis2_flag = axis2_conf_get_axis2_flag (conf, env);
+        axis2_flag = axis2_conf_get_axis2_flag(conf, env);
     }
 
-    if (!axis2_flag)
+    if(!axis2_flag)
     {
 
         temp_path = axutil_stracat(env, repos_listener->folder_name, AXIS2_PATH_SEP_STR);
@@ -198,16 +196,16 @@
     }
     else
     {
-        module_param = axis2_conf_get_param (conf, env, AXIS2_MODULE_DIR);
-        if (module_param)
+        module_param = axis2_conf_get_param(conf, env, AXIS2_MODULE_DIR);
+        if(module_param)
         {
-            module_dir = (axis2_char_t *)axutil_param_get_value (module_param, env);
-            module_path = axutil_strdup (env, module_dir);
+            module_dir = (axis2_char_t *)axutil_param_get_value(module_param, env);
+            module_path = axutil_strdup(env, module_dir);
         }
         else
         {
-            AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "While creating axis2 configuration using "\
-                    "axis2.xml, modulesDir  parameter not available.");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "While creating axis2 configuration using "
+                "axis2.xml, modulesDir  parameter not available.");
         }
 
     }
@@ -234,40 +232,36 @@
     axutil_param_t *svc_param;
     axis2_char_t *svc_dir;
 
-    AXIS2_PARAM_CHECK (env->error, repos_listener, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE);
 
-    conf = axis2_repos_listener_get_conf (repos_listener, env);
+    conf = axis2_repos_listener_get_conf(repos_listener, env);
 
-    if (conf)
-        axis2_flag = axis2_conf_get_axis2_flag (conf, env);
+    if(conf)
+        axis2_flag = axis2_conf_get_axis2_flag(conf, env);
 
-    if (!axis2_flag)
+    if(!axis2_flag)
     {
-        temp_path =
-            axutil_stracat(env, repos_listener->folder_name, 
-                           AXIS2_PATH_SEP_STR);
+        temp_path = axutil_stracat(env, repos_listener->folder_name, AXIS2_PATH_SEP_STR);
         svc_path = axutil_stracat(env, temp_path, AXIS2_SVC_PATH);
         AXIS2_FREE(env->allocator, temp_path);
     }
     else
     {
-        svc_param = axis2_conf_get_param (conf, env, AXIS2_SERVICE_DIR);
-        if (svc_param)
+        svc_param = axis2_conf_get_param(conf, env, AXIS2_SERVICE_DIR);
+        if(svc_param)
         {
-            svc_dir = axutil_param_get_value (svc_param, env);
-            svc_path = axutil_strdup (env, svc_dir);
+            svc_dir = axutil_param_get_value(svc_param, env);
+            svc_path = axutil_strdup(env, svc_dir);
         }
         else
         {
-            AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, 
-                "While creating axis2 configuration using axis2.xml, servicesDir"\
-                " parameter not available.");
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "While creating axis2 configuration using axis2.xml, servicesDir"
+                    " parameter not available.");
         }
     }
 
-    status =
-        axis2_repos_listener_search(repos_listener, 
-                                    env, svc_path, AXIS2_SVC);
+    status = axis2_repos_listener_search(repos_listener, env, svc_path, AXIS2_SVC);
     AXIS2_FREE(env->allocator, svc_path);
     return status;
 }
@@ -277,7 +271,7 @@
     axis2_repos_listener_t * repos_listener,
     const axutil_env_t * env)
 {
-    AXIS2_PARAM_CHECK (env->error, repos_listener, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE);
     return axis2_ws_info_list_update(repos_listener->info_list, env);
 }
 
@@ -288,10 +282,10 @@
 {
     axis2_status_t status = AXIS2_FAILURE;
 
-    AXIS2_PARAM_CHECK (env->error, repos_listener, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE);
 
     status = axis2_ws_info_list_init(repos_listener->info_list, env);
-    if (AXIS2_SUCCESS != status)
+    if(AXIS2_SUCCESS != status)
     {
         return status;
     }
@@ -324,41 +318,37 @@
     axutil_array_list_t *current_info_list = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
-    AXIS2_PARAM_CHECK (env->error, repos_listener, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, folder_name, AXIS2_FAILURE);
-    current_info_list = axutil_dir_handler_list_service_or_module_dirs(env,
-                                                                       folder_name);
-    if (!current_info_list)
+    current_info_list = axutil_dir_handler_list_service_or_module_dirs(env, folder_name);
+    if(!current_info_list)
     {
         axis2_status_t status_code = AXIS2_FAILURE;
 
         status_code = AXIS2_ERROR_GET_STATUS_CODE(env->error);
-        if (AXIS2_SUCCESS != status)
+        if(AXIS2_SUCCESS != status)
         {
             return status;
         }
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No %s in the folder.",
-                        folder_name);
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No %s in the folder.", folder_name);
         return AXIS2_SUCCESS;
     }
 
     size = axutil_array_list_size(current_info_list, env);
 
-    for (i = 0; i < size; i++)  /* Loop until empty */
+    for(i = 0; i < size; i++) /* Loop until empty */
     {
         axutil_file_t *file = NULL;
         file = axutil_array_list_get(current_info_list, env, i);
-        status =
-            axis2_ws_info_list_add_ws_info_item(repos_listener->info_list, env,
-                                                file, type);
-        if (AXIS2_SUCCESS != status)
+        status = axis2_ws_info_list_add_ws_info_item(repos_listener->info_list, env, file, type);
+        if(AXIS2_SUCCESS != status)
         {
             int size_j = 0;
             int j = 0;
-            axis2_char_t* file_name = axutil_file_get_name(file ,env);
+            axis2_char_t* file_name = axutil_file_get_name(file, env);
 
             size_j = axutil_array_list_size(current_info_list, env);
-            for (j = 0; j < size_j; j++)
+            for(j = 0; j < size_j; j++)
             {
                 axutil_file_t *del_file = NULL;
 
@@ -367,13 +357,13 @@
             }
             axutil_array_list_free(current_info_list, env);
             current_info_list = NULL;
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Adding file %s to ws info list failed", file_name);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding file %s to ws info list failed",
+                file_name);
             return status;
         }
     }
 
-    for (i = 0; i < size; i++)
+    for(i = 0; i < size; i++)
     {
         axutil_file_t *del_file = NULL;
 
@@ -385,26 +375,24 @@
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_repos_listener_set_conf(
-    axis2_repos_listener_t *repo_listener,        
+    axis2_repos_listener_t *repo_listener,
     const axutil_env_t * env,
     axis2_conf_t *conf)
 {
-    AXIS2_PARAM_CHECK (env->error, repo_listener, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK (env->error, conf, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, repo_listener, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
     repo_listener->conf = conf;
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN axis2_conf_t *AXIS2_CALL
-axis2_repos_listener_get_conf (
-    axis2_repos_listener_t *repo_listener,        
+axis2_repos_listener_get_conf(
+    axis2_repos_listener_t *repo_listener,
     const axutil_env_t * env)
 {
-    AXIS2_PARAM_CHECK (env->error, repo_listener, NULL);
+    AXIS2_PARAM_CHECK(env->error, repo_listener, NULL);
     return repo_listener->conf;
 }
 

Modified: webservices/axis2/trunk/c/src/core/deployment/svc_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/deployment/svc_builder.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/deployment/svc_builder.c (original)
+++ webservices/axis2/trunk/c/src/core/deployment/svc_builder.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -28,12 +27,14 @@
     struct axis2_desc_builder *desc_builder;
 };
 
-static axutil_array_list_t *axis2_svc_builder_process_ops(
+static axutil_array_list_t *
+axis2_svc_builder_process_ops(
     axis2_svc_builder_t * svc_builder,
     const axutil_env_t * env,
     axiom_children_qname_iterator_t * op_itr);
 
-static void axis2_svc_builder_process_msgs(
+static void
+axis2_svc_builder_process_msgs(
     axis2_svc_builder_t * svc_builder,
     const axutil_env_t * env,
     axiom_children_qname_iterator_t * iterator,
@@ -45,15 +46,12 @@
 {
     axis2_svc_builder_t *svc_builder = NULL;
 
-    svc_builder = (axis2_svc_builder_t *) AXIS2_MALLOC(env->allocator,
-                                                       sizeof
-                                                       (axis2_svc_builder_t));
+    svc_builder = (axis2_svc_builder_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_builder_t));
 
-    if (!svc_builder)
+    if(!svc_builder)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "No memory. Allocation to svc_builder failed");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Allocation to svc_builder failed");
         return NULL;
     }
 
@@ -75,20 +73,18 @@
     AXIS2_PARAM_CHECK(env->error, file_name, NULL);
     AXIS2_PARAM_CHECK(env->error, dep_engine, NULL);
     AXIS2_PARAM_CHECK(env->error, svc, NULL);
-    svc_builder = (axis2_svc_builder_t *) axis2_svc_builder_create(env);
-    if (!svc_builder)
+    svc_builder = (axis2_svc_builder_t *)axis2_svc_builder_create(env);
+    if(!svc_builder)
     {
         return NULL;
     }
-    svc_builder->desc_builder =
-        axis2_desc_builder_create_with_file_and_dep_engine(env, file_name,
-                                                           dep_engine);
-    if (!svc_builder->desc_builder)
+    svc_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, file_name,
+        dep_engine);
+    if(!svc_builder->desc_builder)
     {
         axis2_svc_builder_free(svc_builder, env);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Creating description builder for service builder %s failed", 
-            file_name);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Creating description builder for service builder %s failed", file_name);
         return NULL;
     }
     svc_builder->svc = svc;
@@ -105,17 +101,16 @@
 
     AXIS2_PARAM_CHECK(env->error, dep_engine, NULL);
     AXIS2_PARAM_CHECK(env->error, svc, NULL);
-    svc_builder = (axis2_svc_builder_t *) axis2_svc_builder_create(env);
-    if (!svc_builder)
+    svc_builder = (axis2_svc_builder_t *)axis2_svc_builder_create(env);
+    if(!svc_builder)
     {
         return NULL;
     }
-    svc_builder->desc_builder =
-        axis2_desc_builder_create_with_dep_engine(env, dep_engine);
-    if (!svc_builder->desc_builder)
+    svc_builder->desc_builder = axis2_desc_builder_create_with_dep_engine(env, dep_engine);
+    if(!svc_builder->desc_builder)
     {
         axis2_svc_builder_free(svc_builder, env);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
             "Creating description builder for service builder failed");
         return NULL;
     }
@@ -128,14 +123,14 @@
     axis2_svc_builder_t * svc_builder,
     const axutil_env_t * env)
 {
-    if (svc_builder->desc_builder)
+    if(svc_builder->desc_builder)
     {
         axis2_desc_builder_free(svc_builder->desc_builder, env);
     }
 
     svc_builder->svc = NULL;
 
-    if (svc_builder)
+    if(svc_builder)
     {
         AXIS2_FREE(env->allocator, svc_builder);
     }
@@ -203,14 +198,13 @@
     svc_element = axiom_node_get_data_element(svc_node, env);
     /* Processing service level paramters */
     qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-    if (!qparamst)
+    if(!qparamst)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
         return AXIS2_FAILURE;
     }
-    itr = axiom_element_get_children_with_qname(svc_element, env, qparamst,
-                                                svc_node);
+    itr = axiom_element_get_children_with_qname(svc_element, env, qparamst, svc_node);
     axutil_qname_free(qparamst, env);
     qparamst = NULL;
 
@@ -219,54 +213,46 @@
     desc = axis2_svc_get_base(svc_builder->svc, env);
     policy_include = axis2_desc_get_policy_include(desc, env);
 
-    status = axis2_desc_builder_process_params(svc_builder->desc_builder, env,
-                                               itr,
-                                               axis2_svc_get_param_container
-                                               (svc_builder->svc, env),
-                                               axis2_svc_grp_get_param_container
-                                               (parent, env));
-    if (AXIS2_SUCCESS != status)
+    status = axis2_desc_builder_process_params(svc_builder->desc_builder, env, itr,
+        axis2_svc_get_param_container(svc_builder->svc, env), axis2_svc_grp_get_param_container(
+            parent, env));
+    if(AXIS2_SUCCESS != status)
     {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Processing parameters failed");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing parameters failed");
         return status;
     }
 
     /* process service description */
     qdesc = axutil_qname_create(env, AXIS2_DESCRIPTION, NULL, NULL);
-    desc_element = axiom_element_get_first_child_with_qname(svc_element, env,
-                                                            qdesc, svc_node,
-                                                            &desc_node);
+    desc_element = axiom_element_get_first_child_with_qname(svc_element, env, qdesc, svc_node,
+        &desc_node);
     axutil_qname_free(qdesc, env);
     qdesc = NULL;
-    if (desc_element)
+    if(desc_element)
     {
         axiom_element_t *desc_value_element = NULL;
         axiom_node_t *desc_value_node = NULL;
         axis2_char_t *description_text = NULL;
 
-        desc_value_element = axiom_element_get_first_element(desc_element,
-                                                             env, desc_node,
-                                                             &desc_value_node);
+        desc_value_element = axiom_element_get_first_element(desc_element, env, desc_node,
+            &desc_value_node);
         description_text = axiom_element_get_text(desc_element, env, desc_node);
-        if (description_text)
+        if(description_text)
         {
             axis2_svc_set_svc_desc(svc_builder->svc, env, description_text);
         }
     }
 
     /* wsdl path */
-    wsdl_path_param =
-        axutil_param_container_get_param(axis2_svc_get_param_container
-                                         (svc_builder->svc, env), env,
-                                         AXIS2_SVC_WSDL_PATH);
+    wsdl_path_param = axutil_param_container_get_param(axis2_svc_get_param_container(
+        svc_builder->svc, env), env, AXIS2_SVC_WSDL_PATH);
 
-    if (wsdl_path_param)
+    if(wsdl_path_param)
     {
         wsdl_path = axutil_param_get_value(wsdl_path_param, env);
     }
 
-    if (wsdl_path)
+    if(wsdl_path)
     {
         axis2_svc_set_svc_wsdl_path(svc_builder->svc, env, wsdl_path);
     }
@@ -281,47 +267,38 @@
      * container taken from svc 
      */
     dll_desc = axutil_dll_desc_create(env);
-    impl_info_param =
-        axutil_param_container_get_param(axis2_svc_get_param_container
-                                         (svc_builder->svc, env), env,
-                                         AXIS2_SERVICE_CLASS);
-    if (!impl_info_param)
+    impl_info_param = axutil_param_container_get_param(axis2_svc_get_param_container(
+        svc_builder->svc, env), env, AXIS2_SERVICE_CLASS);
+    if(!impl_info_param)
     {
         axutil_dll_desc_free(dll_desc, env);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "%s parameter not found", AXIS2_SERVICE_CLASS);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s parameter not found", AXIS2_SERVICE_CLASS);
         return AXIS2_FAILURE;
     }
-    class_name = axutil_strtrim(env, 
-                     axutil_param_get_value(impl_info_param, env), NULL);
-    svc_dll_name =
-        axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env,
-                                                          class_name);
+    class_name = axutil_strtrim(env, axutil_param_get_value(impl_info_param, env), NULL);
+    svc_dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name);
 
-    if (class_name)
+    if(class_name)
     {
         AXIS2_FREE(env->allocator, class_name);
         class_name = NULL;
     }
 
-    arch_file_data =
-        axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine
-                                               (svc_builder->desc_builder, env),
-                                               env);
+    arch_file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine(
+        svc_builder->desc_builder, env), env);
     svc_folder = axis2_arch_file_data_get_file(arch_file_data, env);
     timestamp = axutil_file_get_timestamp(svc_folder, env);
     axutil_dll_desc_set_timestamp(dll_desc, env, timestamp);
     svc_folder_path = axutil_file_get_path(svc_folder, env);
     axis2_svc_set_svc_folder_path(svc_builder->svc, env, svc_folder_path);
-    dll_path = axutil_strcat(env, svc_folder_path, AXIS2_PATH_SEP_STR,
-                             svc_dll_name, NULL);
+    dll_path = axutil_strcat(env, svc_folder_path, AXIS2_PATH_SEP_STR, svc_dll_name, NULL);
     AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "DLL path is : %s", dll_path);
     status = axutil_dll_desc_set_name(dll_desc, env, dll_path);
-    if (AXIS2_SUCCESS != status)
+    if(AXIS2_SUCCESS != status)
     {
         axutil_dll_desc_free(dll_desc, env);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Setting name to  %s dll description failed", dll_path);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name to  %s dll description failed",
+            dll_path);
         return status;
     }
     AXIS2_FREE(env->allocator, dll_path);
@@ -329,40 +306,37 @@
 
     axutil_dll_desc_set_type(dll_desc, env, AXIS2_SVC_DLL);
     status = axutil_param_set_value(impl_info_param, env, dll_desc);
-    axutil_param_set_value_free(impl_info_param, env,
-                                axutil_dll_desc_free_void_arg);
-    if (AXIS2_SUCCESS != status)
+    axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg);
+    if(AXIS2_SUCCESS != status)
     {
         axutil_dll_desc_free(dll_desc, env);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Setting dll_desc to parameter %s failed", class_name);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting dll_desc to parameter %s failed",
+            class_name);
         return status;
     }
     /* processing service wide modules which required to engage globally */
     qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL);
-    module_refs = axiom_element_get_children_with_qname(svc_element, env,
-                                                        qmodulest, svc_node);
+    module_refs = axiom_element_get_children_with_qname(svc_element, env, qmodulest, svc_node);
     axutil_qname_free(qmodulest, env);
     qmodulest = NULL;
-    status =
-        axis2_svc_builder_process_module_refs(svc_builder, env, module_refs);
-    if (AXIS2_SUCCESS != status)
+    status = axis2_svc_builder_process_module_refs(svc_builder, env, module_refs);
+    if(AXIS2_SUCCESS != status)
     {
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-            "Processing module references failed");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing module references failed");
         return status;
     }
-    
+
     if(!addressing_engaged)
     {
         svc_module_qnames = axis2_svc_get_all_module_qnames(svc_builder->svc, env);
-        if (svc_module_qnames)
+        if(svc_module_qnames)
         {
-            svc_module_qname_size = axutil_array_list_size(svc_module_qnames, env);  
+            svc_module_qname_size = axutil_array_list_size(svc_module_qnames, env);
             qname_addressing = axutil_qname_create(env, AXIS2_MODULE_ADDRESSING, NULL, NULL);
-            for (i = 0; i < svc_module_qname_size; i++)
+            for(i = 0; i < svc_module_qname_size; i++)
             {
-                if (axutil_qname_equals(axutil_array_list_get(svc_module_qnames, env, i), env, qname_addressing))
+                if(axutil_qname_equals(axutil_array_list_get(svc_module_qnames, env, i), env,
+                    qname_addressing))
                 {
                     addressing_engaged = AXIS2_TRUE;
                     break;
@@ -375,94 +349,82 @@
 
     /* process IN_FLOW */
     qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL);
-    in_flow_element = axiom_element_get_first_child_with_qname(svc_element,
-                                                               env, qinflowst,
-                                                               svc_node,
-                                                               &in_flow_node);
+    in_flow_element = axiom_element_get_first_child_with_qname(svc_element, env, qinflowst,
+        svc_node, &in_flow_node);
     axutil_qname_free(qinflowst, env);
     qinflowst = NULL;
 
     qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL);
-    out_flow_element = axiom_element_get_first_child_with_qname(svc_element,
-                                                                env, qoutflowst,
-                                                                svc_node,
-                                                                &out_flow_node);
+    out_flow_element = axiom_element_get_first_child_with_qname(svc_element, env, qoutflowst,
+        svc_node, &out_flow_node);
     axutil_qname_free(qoutflowst, env);
     qoutflowst = NULL;
 
     qin_faultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL);
-    in_faultflow_element = axiom_element_get_first_child_with_qname(svc_element,
-                                                                    env,
-                                                                    qin_faultflowst,
-                                                                    svc_node,
-                                                                    &in_faultflow_node);
+    in_faultflow_element = axiom_element_get_first_child_with_qname(svc_element, env,
+        qin_faultflowst, svc_node, &in_faultflow_node);
     axutil_qname_free(qin_faultflowst, env);
     qin_faultflowst = NULL;
 
-    qout_faultflowst =
-        axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL);
-    out_faultflow_element =
-        axiom_element_get_first_child_with_qname(svc_element, env, qoutflowst,
-                                                 svc_node, &out_faultflow_node);
+    qout_faultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL);
+    out_faultflow_element = axiom_element_get_first_child_with_qname(svc_element, env, qoutflowst,
+        svc_node, &out_faultflow_node);
     axutil_qname_free(qout_faultflowst, env);
     qout_faultflowst = NULL;
 
     /* processing operations */
     qopst = axutil_qname_create(env, AXIS2_OPERATIONST, NULL, NULL);
-    operation_itr = axiom_element_get_children_with_qname(svc_element, env,
-                                                          qopst, svc_node);
+    operation_itr = axiom_element_get_children_with_qname(svc_element, env, qopst, svc_node);
     axutil_qname_free(qopst, env);
     qopst = NULL;
     ops = axis2_svc_builder_process_ops(svc_builder, env, operation_itr);
-    if (ops)
+    if(ops)
     {
         size = axutil_array_list_size(ops, env);
     }
-    for (i = 0; i < size; i++)
+    for(i = 0; i < size; i++)
     {
         axis2_op_t *op_desc = NULL;
         axutil_array_list_t *params = NULL;
         int j = 0;
         int sizej = 0;
 
-        op_desc = (axis2_op_t *) axutil_array_list_get(ops, env, i);
-        if (addressing_engaged)
+        op_desc = (axis2_op_t *)axutil_array_list_get(ops, env, i);
+        if(addressing_engaged)
         {
             params = axis2_op_get_all_params(op_desc, env);
             /* Adding wsa-mapping into service */
             sizej = axutil_array_list_size(params, env);
-            for (j = 0; j < sizej; j++)
+            for(j = 0; j < sizej; j++)
             {
                 axutil_param_t *param = NULL;
                 axis2_char_t *param_name = NULL;
 
                 param = axutil_array_list_get(params, env, j);
                 param_name = axutil_param_get_name(param, env);
-                if (0 == axutil_strcmp(param_name, AXIS2_WSA_MAPPING))
+                if(0 == axutil_strcmp(param_name, AXIS2_WSA_MAPPING))
                 {
                     axis2_char_t *key = NULL;
 
-                    key = (axis2_char_t *) axutil_param_get_value(param, env);
+                    key = (axis2_char_t *)axutil_param_get_value(param, env);
                     axis2_svc_add_mapping(svc_builder->svc, env, key, op_desc);
                 }
             }
         }
         axis2_svc_add_op(svc_builder->svc, env, op_desc);
-        if (axis2_op_get_rest_http_method(op_desc, env) && 
-            axis2_op_get_rest_http_location(op_desc, env) )
+        if(axis2_op_get_rest_http_method(op_desc, env) && axis2_op_get_rest_http_location(op_desc,
+            env))
         {
-            axis2_svc_add_rest_mapping(svc_builder->svc, env,
-                                       axis2_op_get_rest_http_method(op_desc, env),
-                                       axis2_op_get_rest_http_location(op_desc, env),
-                                       op_desc);
+            axis2_svc_add_rest_mapping(svc_builder->svc, env, axis2_op_get_rest_http_method(
+                op_desc, env), axis2_op_get_rest_http_location(op_desc, env), op_desc);
         }
     }
     axutil_array_list_free(ops, env);
 
     /*
-       <schema targetNamespace="http://x.y.z"/>
-       setting the PolicyInclude
-       processing <wsp:Policy> .. </..> elements
+     <schema targetNamespace="http://x.y.z"/>
+     setting the PolicyInclude
+     processing <wsp:Policy> .. </..> elements
      */
     qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL);
     itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node);
@@ -476,10 +438,9 @@
         qpolicy = NULL;
     }
 
-    if (itr)
+    if(itr)
     {
-        axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr,
-                                      policy_include);
+        axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include);
     }
 
     /* processing <wsp:PolicyReference> .. </..> elements */
@@ -495,10 +456,9 @@
         axutil_qname_free(qpolicy, env);
         qpolicy = NULL;
     }
-    if (itr)
+    if(itr)
     {
-        axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr,
-                                                policy_include);
+        axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include);
     }
 
     return AXIS2_SUCCESS;
@@ -515,7 +475,7 @@
     AXIS2_PARAM_CHECK(env->error, op_itr, NULL);
 
     ops = axutil_array_list_create(env, 0);
-    while (AXIS2_TRUE == axiom_children_qname_iterator_has_next(op_itr, env))
+    while(AXIS2_TRUE == axiom_children_qname_iterator_has_next(op_itr, env))
     {
         axiom_element_t *op_element = NULL;
         axiom_node_t *op_node = NULL;
@@ -549,10 +509,9 @@
         op_name_att = axiom_element_get_attribute(op_element, env, qattname);
         axutil_qname_free(qattname, env);
         qattname = NULL;
-        if (!op_name_att)
+        if(!op_name_att)
         {
-            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING,
-                            AXIS2_FAILURE);
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING, AXIS2_FAILURE);
             AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "");
             return NULL;
         }
@@ -571,10 +530,10 @@
         qmep = NULL;
         op_name = axiom_attribute_get_value(op_name_att, env);
 
-        if (op_mep_att)
+        if(op_mep_att)
         {
             mep_url = axiom_attribute_get_value(op_mep_att, env);
-            if (mep_url)
+            if(mep_url)
             {
                 axis2_op_set_msg_exchange_pattern(op_desc, env, mep_url);
             }
@@ -585,38 +544,29 @@
 
         /* operation parameters */
         qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-        params_itr = axiom_element_get_children_with_qname(op_element, env,
-                                                           qparamst, op_node);
+        params_itr = axiom_element_get_children_with_qname(op_element, env, qparamst, op_node);
         axutil_qname_free(qparamst, env);
         qparamst = NULL;
-        status = axis2_desc_builder_process_params(svc_builder->desc_builder,
-                                                   env, params_itr,
-                                                   axis2_op_get_param_container
-                                                   (op_desc, env),
-                                                   axis2_svc_get_param_container
-                                                   (svc_builder->svc, env));
+        status = axis2_desc_builder_process_params(svc_builder->desc_builder, env, params_itr,
+            axis2_op_get_param_container(op_desc, env), axis2_svc_get_param_container(
+                svc_builder->svc, env));
         /* To process wsamapping */
-        axis2_desc_builder_process_action_mappings(svc_builder->desc_builder,
-                                                   env, op_node, op_desc);
+        axis2_desc_builder_process_action_mappings(svc_builder->desc_builder, env, op_node, op_desc);
 
         /* To process REST params */
-        axis2_desc_builder_process_rest_params(svc_builder->desc_builder,
-                                               env, op_node, op_desc);
+        axis2_desc_builder_process_rest_params(svc_builder->desc_builder, env, op_node, op_desc);
 
         /* loading the message receivers */
         qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL);
-        recv_element = axiom_element_get_first_child_with_qname(op_element,
-                                                                env, qmsgrecv,
-                                                                op_node,
-                                                                &recv_node);
+        recv_element = axiom_element_get_first_child_with_qname(op_element, env, qmsgrecv, op_node,
+            &recv_node);
         axutil_qname_free(qmsgrecv, env);
         qmsgrecv = NULL;
-        if (recv_element && NULL != recv_node)
+        if(recv_element && NULL != recv_node)
         {
             axis2_msg_recv_t *msg_recv = NULL;
-            msg_recv =
-                axis2_desc_builder_load_msg_recv(svc_builder->desc_builder, env,
-                                                 recv_element);
+            msg_recv = axis2_desc_builder_load_msg_recv(svc_builder->desc_builder, env,
+                recv_element);
             axis2_op_set_msg_recv(op_desc, env, msg_recv);
 
         }
@@ -629,18 +579,15 @@
         }
         /* process module refs */
         qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL);
-        module_itr = axiom_element_get_children_with_qname(op_element, env,
-                                                           qmodulest, op_node);
+        module_itr = axiom_element_get_children_with_qname(op_element, env, qmodulest, op_node);
         axutil_qname_free(qmodulest, env);
         qmodulest = NULL;
-        status = axis2_desc_builder_process_op_module_refs(svc_builder->
-                                                           desc_builder, env,
-                                                           module_itr, op_desc);
-        if (AXIS2_SUCCESS != status)
-        {
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Processing module operation references failed for operation %s", 
-                op_name);
+        status = axis2_desc_builder_process_op_module_refs(svc_builder-> desc_builder, env,
+            module_itr, op_desc);
+        if(AXIS2_SUCCESS != status)
+        {
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "Processing module operation references failed for operation %s", op_name);
             return NULL;
         }
 
@@ -661,10 +608,9 @@
             qpolicy = NULL;
         }
 
-        if (itr)
+        if(itr)
         {
-            axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr,
-                                          policy_include);
+            axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include);
         }
 
         /* processing <wsp:PolicyReference> .. </..> elements */
@@ -678,33 +624,29 @@
             qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL);
             itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node);
             axutil_qname_free(qpolicy, env);
-            qpolicy = NULL;        
+            qpolicy = NULL;
         }
 
-        if (itr)
+        if(itr)
         {
-            axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr,
-                                                    policy_include);
+            axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include);
         }
 
         qmessage = axutil_qname_create(env, AXIS2_MESSAGE, NULL, NULL);
-        itr = axiom_element_get_children_with_qname(op_element, env,
-                                                    qmessage, op_node);
+        itr = axiom_element_get_children_with_qname(op_element, env, qmessage, op_node);
         axutil_qname_free(qmessage, env);
         qmessage = NULL;
 
-        if (itr)
+        if(itr)
         {
             axis2_svc_builder_process_msgs(svc_builder, env, itr, op_desc);
         }
 
         /* setting operation phase */
-        dep_engine =
-            axis2_desc_builder_get_dep_engine(svc_builder->desc_builder, env);
-        if (dep_engine)
+        dep_engine = axis2_desc_builder_get_dep_engine(svc_builder->desc_builder, env);
+        if(dep_engine)
         {
-            axis2_phases_info_t *info =
-                axis2_dep_engine_get_phases_info(dep_engine, env);
+            axis2_phases_info_t *info = axis2_dep_engine_get_phases_info(dep_engine, env);
             axis2_phases_info_set_op_phases(info, env, op_desc);
         }
 
@@ -722,7 +664,7 @@
     axiom_children_qname_iterator_t * iterator,
     axis2_op_t * op)
 {
-    while (axiom_children_qname_iterator_has_next(iterator, env))
+    while(axiom_children_qname_iterator_has_next(iterator, env))
     {
         axiom_node_t *node = NULL;
         axiom_element_t *element = NULL;
@@ -738,32 +680,27 @@
         element = axiom_node_get_data_element(node, env);
         qname = axutil_qname_create(env, AXIS2_LABEL, NULL, NULL);
 
-        if (element)
+        if(element)
         {
             msg_label = axiom_element_get_attribute_value(element, env, qname);
         }
 
-        if (msg_label)
+        if(msg_label)
         {
             msg = axis2_op_get_msg(op, env, msg_label);
         }
 
-        if (msg)
+        if(msg)
         {
             /* operation parameters */
             axiom_children_qname_iterator_t *params_itr = NULL;
             axutil_qname_t *qparamst = NULL;
             qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
-            params_itr = axiom_element_get_children_with_qname(element, env,
-                                                               qparamst, node);
+            params_itr = axiom_element_get_children_with_qname(element, env, qparamst, node);
             axutil_qname_free(qparamst, env);
             qparamst = NULL;
-            axis2_desc_builder_process_params(svc_builder->desc_builder,
-                                              env, params_itr,
-                                              axis2_msg_get_param_container(msg,
-                                                                            env),
-                                              axis2_op_get_param_container(op,
-                                                                           env));
+            axis2_desc_builder_process_params(svc_builder->desc_builder, env, params_itr,
+                axis2_msg_get_param_container(msg, env), axis2_op_get_param_container(op, env));
 
             desc = axis2_msg_get_base(msg, env);
             policy_include = axis2_desc_get_policy_include(desc, env);
@@ -776,7 +713,7 @@
             itr = axiom_element_get_children_with_qname(element, env, qpolicy, node);
             axutil_qname_free(qpolicy, env);
             qpolicy = NULL;
-            
+
             if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env)))
             {
                 qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL);
@@ -785,33 +722,32 @@
                 qpolicy = NULL;
             }
 
-            if (itr)
+            if(itr)
             {
-                axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr,
-                                              policy_include);
+                axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include);
                 /* axis2_process_policy_elements(env, AXIS2_MESSAGE_POLICY, itr,
-                   policy_include); */
+                 policy_include); */
 
             }
 
             /* processing <wsp:PolicyReference> .. </..> elements */
             qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL);
-            itr = axiom_element_get_children_with_qname(element, env, qpolicy,node);
+            itr = axiom_element_get_children_with_qname(element, env, qpolicy, node);
             axutil_qname_free(qpolicy, env);
             qpolicy = NULL;
 
             if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env)))
             {
-                qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL);
-                itr = axiom_element_get_children_with_qname(element, env, qpolicy,node);
+                qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE,
+                    NULL);
+                itr = axiom_element_get_children_with_qname(element, env, qpolicy, node);
                 axutil_qname_free(qpolicy, env);
                 qpolicy = NULL;
             }
 
-            if (itr)
+            if(itr)
             {
-                axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF,
-                                                        itr, policy_include);
+                axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include);
             }
         }
     }
@@ -825,27 +761,23 @@
     axutil_param_container_t * parent,
     axis2_svc_t * svc)
 {
-    while (axiom_children_qname_iterator_has_next(module_confs, env))
+    while(axiom_children_qname_iterator_has_next(module_confs, env))
     {
         axiom_element_t *module_conf_element = NULL;
         axiom_node_t *module_conf_node = NULL;
         axiom_attribute_t *module_name_att = NULL;
         axutil_qname_t *qattname = NULL;
 
-        module_conf_node =
-            axiom_children_qname_iterator_next(module_confs, env);
-        module_conf_element =
-            axiom_node_get_data_element(module_conf_node, env);
+        module_conf_node = axiom_children_qname_iterator_next(module_confs, env);
+        module_conf_element = axiom_node_get_data_element(module_conf_node, env);
         qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
-        module_name_att = axiom_element_get_attribute(module_conf_element,
-                                                      env, qattname);
+        module_name_att = axiom_element_get_attribute(module_conf_element, env, qattname);
         axutil_qname_free(qattname, env);
         qattname = NULL;
-        if (!module_name_att)
+        if(!module_name_att)
         {
-            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_CONF,
-                            AXIS2_FAILURE);
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_CONF, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                 "Module name attribute not found for module node");
             return AXIS2_FAILURE;
         }
@@ -861,7 +793,7 @@
 {
     AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE);
 
-    while (axiom_children_qname_iterator_has_next(module_refs, env))
+    while(axiom_children_qname_iterator_has_next(module_refs, env))
     {
         axiom_element_t *module_ref_element = NULL;
         axiom_node_t *module_ref_node = NULL;
@@ -871,25 +803,21 @@
         module_ref_node = axiom_children_qname_iterator_next(module_refs, env);
         module_ref_element = axiom_node_get_data_element(module_ref_node, env);
         qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL);
-        module_ref_att = axiom_element_get_attribute(module_ref_element,
-                                                     env, qref);
+        module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref);
         axutil_qname_free(qref, env);
-        if (module_ref_att)
+        if(module_ref_att)
         {
             axis2_char_t *ref_name = NULL;
             axutil_qname_t *qrefname = NULL;
 
             ref_name = axiom_attribute_get_value(module_ref_att, env);
             qrefname = axutil_qname_create(env, ref_name, NULL, NULL);
-            if (!axis2_dep_engine_get_module
-                (axis2_desc_builder_get_dep_engine
-                 (svc_builder->desc_builder, env), env, qrefname))
+            if(!axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine(
+                svc_builder->desc_builder, env), env, qrefname))
             {
-                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND,
-                                AXIS2_FAILURE);
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to find "\
-                    "Module %s, in Service %s", ref_name, 
-                    axis2_svc_get_name(svc_builder->svc, env));
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to find "
+                    "Module %s, in Service %s", ref_name, axis2_svc_get_name(svc_builder->svc, env));
                 return AXIS2_FAILURE;
             }
             else

Modified: webservices/axis2/trunk/c/src/core/deployment/svc_grp_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/deployment/svc_grp_builder.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/deployment/svc_grp_builder.c (original)
+++ webservices/axis2/trunk/c/src/core/deployment/svc_grp_builder.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -32,11 +31,10 @@
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    svc_grp_builder = (axis2_svc_grp_builder_t *) AXIS2_MALLOC(env->allocator,
-                                                    sizeof
-                                                    (axis2_svc_grp_builder_t));
+    svc_grp_builder = (axis2_svc_grp_builder_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(axis2_svc_grp_builder_t));
 
-    if (!svc_grp_builder)
+    if(!svc_grp_builder)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -56,16 +54,14 @@
 {
     axis2_svc_grp_builder_t *svc_grp_builder = NULL;
 
-    svc_grp_builder = (axis2_svc_grp_builder_t *)
-        axis2_svc_grp_builder_create(env);
-    if (!svc_grp_builder)
+    svc_grp_builder = (axis2_svc_grp_builder_t *)axis2_svc_grp_builder_create(env);
+    if(!svc_grp_builder)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         svc_grp_builder = NULL;
     }
-    svc_grp_builder->desc_builder =
-        axis2_desc_builder_create_with_dep_engine(env, dep_engine);
-    if (!svc_grp_builder->desc_builder)
+    svc_grp_builder->desc_builder = axis2_desc_builder_create_with_dep_engine(env, dep_engine);
+    if(!svc_grp_builder->desc_builder)
     {
         axis2_svc_grp_builder_free(svc_grp_builder, env);
         return NULL;
@@ -80,11 +76,11 @@
     axis2_svc_grp_builder_t * svc_grp_builder,
     const axutil_env_t * env)
 {
-    if (svc_grp_builder->desc_builder)
+    if(svc_grp_builder->desc_builder)
     {
         axis2_desc_builder_free(svc_grp_builder->desc_builder, env);
     }
-    if (svc_grp_builder)
+    if(svc_grp_builder)
     {
         AXIS2_FREE(env->allocator, svc_grp_builder);
     }
@@ -109,55 +105,46 @@
     axis2_conf_t *parent = NULL;
 
     /* Processing service level paramters */
-    svc_grp_element =
-        axiom_node_get_data_element(svc_grp_builder->svc_grp, env);
+    svc_grp_element = axiom_node_get_data_element(svc_grp_builder->svc_grp, env);
     qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL);
 
     itr = axiom_element_get_children_with_qname(svc_grp_element, env, qparamst,
-                                                svc_grp_builder->svc_grp);
+        svc_grp_builder->svc_grp);
 
-    if (qparamst)
+    if(qparamst)
     {
         axutil_qname_free(qparamst, env);
         qparamst = NULL;
     }
 
     parent = axis2_svc_grp_get_parent(svc_grp, env);
-    status =
-        axis2_desc_builder_process_params(svc_grp_builder->desc_builder, env,
-                                          itr,
-                                          axis2_svc_grp_get_param_container
-                                          (svc_grp, env),
-                                          axis2_conf_get_param_container(parent,
-                                                                         env));
+    status = axis2_desc_builder_process_params(svc_grp_builder->desc_builder, env, itr,
+        axis2_svc_grp_get_param_container(svc_grp, env),
+        axis2_conf_get_param_container(parent, env));
 
     /* Processing service modules required to be engaged globally */
     qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL);
-    module_ref_itr = axiom_element_get_children_with_qname(svc_grp_element, env,
-                                                           qmodulest,
-                                                           svc_grp_builder->
-                                                           svc_grp);
+    module_ref_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qmodulest,
+        svc_grp_builder-> svc_grp);
 
-    if (qmodulest)
+    if(qmodulest)
     {
         axutil_qname_free(qmodulest, env);
         qmodulest = NULL;
     }
 
-    axis2_svc_grp_builder_process_module_refs(svc_grp_builder, env,
-                                              module_ref_itr, svc_grp);
+    axis2_svc_grp_builder_process_module_refs(svc_grp_builder, env, module_ref_itr, svc_grp);
     qsvc_element = axutil_qname_create(env, AXIS2_SVC_ELEMENT, NULL, NULL);
-    svc_itr = axiom_element_get_children_with_qname(svc_grp_element, env,
-                                                    qsvc_element,
-                                                    svc_grp_builder->svc_grp);
+    svc_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qsvc_element,
+        svc_grp_builder->svc_grp);
 
-    if (qsvc_element)
+    if(qsvc_element)
     {
         axutil_qname_free(qsvc_element, env);
         qsvc_element = NULL;
     }
 
-    while (axiom_children_qname_iterator_has_next(svc_itr, env))
+    while(axiom_children_qname_iterator_has_next(svc_itr, env))
     {
         axiom_node_t *svc_node = NULL;
         axiom_element_t *svc_element = NULL;
@@ -165,25 +152,22 @@
         axis2_char_t *svc_name = NULL;
         axutil_qname_t *qattname = NULL;
 
-        svc_node =
-            (axiom_node_t *) axiom_children_qname_iterator_next(svc_itr, env);
+        svc_node = (axiom_node_t *)axiom_children_qname_iterator_next(svc_itr, env);
         svc_element = axiom_node_get_data_element(svc_node, env);
         qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL);
         svc_name_att = axiom_element_get_attribute(svc_element, env, qattname);
 
-        if (qattname)
+        if(qattname)
         {
             axutil_qname_free(qattname, env);
             qattname = NULL;
         }
 
         svc_name = axiom_attribute_get_value(svc_name_att, env);
-        if (!svc_name)
+        if(!svc_name)
         {
-            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_NAME_ERROR,
-                            AXIS2_FAILURE);
-            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                "Service name attribute has no value");
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_NAME_ERROR, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service name attribute has no value");
             return AXIS2_FAILURE;
         }
         else
@@ -193,12 +177,10 @@
             axutil_array_list_t *deployable_svcs = NULL;
             axis2_svc_builder_t *svc_builder = NULL;
 
-            file_data =
-                axis2_dep_engine_get_current_file_item
-                (axis2_desc_builder_get_dep_engine
-                 (svc_grp_builder->desc_builder, env), env);
+            file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine(
+                svc_grp_builder->desc_builder, env), env);
             axis_svc = axis2_arch_file_data_get_svc(file_data, env, svc_name);
-            if (!axis_svc)
+            if(!axis_svc)
             {
                 axutil_qname_t *qsvc_name = NULL;
 
@@ -209,16 +191,11 @@
 
             }
             /* Adding service to the deployable services list */
-            deployable_svcs =
-                axis2_arch_file_data_get_deployable_svcs(file_data, env);
+            deployable_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env);
             axutil_array_list_add(deployable_svcs, env, axis_svc);
             axis2_svc_set_parent(axis_svc, env, svc_grp);
             svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env,
-                                               axis2_desc_builder_get_dep_engine
-                                               (svc_grp_builder->
-                                                desc_builder,
-                                                env),
-                                               axis_svc);
+                axis2_desc_builder_get_dep_engine(svc_grp_builder-> desc_builder, env), axis_svc);
             status = axis2_svc_builder_populate_svc(svc_builder, env, svc_node);
             axis2_svc_builder_free(svc_builder, env);
 
@@ -237,20 +214,18 @@
     AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE);
 
-    while (axiom_children_qname_iterator_has_next(module_refs, env))
+    while(axiom_children_qname_iterator_has_next(module_refs, env))
     {
         axiom_node_t *module_ref_node = NULL;
         axiom_element_t *module_ref_element = NULL;
         axiom_attribute_t *module_ref_att = NULL;
         axutil_qname_t *qref = NULL;
 
-        module_ref_node = (axiom_node_t *)
-            axiom_children_qname_iterator_next(module_refs, env);
+        module_ref_node = (axiom_node_t *)axiom_children_qname_iterator_next(module_refs, env);
         module_ref_element = axiom_node_get_data_element(module_ref_node, env);
         qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL);
-        module_ref_att = axiom_element_get_attribute(module_ref_element, env,
-                                                     qref);
-        if (module_ref_att)
+        module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref);
+        if(module_ref_att)
         {
             axis2_char_t *ref_name = NULL;
             axutil_qname_t *qrefname = NULL;
@@ -258,15 +233,12 @@
 
             ref_name = axiom_attribute_get_value(module_ref_att, env);
             qrefname = axutil_qname_create(env, ref_name, NULL, NULL);
-            module =
-                axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine
-                                            (svc_grp_builder->desc_builder,
-                                             env), env, qrefname);
-            if (!module)
+            module = axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine(
+                svc_grp_builder->desc_builder, env), env, qrefname);
+            if(!module)
             {
-                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND,
-                                AXIS2_FAILURE);
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                     "Module %s not found in deployment engine.", ref_name);
                 return AXIS2_FAILURE;
             }

Modified: webservices/axis2/trunk/c/src/core/deployment/ws_info.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/deployment/ws_info.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/deployment/ws_info.c (original)
+++ webservices/axis2/trunk/c/src/core/deployment/ws_info.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -40,10 +39,9 @@
 
     AXIS2_PARAM_CHECK(env->error, file_name, NULL);
 
-    ws_info = (axis2_ws_info_t *) AXIS2_MALLOC(env->allocator,
-                                               sizeof(axis2_ws_info_t));
+    ws_info = (axis2_ws_info_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_ws_info_t));
 
-    if (!ws_info)
+    if(!ws_info)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -54,7 +52,7 @@
     ws_info->type = 0;
 
     ws_info->file_name = axutil_strdup(env, file_name);
-    if (!ws_info->file_name)
+    if(!ws_info->file_name)
     {
         axis2_ws_info_free(ws_info, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -77,11 +75,9 @@
 
     AXIS2_PARAM_CHECK(env->error, file_name, NULL);
 
-    ws_info = (axis2_ws_info_t *)
-        axis2_ws_info_create_with_file_name_and_last_modified_date(env,
-                                                                   file_name,
-                                                                   last_modified_date);
-    if (!ws_info)
+    ws_info = (axis2_ws_info_t *)axis2_ws_info_create_with_file_name_and_last_modified_date(env,
+        file_name, last_modified_date);
+    if(!ws_info)
     {
         axis2_ws_info_free(ws_info, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -96,12 +92,12 @@
     axis2_ws_info_t * ws_info,
     const axutil_env_t * env)
 {
-    if (ws_info->file_name)
+    if(ws_info->file_name)
     {
         AXIS2_FREE(env->allocator, ws_info->file_name);
     }
 
-    if (ws_info)
+    if(ws_info)
     {
         AXIS2_FREE(env->allocator, ws_info);
     }
@@ -125,7 +121,7 @@
 {
     AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE);
 
-    if (ws_info->file_name)
+    if(ws_info->file_name)
     {
         AXIS2_FREE(env->allocator, ws_info->file_name);
         ws_info->file_name = NULL;

Modified: webservices/axis2/trunk/c/src/core/deployment/ws_info_list.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/deployment/ws_info_list.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/deployment/ws_info_list.c (original)
+++ webservices/axis2/trunk/c/src/core/deployment/ws_info_list.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -47,22 +46,21 @@
 {
     axis2_ws_info_list_t *ws_info_list = NULL;
 
-    ws_info_list = (axis2_ws_info_list_t *) AXIS2_MALLOC(env->allocator,
-                                                         sizeof
-                                                         (axis2_ws_info_list_t));
+    ws_info_list = (axis2_ws_info_list_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(axis2_ws_info_list_t));
 
-    if (!ws_info_list)
+    if(!ws_info_list)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
 
-    memset ((void *)ws_info_list, 0, sizeof (axis2_ws_info_list_t));
+    memset((void *)ws_info_list, 0, sizeof(axis2_ws_info_list_t));
 
     ws_info_list->dep_engine = dep_engine;
 
     ws_info_list->ws_info_list = axutil_array_list_create(env, 0);
-    if (!(ws_info_list->ws_info_list))
+    if(!(ws_info_list->ws_info_list))
     {
         axis2_ws_info_list_free(ws_info_list, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -70,7 +68,7 @@
     }
 
     ws_info_list->current_info_list = axutil_array_list_create(env, 0);
-    if (!(ws_info_list->current_info_list))
+    if(!(ws_info_list->current_info_list))
     {
         axis2_ws_info_list_free(ws_info_list, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -85,43 +83,40 @@
     axis2_ws_info_list_t * ws_info_list,
     const axutil_env_t * env)
 {
-    if (ws_info_list->current_info_list)
+    if(ws_info_list->current_info_list)
     {
         int list_size = 0;
         int i = 0;
 
-        list_size =
-            axutil_array_list_size(ws_info_list->current_info_list, env);
-        for (i = 0; i < list_size; i++)
+        list_size = axutil_array_list_size(ws_info_list->current_info_list, env);
+        for(i = 0; i < list_size; i++)
         {
             axis2_char_t *file_name = NULL;
 
-            file_name = (axis2_char_t *)
-                axutil_array_list_get(ws_info_list->current_info_list, env, i);
+            file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list->current_info_list, env,
+                i);
             AXIS2_FREE(env->allocator, file_name);
         }
         axutil_array_list_free(ws_info_list->current_info_list, env);
     }
 
-    if (ws_info_list->ws_info_list)
+    if(ws_info_list->ws_info_list)
     {
         int list_size = 0;
         int i = 0;
 
         list_size = axutil_array_list_size(ws_info_list->ws_info_list, env);
-        for (i = 0; i < list_size; i++)
+        for(i = 0; i < list_size; i++)
         {
             axis2_ws_info_t *ws_info = NULL;
 
-            ws_info = (axis2_ws_info_t *) axutil_array_list_get(ws_info_list->
-                                                                ws_info_list,
-                                                                env, i);
+            ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);
             axis2_ws_info_free(ws_info, env);
         }
         axutil_array_list_free(ws_info_list->ws_info_list, env);
     }
 
-    if (ws_info_list)
+    if(ws_info_list)
     {
         AXIS2_FREE(env->allocator, ws_info_list);
     }
@@ -138,12 +133,11 @@
     int i = 0;
 
     size = axutil_array_list_size(ws_info_list->ws_info_list, env);
-    for (i = 0; i < size; i++)
+    for(i = 0; i < size; i++)
     {
         axis2_ws_info_t *ws_info = NULL;
 
-        ws_info = (axis2_ws_info_t *)
-            axutil_array_list_get(ws_info_list->ws_info_list, env, i);
+        ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list->ws_info_list, env, i);
         axis2_ws_info_free(ws_info, env);
     }
     return AXIS2_SUCCESS;
@@ -164,14 +158,14 @@
 
     temp_name = axutil_file_get_name(file, env);
     file_name = axutil_strdup(env, temp_name);
-    if (!file_name)
+    if(!file_name)
     {
         return AXIS2_FAILURE;
     }
 
-    switch (type)
+    switch(type)
     {
-    case AXIS2_SVC:
+        case AXIS2_SVC:
         {
             axis2_ws_info_t *ws_info = NULL;
             long last_modified_date = 0;
@@ -179,29 +173,24 @@
 
             last_modified_date = (long)axutil_file_get_timestamp(file, env);
             /* We are sure that the difference lies within the long range */
-            ws_info =
-                axis2_ws_info_create_with_file_name_and_last_modified_date_and_type
-                (env, file_name, last_modified_date, AXIS2_SVC);
-            status =
-                axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info);
+            ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env,
+                file_name, last_modified_date, AXIS2_SVC);
+            status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info);
 
-            if (AXIS2_SUCCESS != status)
+            if(AXIS2_SUCCESS != status)
             {
                 return status;
             }
-            file_data = axis2_arch_file_data_create_with_type_and_file(env,
-                                                                       AXIS2_SVC,
-                                                                       file);
+            file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_SVC, file);
             /* To inform that new web service is to be deployed */
-            status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine,
-                                                       env, file_data);
-            if (AXIS2_SUCCESS != status)
+            status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data);
+            if(AXIS2_SUCCESS != status)
             {
                 return status;
             }
             break;
         }
-    case AXIS2_MODULE:
+        case AXIS2_MODULE:
         {
             axis2_ws_info_t *ws_info = NULL;
             long last_modified_date = 0;
@@ -209,23 +198,18 @@
 
             last_modified_date = (long)axutil_file_get_timestamp(file, env);
             /* We are sure that the difference lies within the long range */
-            ws_info =
-                axis2_ws_info_create_with_file_name_and_last_modified_date_and_type
-                (env, file_name, last_modified_date, AXIS2_MODULE);
-            status =
-                axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info);
+            ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env,
+                file_name, last_modified_date, AXIS2_MODULE);
+            status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info);
 
-            if (AXIS2_SUCCESS != status)
+            if(AXIS2_SUCCESS != status)
             {
                 return status;
             }
-            file_data = axis2_arch_file_data_create_with_type_and_file(env,
-                                                                       AXIS2_MODULE,
-                                                                       file);
+            file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, file);
             /* To inform that new module is to be deployed */
-            status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine,
-                                                       env, file_data);
-            if (AXIS2_SUCCESS != status)
+            status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data);
+            if(AXIS2_SUCCESS != status)
             {
                 return status;
             }
@@ -233,8 +217,7 @@
             break;
         }
     }
-    return axutil_array_list_add(ws_info_list->current_info_list, env,
-                                 file_name);
+    return axutil_array_list_add(ws_info_list->current_info_list, env, file_name);
 }
 
 AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL
@@ -248,17 +231,15 @@
     AXIS2_PARAM_CHECK(env->error, file_name, NULL);
 
     size = axutil_array_list_size(ws_info_list->ws_info_list, env);
-    for (i = 0; i < size; i++)
+    for(i = 0; i < size; i++)
     {
         axis2_ws_info_t *ws_info = NULL;
         axis2_char_t *file_name_l = NULL;
 
-        ws_info = (axis2_ws_info_t *) axutil_array_list_get(ws_info_list->
-                                                            ws_info_list, env,
-                                                            i);
+        ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);
 
         file_name_l = axis2_ws_info_get_file_name(ws_info, env);
-        if (!axutil_strcmp(file_name_l, file_name))
+        if(!axutil_strcmp(file_name_l, file_name))
         {
             return ws_info;
         }
@@ -306,13 +287,13 @@
 
     /* Create temp list */
     temp_list = axutil_array_list_create(env, 0);
-    if (!temp_list)
+    if(!temp_list)
     {
         return AXIS2_FAILURE;
     }
     list_size = axutil_array_list_size(ws_info_list->ws_info_list, env);
 
-    for (i = 0; i < list_size; i++)
+    for(i = 0; i < list_size; i++)
     {
         /* For each ws_info item in the ws_info_list check whether it is also
          * in the current_info_list. If not mark it to be undeployed by adding
@@ -324,58 +305,47 @@
         axis2_bool_t exist = AXIS2_FALSE;
         int j = 0;
 
-        file_item = (axis2_ws_info_t *) axutil_array_list_get(ws_info_list->
-                                                              ws_info_list, env,
-                                                              i);
+        file_item = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);
 
         file_item_name = axis2_ws_info_get_file_name(file_item, env);
-        current_lists_size =
-            axutil_array_list_size(ws_info_list->current_info_list, env);
-        for (j = 0; j < current_lists_size; j++)
+        current_lists_size = axutil_array_list_size(ws_info_list->current_info_list, env);
+        for(j = 0; j < current_lists_size; j++)
         {
             axis2_char_t *file_name = NULL;
-            file_name = (axis2_char_t *) axutil_array_list_get(ws_info_list->
-                                                               current_info_list,
-                                                               env, j);
-            if (!axutil_strcmp(file_name, file_item_name))
+            file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list-> current_info_list,
+                env, j);
+            if(!axutil_strcmp(file_name, file_item_name))
             {
                 exist = AXIS2_TRUE;
                 break;
             }
         }
 
-        if (!exist)
+        if(!exist)
         {
             axis2_ws_info_t *ws_info = NULL;
             long last_modified_date = 0;
 
-            last_modified_date = axis2_ws_info_get_last_modified_date(file_item,
-                                                                      env);
+            last_modified_date = axis2_ws_info_get_last_modified_date(file_item, env);
             axutil_array_list_add(temp_list, env, file_item);
-            ws_info =
-                axis2_ws_info_create_with_file_name_and_last_modified_date(env,
-                                                                           file_item_name,
-                                                                           last_modified_date);
+            ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date(env,
+                file_item_name, last_modified_date);
             /* This ws_info is to be undeployed */
-            axis2_dep_engine_add_ws_to_undeploy(ws_info_list->dep_engine, env,
-                                                ws_info);
+            axis2_dep_engine_add_ws_to_undeploy(ws_info_list->dep_engine, env, ws_info);
         }
 
     }
 
     list_size = axutil_array_list_size(temp_list, env);
-    for (i = 0; i < list_size; i++)
+    for(i = 0; i < list_size; i++)
     {
         /* Get each ws_info item from the temp list created and remove that
          * item from the ws_info_list */
         axis2_ws_info_t *file_item = NULL;
         int index = 0;
 
-        file_item =
-            (axis2_ws_info_t *) axutil_array_list_get(temp_list, env, i);
-        index =
-            axutil_array_list_index_of(ws_info_list->ws_info_list, env,
-                                       file_item);
+        file_item = (axis2_ws_info_t *)axutil_array_list_get(temp_list, env, i);
+        index = axutil_array_list_index_of(ws_info_list->ws_info_list, env, file_item);
         axutil_array_list_remove(ws_info_list->ws_info_list, env, index);
     }
     axutil_array_list_free(temp_list, env);
@@ -390,7 +360,7 @@
     axis2_status_t status = AXIS2_FAILURE;
 
     status = axis2_ws_info_list_check_for_undeploy(ws_info_list, env);
-    if (AXIS2_SUCCESS != status)
+    if(AXIS2_SUCCESS != status)
     {
         return AXIS2_FAILURE;
     }

Modified: webservices/axis2/trunk/c/src/core/description/desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/desc.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/desc.c (original)
+++ webservices/axis2/trunk/c/src/core/description/desc.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -41,9 +40,9 @@
 {
     axis2_desc_t *desc = NULL;
 
-    desc = (axis2_desc_t *) AXIS2_MALLOC(env->allocator, sizeof(axis2_desc_t));
+    desc = (axis2_desc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_desc_t));
 
-    if (!desc)
+    if(!desc)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -54,16 +53,15 @@
     desc->parent = NULL;
     desc->policy_include = NULL;
 
-    desc->param_container = (axutil_param_container_t *)
-        axutil_param_container_create(env);
-    if (!(desc->param_container))
+    desc->param_container = (axutil_param_container_t *)axutil_param_container_create(env);
+    if(!(desc->param_container))
     {
         axis2_desc_free(desc, env);
         return NULL;
     }
 
     desc->children = axutil_hash_make(env);
-    if (!(desc->children))
+    if(!(desc->children))
     {
         axis2_desc_free(desc, env);
         return NULL;
@@ -79,36 +77,35 @@
     axis2_desc_t * desc,
     const axutil_env_t * env)
 {
-    if (desc->children)
+    if(desc->children)
     {
         axutil_hash_index_t *hi = NULL;
         void *val = NULL;
 
-        for (hi = axutil_hash_first(desc->children, env); hi;
-             hi = axutil_hash_next(env, hi))
+        for(hi = axutil_hash_first(desc->children, env); hi; hi = axutil_hash_next(env, hi))
         {
             axutil_hash_this(hi, NULL, NULL, &val);
 
-            if (val)
+            if(val)
             {
-                axis2_msg_free((axis2_msg_t *) val, env);
+                axis2_msg_free((axis2_msg_t *)val, env);
             }
         }
 
         axutil_hash_free(desc->children, env);
     }
 
-    if (desc->param_container)
+    if(desc->param_container)
     {
         axutil_param_container_free(desc->param_container, env);
     }
 
-    if (desc->policy_include)
+    if(desc->policy_include)
     {
         axis2_policy_include_free(desc->policy_include, env);
     }
 
-    if (desc)
+    if(desc)
     {
         AXIS2_FREE(env->allocator, desc);
     }
@@ -134,8 +131,7 @@
     const axis2_char_t * param_name)
 {
     AXIS2_PARAM_CHECK(env->error, param_name, NULL);
-    return axutil_param_container_get_param(desc->param_container, env,
-                                            param_name);
+    return axutil_param_container_get_param(desc->param_container, env, param_name);
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
@@ -170,10 +166,11 @@
     const axis2_char_t * key,
     const axis2_msg_t *child)
 {
-    if (desc->children)
+    if(desc->children)
     {
-        axis2_msg_t* msg = (axis2_msg_t *) axutil_hash_get(desc->children, key, AXIS2_HASH_KEY_STRING);
-        if ( msg != NULL )
+        axis2_msg_t* msg = (axis2_msg_t *)axutil_hash_get(desc->children, key,
+            AXIS2_HASH_KEY_STRING);
+        if(msg != NULL)
         {
             axis2_msg_free(msg, env);
             msg = NULL;
@@ -207,7 +204,7 @@
     const axutil_env_t * env,
     const axis2_char_t * key)
 {
-    if (desc->children)
+    if(desc->children)
     {
         axutil_hash_set(desc->children, key, AXIS2_HASH_KEY_STRING, NULL);
         return AXIS2_SUCCESS;
@@ -239,7 +236,7 @@
     const axutil_env_t * env,
     axis2_policy_include_t * policy_include)
 {
-    if (desc->policy_include)
+    if(desc->policy_include)
     {
         axis2_policy_include_free(desc->policy_include, env);
         desc->policy_include = NULL;
@@ -254,7 +251,7 @@
     axis2_desc_t * desc,
     const axutil_env_t * env)
 {
-    if (!desc->policy_include)
+    if(!desc->policy_include)
     {
         /*desc->policy_include = axis2_policy_include_create(env); */
         desc->policy_include = axis2_policy_include_create_with_desc(env, desc);

Modified: webservices/axis2/trunk/c/src/core/description/flow.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/flow.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/flow.c (original)
+++ webservices/axis2/trunk/c/src/core/description/flow.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -29,9 +28,9 @@
 {
     axis2_flow_t *flow = NULL;
 
-    flow = (axis2_flow_t *) AXIS2_MALLOC(env->allocator, sizeof(axis2_flow_t));
+    flow = (axis2_flow_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_flow_t));
 
-    if (!flow)
+    if(!flow)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -40,7 +39,7 @@
     flow->list = NULL;
 
     flow->list = axutil_array_list_create(env, 20);
-    if (!(flow->list))
+    if(!(flow->list))
     {
         axis2_flow_free(flow, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -55,25 +54,23 @@
     axis2_flow_t * flow,
     const axutil_env_t * env)
 {
-    if (flow->list)
+    if(flow->list)
     {
         int i = 0;
         int size = 0;
 
         size = axutil_array_list_size(flow->list, env);
-        for (i = 0; i < size; i++)
+        for(i = 0; i < size; i++)
         {
             axis2_handler_desc_t *handler_desc = NULL;
 
-            handler_desc =
-                (axis2_handler_desc_t *) axutil_array_list_get(flow->list, env,
-                                                               i);
+            handler_desc = (axis2_handler_desc_t *)axutil_array_list_get(flow->list, env, i);
             axis2_handler_desc_free(handler_desc, env);
         }
         axutil_array_list_free(flow->list, env);
     }
 
-    if (flow)
+    if(flow)
     {
         AXIS2_FREE(env->allocator, flow);
     }
@@ -88,7 +85,7 @@
 {
     axis2_flow_t *flow_l = NULL;
 
-    flow_l = (axis2_flow_t *) flow;
+    flow_l = (axis2_flow_t *)flow;
     axis2_flow_free(flow_l, env);
     return;
 }
@@ -101,10 +98,10 @@
 {
     AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE);
 
-    if (!flow->list)
+    if(!flow->list)
     {
         flow->list = axutil_array_list_create(env, 0);
-        if (!flow->list)
+        if(!flow->list)
         {
             axis2_flow_free(flow, env);
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);

Modified: webservices/axis2/trunk/c/src/core/description/flow_container.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/flow_container.c?rev=805347&r1=805346&r2=805347&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/flow_container.c (original)
+++ webservices/axis2/trunk/c/src/core/description/flow_container.c Tue Aug 18 10:15:49 2009
@@ -1,4 +1,3 @@
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -33,12 +32,10 @@
 {
     axis2_flow_container_t *flow_container = NULL;
 
-    flow_container = (axis2_flow_container_t *) AXIS2_MALLOC(env->
-                                                             allocator,
-                                                             sizeof
-                                                             (axis2_flow_container_t));
+    flow_container = (axis2_flow_container_t *)AXIS2_MALLOC(env-> allocator,
+        sizeof(axis2_flow_container_t));
 
-    if (!flow_container)
+    if(!flow_container)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -57,27 +54,27 @@
     axis2_flow_container_t * flow_container,
     const axutil_env_t * env)
 {
-    if (flow_container->in)
+    if(flow_container->in)
     {
         axis2_flow_free(flow_container->in, env);
     }
 
-    if (flow_container->out)
+    if(flow_container->out)
     {
         axis2_flow_free(flow_container->out, env);
     }
 
-    if (flow_container->in_fault)
+    if(flow_container->in_fault)
     {
         axis2_flow_free(flow_container->in_fault, env);
     }
 
-    if (flow_container->out_fault)
+    if(flow_container->out_fault)
     {
         axis2_flow_free(flow_container->out_fault, env);
     }
 
-    if (flow_container)
+    if(flow_container)
     {
         AXIS2_FREE(env->allocator, flow_container);
     }
@@ -99,7 +96,7 @@
     const axutil_env_t * env,
     axis2_flow_t * in_flow)
 {
-    if (flow_container->in)
+    if(flow_container->in)
     {
         axis2_flow_free(flow_container->in, env);
     }
@@ -121,7 +118,7 @@
     const axutil_env_t * env,
     axis2_flow_t * out_flow)
 {
-    if (flow_container->out)
+    if(flow_container->out)
     {
         axis2_flow_free(flow_container->out, env);
     }
@@ -143,7 +140,7 @@
     const axutil_env_t * env,
     axis2_flow_t * falut_in_flow)
 {
-    if (flow_container->in_fault)
+    if(flow_container->in_fault)
     {
         axis2_flow_free(flow_container->in_fault, env);
     }
@@ -166,7 +163,7 @@
     axis2_flow_t * fault_out_flow)
 {
     AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE);
-    if (flow_container->out_fault)
+    if(flow_container->out_fault)
     {
         axis2_flow_free(flow_container->out_fault, env);
     }