axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r580276 [11/26] - in /webservices/axis2/trunk/c/src: core/addr/ core/clientapi/ core/context/ core/deployment/ core/description/ core/engine/ core/phaseresolver/ core/receivers/ core/transport/ core/transport/http/common/ core/transport/htt...
Date Fri, 28 Sep 2007 09:53:04 GMT
Modified: webservices/axis2/trunk/c/src/core/description/svc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/svc.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/svc.c (original)
+++ webservices/axis2/trunk/c/src/core/description/svc.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -25,17 +26,20 @@
 {
     axis2_svc_grp_t *parent;
     axis2_char_t *axis_svc_name;
+
     /** to keep last update time of the service */
     long last_update;
     axis2_char_t *filename;
+
     /** to store module descriptions at deploy time parsing */
     axutil_array_list_t *module_list;
 
     /* service description  */
-	 axis2_char_t *svc_desc;
+    axis2_char_t *svc_desc;
 
-    /*wsdl file path*/
+    /*wsdl file path */
     axis2_char_t *wsdl_path;
+
     /**
      * WSDL related stuff
      */
@@ -46,6 +50,7 @@
      * C2WSDL(in the future)
      */
     axutil_array_list_t *schema_list;
+
     /**
      * A table that keeps a mapping of unique XSD names (Strings)
      * against the schema objects. This is populated in the first
@@ -53,23 +58,28 @@
      * the subsequent requests
      */
     axutil_hash_t *schema_mapping_table;
+
     /**
      * This is where operations are kept
      */
     axutil_hash_t *op_alias_map;
+
     /**
      * This is where action mappings are kept
      */
     axutil_hash_t *op_action_map;
+
     /**
      * Keeps track whether the schema locations are adjusted
      */
     axis2_bool_t schema_loc_adjusted;
+
     /**
      * A custom schema name prefix. if set this will be used to
      * modify the schema names
      */
     axis2_char_t *custom_schema_name_prefix;
+
     /**
      * A custom schema name suffix. will be attached to the
      * schema file name when the files are uniquely named.
@@ -89,24 +99,27 @@
     axutil_qname_t *qname;
     axis2_char_t *style;
     axutil_array_list_t *engaged_modules;
+
     /** parameter container to hold service related parameters */
     struct axutil_param_container *param_container;
+
     /** flow container that encapsulates the flow related data */
     struct axis2_flow_container *flow_container;
+
     /** base description struct */
     axis2_desc_t *base;
 };
 
 AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
-axis2_svc_create(const axutil_env_t *env)
+axis2_svc_create(
+    const axutil_env_t * env)
 {
     axis2_svc_t *svc = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    svc = (axis2_svc_t *)
-        AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_t));
-    if (! svc)
+    svc = (axis2_svc_t *) AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_t));
+    if (!svc)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -141,7 +154,7 @@
     svc->base = NULL;
 
     svc->param_container = axutil_param_container_create(env);
-    if (! svc->param_container)
+    if (!svc->param_container)
     {
         axis2_svc_free(svc, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -149,7 +162,7 @@
     }
 
     svc->flow_container = axis2_flow_container_create(env);
-    if (! svc->flow_container)
+    if (!svc->flow_container)
     {
         axis2_svc_free(svc, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -157,7 +170,7 @@
     }
 
     svc->op_alias_map = axutil_hash_make(env);
-    if (! svc->op_alias_map)
+    if (!svc->op_alias_map)
     {
         axis2_svc_free(svc, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -166,7 +179,7 @@
 
     /** create module list of default size */
     svc->op_action_map = axutil_hash_make(env);
-    if (! svc->op_action_map)
+    if (!svc->op_action_map)
     {
         axis2_svc_free(svc, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -174,7 +187,7 @@
     }
 
     svc->module_list = axutil_array_list_create(env, 0);
-    if (! svc->module_list)
+    if (!svc->module_list)
     {
         axis2_svc_free(svc, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -182,21 +195,21 @@
     }
 
     svc->schema_list = axutil_array_list_create(env,
-        AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
-    if (! svc->schema_list)
+                                                AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+    if (!svc->schema_list)
     {
         axis2_svc_free(svc, env);
         return NULL;
     }
 
     svc->engaged_modules = axutil_array_list_create(env,
-        AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
-    if (! svc->engaged_modules)
+                                                    AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+    if (!svc->engaged_modules)
     {
         axis2_svc_free(svc, env);
         return NULL;
     }
-    
+
     svc->schema_loc_adjusted = AXIS2_FALSE;
     if (svc->schema_target_ns_prefix)
     {
@@ -219,7 +232,7 @@
     }
     svc->target_ns_prefix = axutil_strdup(env, "tns");
     svc->sc_calc_count = 0;
-    
+
     svc->base = axis2_desc_create(env);
     if (!svc->base)
     {
@@ -231,16 +244,17 @@
 }
 
 AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
-axis2_svc_create_with_qname(const axutil_env_t *env,
-    const axutil_qname_t *qname)
+axis2_svc_create_with_qname(
+    const axutil_env_t * env,
+    const axutil_qname_t * qname)
 {
     axis2_svc_t *svc = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
     AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
-    
+
     svc = axis2_svc_create(env);
-    if (! svc)
+    if (!svc)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -257,8 +271,9 @@
 }
 
 AXIS2_EXTERN void AXIS2_CALL
-axis2_svc_free(axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_free(
+    axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, void);
 
@@ -280,7 +295,7 @@
 
     if (svc->svc_desc)
     {
-        AXIS2_FREE (env->allocator, svc->svc_desc);
+        AXIS2_FREE(env->allocator, svc->svc_desc);
         svc->svc_desc = NULL;
     }
 
@@ -326,16 +341,17 @@
         void *val = NULL;
 
         for (hi = axutil_hash_first(svc->op_alias_map, env); hi;
-            hi = axutil_hash_next(env, hi))
+             hi = axutil_hash_next(env, hi))
         {
             axutil_hash_this(hi, NULL, NULL, &val);
 
             if (val)
             {
-                if (axis2_op_is_from_module((axis2_op_t *)val, env) == AXIS2_FALSE )
-		{
-                    axis2_op_free((axis2_op_t *)val, env);
-		}
+                if (axis2_op_is_from_module((axis2_op_t *) val, env) ==
+                    AXIS2_FALSE)
+                {
+                    axis2_op_free((axis2_op_t *) val, env);
+                }
                 val = NULL;
             }
         }
@@ -349,13 +365,13 @@
         const void *key = NULL;
 
         for (hi = axutil_hash_first(svc->op_action_map, env); hi;
-            hi = axutil_hash_next(env, hi))
+             hi = axutil_hash_next(env, hi))
         {
             axutil_hash_this(hi, &key, NULL, NULL);
 
             if (key)
             {
-                AXIS2_FREE(env->allocator, (axis2_char_t *)key);
+                AXIS2_FREE(env->allocator, (axis2_char_t *) key);
                 key = NULL;
             }
         }
@@ -376,7 +392,7 @@
 
     if (svc->target_ns_prefix)
     {
-        AXIS2_FREE(env->allocator,  svc->target_ns_prefix);
+        AXIS2_FREE(env->allocator, svc->target_ns_prefix);
         svc->target_ns_prefix = NULL;
     }
 
@@ -385,11 +401,11 @@
         axutil_qname_free(svc->qname, env);
     }
 
-    if(svc->style)
+    if (svc->style)
     {
         AXIS2_FREE(env->allocator, svc->style);
     }
-    
+
     if (svc->base)
     {
         axis2_desc_free(svc->base, env);
@@ -404,11 +420,11 @@
     return;
 }
 
-
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_add_op(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axis2_op_t *op)
+axis2_svc_add_op(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axis2_op_t * op)
 {
     axis2_status_t status = AXIS2_FAILURE;
     axis2_msg_recv_t *msg_recv = NULL;
@@ -438,9 +454,10 @@
 }
 
 AXIS2_EXTERN axis2_op_t *AXIS2_CALL
-axis2_svc_get_op_with_qname(const axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axutil_qname_t *op_qname)
+axis2_svc_get_op_with_qname(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axutil_qname_t * op_qname)
 {
     axis2_op_t *op = NULL;
     axis2_char_t *key = NULL;
@@ -450,7 +467,7 @@
 
     key = axutil_qname_get_localpart(op_qname, env);
     op = axutil_hash_get(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING);
-    if (! op)
+    if (!op)
     {
         op = axutil_hash_get(svc->op_action_map, key, AXIS2_HASH_KEY_STRING);
     }
@@ -459,20 +476,22 @@
 }
 
 AXIS2_EXTERN axis2_op_t *AXIS2_CALL
-axis2_svc_get_op_with_name(const axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *nc_name)
+axis2_svc_get_op_with_name(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * nc_name)
 {
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, nc_name, NULL);
 
     return (axis2_op_t *) axutil_hash_get(svc->op_alias_map, nc_name,
-        AXIS2_HASH_KEY_STRING);
+                                          AXIS2_HASH_KEY_STRING);
 }
 
 AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
-axis2_svc_get_all_ops(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_all_ops(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -480,9 +499,10 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_parent(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axis2_svc_grp_t *svc_grp)
+axis2_svc_set_parent(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axis2_svc_grp_t * svc_grp)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE);
@@ -490,15 +510,17 @@
     svc->parent = svc_grp;
     if (svc_grp)
     {
-        axis2_desc_set_parent(svc->base, env, axis2_svc_grp_get_base(svc_grp, env));
+        axis2_desc_set_parent(svc->base, env,
+                              axis2_svc_grp_get_base(svc_grp, env));
     }
 
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL
-axis2_svc_get_parent(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_parent(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -506,9 +528,10 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_qname(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axutil_qname_t *qname)
+axis2_svc_set_qname(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axutil_qname_t * qname)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
@@ -519,46 +542,51 @@
 
     if (qname)
     {
-        svc->qname = axutil_qname_clone((axutil_qname_t *)qname, env);
+        svc->qname = axutil_qname_clone((axutil_qname_t *) qname, env);
     }
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL
-axis2_svc_get_qname(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_qname(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return svc->qname;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_add_param(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axutil_param_t *param)
+axis2_svc_add_param(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axutil_param_t * param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
 
-
     if (AXIS2_TRUE == axis2_svc_is_param_locked(svc, env,
-        axutil_param_get_name(param, env)))
+                                                axutil_param_get_name(param,
+                                                                      env)))
     {
         AXIS2_ERROR_SET(env->error,
-            AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+                        AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE,
+                        AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     else
     {
-        return axutil_param_container_add_param(svc->param_container, env, param);
+        return axutil_param_container_add_param(svc->param_container, env,
+                                                param);
     }
     return AXIS2_FAILURE;
 }
 
 AXIS2_EXTERN axutil_param_t *AXIS2_CALL
-axis2_svc_get_param(const axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *name)
+axis2_svc_get_param(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * name)
 {
     axutil_param_t *param = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -567,14 +595,15 @@
     param = axutil_param_container_get_param(svc->param_container, env, name);
     if (param == NULL && svc->parent)
     {
-        param =  axis2_svc_grp_get_param(svc->parent, env, name);
+        param = axis2_svc_grp_get_param(svc->parent, env, name);
     }
     return param;
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-axis2_svc_get_all_params(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_all_params(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -582,9 +611,10 @@
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axis2_svc_is_param_locked(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *param_name)
+axis2_svc_is_param_locked(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * param_name)
 {
     axis2_bool_t locked = AXIS2_FALSE;
     axutil_param_t *param = NULL;
@@ -598,7 +628,7 @@
 
     parent = axis2_svc_get_parent(svc, env);
     if (parent)
-        locked =  axis2_svc_grp_is_param_locked(parent, env, param_name);
+        locked = axis2_svc_grp_is_param_locked(parent, env, param_name);
     if (parent && AXIS2_TRUE == locked)
     {
         return AXIS2_TRUE;
@@ -613,10 +643,10 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_engage_module(
-    axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axis2_module_desc_t *module_desc,
-    axis2_conf_t *conf)
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axis2_module_desc_t * module_desc,
+    axis2_conf_t * conf)
 {
     axis2_phase_resolver_t *phase_resolver = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -624,14 +654,14 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
-    
+
     phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
     if (!phase_resolver)
     {
         return AXIS2_FAILURE;
     }
     status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, svc,
-        module_desc);
+                                                       module_desc);
     if (status)
     {
         const axutil_qname_t *qname = NULL;
@@ -648,19 +678,22 @@
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axis2_svc_is_module_engaged(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axutil_qname_t *module_qname)
+axis2_svc_is_module_engaged(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axutil_qname_t * module_qname)
 {
-    int i = 0, size = 0;
+    int i = 0,
+        size = 0;
     size = axutil_array_list_size(svc->engaged_modules, env);
     for (i = 0; i < size; i++)
     {
         const axutil_qname_t *module_qname_l = NULL;
         axis2_module_desc_t *module_desc_l = NULL;
 
-        module_desc_l = (axis2_module_desc_t *) axutil_array_list_get(
-            svc->engaged_modules, env, i);
+        module_desc_l =
+            (axis2_module_desc_t *) axutil_array_list_get(svc->engaged_modules,
+                                                          env, i);
         module_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
 
         if (axutil_qname_equals(module_qname, env, module_qname_l))
@@ -672,10 +705,11 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_disengage_module(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axis2_module_desc_t *module_desc,
-    axis2_conf_t *conf)
+axis2_svc_disengage_module(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axis2_module_desc_t * module_desc,
+    axis2_conf_t * conf)
 {
     axis2_phase_resolver_t *phase_resolver = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -683,14 +717,15 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
-    
+
     phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
     if (!phase_resolver)
     {
         return AXIS2_FAILURE;
     }
-    status = axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc,
-        module_desc);
+    status =
+        axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc,
+                                                       module_desc);
 
     axis2_phase_resolver_free(phase_resolver, env);
 
@@ -699,10 +734,10 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_add_module_ops(
-    axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axis2_module_desc_t *module_desc,
-    axis2_conf_t *conf)
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axis2_module_desc_t * module_desc,
+    axis2_conf_t * conf)
 {
     axutil_hash_t *map = NULL;
     axutil_hash_index_t *index = NULL;
@@ -710,21 +745,20 @@
     axis2_op_t *op_desc = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-        "Start:axis2_svc_add_module_ops");
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Start:axis2_svc_add_module_ops");
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
 
     map = axis2_module_desc_get_all_ops(module_desc, env);
-    phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, 
-        svc);
+    phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf,
+                                                                     svc);
     if (!phase_resolver)
     {
         return AXIS2_FAILURE;
     }
     for (index = axutil_hash_first(map, env); index; index =
-        axutil_hash_next(env, index))
+         axutil_hash_next(env, index))
     {
         axutil_array_list_t *mappings_list = NULL;
         int size = 0;
@@ -748,7 +782,8 @@
         {
             axis2_char_t *mapping = NULL;
 
-            mapping = (axis2_char_t *) axutil_array_list_get(mappings_list, env, j);
+            mapping =
+                (axis2_char_t *) axutil_array_list_get(mappings_list, env, j);
             status = axis2_svc_add_mapping(svc, env, mapping, op_desc);
             if (AXIS2_SUCCESS != status)
             {
@@ -760,7 +795,8 @@
             }
         }
 
-        status = axis2_phase_resolver_build_module_op(phase_resolver, env, op_desc);
+        status =
+            axis2_phase_resolver_build_module_op(phase_resolver, env, op_desc);
 
         if (AXIS2_SUCCESS != status)
         {
@@ -787,14 +823,14 @@
     {
         axis2_phase_resolver_free(phase_resolver, env);
     }
-    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-        "End:axis2_svc_add_module_ops");
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "End:axis2_svc_add_module_ops");
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axis2_svc_get_name(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_name(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -807,9 +843,10 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_name(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *axis_svc_name)
+axis2_svc_set_name(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * axis_svc_name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, axis_svc_name, AXIS2_FAILURE);
@@ -828,32 +865,35 @@
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_last_update(axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_set_last_update(
+    axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN long AXIS2_CALL
-axis2_svc_get_last_update(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_last_update(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->last_update;
 }
 
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axis2_svc_get_file_name(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_file_name(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->filename;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_file_name(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *filename)
+axis2_svc_set_file_name(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * filename)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, filename, AXIS2_FAILURE);
@@ -873,16 +913,18 @@
 }
 
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axis2_svc_get_svc_desc(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_svc_desc(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->svc_desc;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_svc_desc(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *svc_desc)
+axis2_svc_set_svc_desc(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * svc_desc)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, svc_desc, AXIS2_FAILURE);
@@ -902,38 +944,40 @@
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_add_mapping(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *mapping_key ,
-    axis2_op_t *op_desc)
+axis2_svc_add_mapping(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * mapping_key,
+    axis2_op_t * op_desc)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, mapping_key, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE);
 
     axutil_hash_set(svc->op_action_map, axutil_strdup(env, mapping_key),
-            AXIS2_HASH_KEY_STRING, op_desc);
+                    AXIS2_HASH_KEY_STRING, op_desc);
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_add_module_qname(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axutil_qname_t *module_qname)
+axis2_svc_add_module_qname(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axutil_qname_t * module_qname)
 {
     axutil_qname_t *qmodule_qname_l = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE);
 
-    qmodule_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env);
-    return axutil_array_list_add(svc->module_list, env,
-            qmodule_qname_l);
+    qmodule_qname_l = axutil_qname_clone((axutil_qname_t *) module_qname, env);
+    return axutil_array_list_add(svc->module_list, env, qmodule_qname_l);
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-axis2_svc_get_all_module_qnames(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_all_module_qnames(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -941,17 +985,19 @@
 }
 
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axis2_svc_get_target_ns(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_target_ns(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return svc->target_ns;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_target_ns(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *ns)
+axis2_svc_set_target_ns(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * ns)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, ns, AXIS2_FAILURE);
@@ -966,17 +1012,19 @@
 }
 
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axis2_svc_get_target_ns_prefix(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_target_ns_prefix(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return svc->target_ns_prefix;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_target_ns_prefix(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    const axis2_char_t *prefix)
+axis2_svc_set_target_ns_prefix(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * prefix)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE);
@@ -991,33 +1039,33 @@
 }
 
 AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
-axis2_svc_get_ns_map(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_ns_map(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return svc->ns_map;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_ns_map(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axutil_hash_t *ns_map)
+axis2_svc_set_ns_map(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axutil_hash_t * ns_map)
 {
     axutil_hash_index_t *hi = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, ns_map, AXIS2_FAILURE);
 
-
     if (svc->ns_map)
     {
-        for (hi = axutil_hash_first(svc->ns_map, env);  hi;
-            hi = axutil_hash_next(env, hi))
+        for (hi = axutil_hash_first(svc->ns_map, env); hi;
+             hi = axutil_hash_next(env, hi))
         {
-            void * value = NULL;
+            void *value = NULL;
             void *key = NULL;
-            axutil_hash_this(hi, (const void **)&key, NULL,
-                (void **)&value);
+            axutil_hash_this(hi, (const void **) &key, NULL, (void **) &value);
             if (key)
             {
                 AXIS2_FREE(env->allocator, key);
@@ -1036,9 +1084,10 @@
 }
 
 AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
-axis2_svc_swap_mapping_table(axis2_svc_t *svc,
-    const axutil_env_t *env,
-    axutil_hash_t *orig_table)
+axis2_svc_swap_mapping_table(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    axutil_hash_t * orig_table)
 {
     axutil_hash_t *new_table = NULL;
     axutil_hash_index_t *hi = NULL;
@@ -1048,29 +1097,30 @@
 
     new_table = axutil_hash_make(env);
 
-    for (hi = axutil_hash_first(orig_table, env);  env;
-        hi = axutil_hash_next(env, hi))
+    for (hi = axutil_hash_first(orig_table, env); env;
+         hi = axutil_hash_next(env, hi))
     {
-        void * value = NULL;
+        void *value = NULL;
         void *key = NULL;
 
-        axutil_hash_this(hi, (const void **)&key, NULL,
-            (void **)&value);
+        axutil_hash_this(hi, (const void **) &key, NULL, (void **) &value);
         axutil_hash_set(new_table, value, AXIS2_HASH_KEY_STRING, key);
     }
     return new_table;
 }
 
 AXIS2_EXTERN void *AXIS2_CALL
-axis2_svc_get_impl_class(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_impl_class(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->impl_class;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_impl_class(axis2_svc_t *svc,
-    const axutil_env_t *env,
+axis2_svc_set_impl_class(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
     void *impl_class)
 {
     svc->impl_class = impl_class;
@@ -1078,42 +1128,44 @@
 }
 
 AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
-axis2_svc_get_param_container(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_param_container(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->param_container;
 }
 
 AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL
-axis2_svc_get_flow_container(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_flow_container(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->flow_container;
 }
 
-
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axis2_svc_get_svc_wsdl_path(const axis2_svc_t *svc,
-      const axutil_env_t *env)
+axis2_svc_get_svc_wsdl_path(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->wsdl_path;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_svc_set_svc_wsdl_path(axis2_svc_t *svc,
-      const axutil_env_t *env,
-      const axis2_char_t *wsdl_path)
+axis2_svc_set_svc_wsdl_path(
+    axis2_svc_t * svc,
+    const axutil_env_t * env,
+    const axis2_char_t * wsdl_path)
 {
     AXIS2_PARAM_CHECK(env->error, wsdl_path, AXIS2_FAILURE);
-    svc->wsdl_path = (axis2_char_t *)wsdl_path;
+    svc->wsdl_path = (axis2_char_t *) wsdl_path;
     return AXIS2_SUCCESS;
 }
 
-
 AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
-axis2_svc_get_base(const axis2_svc_t *svc,
-    const axutil_env_t *env)
+axis2_svc_get_base(
+    const axis2_svc_t * svc,
+    const axutil_env_t * env)
 {
     return svc->base;
 }
-

Modified: webservices/axis2/trunk/c/src/core/description/svc_grp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/svc_grp.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/svc_grp.c (original)
+++ webservices/axis2/trunk/c/src/core/description/svc_grp.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -20,32 +21,39 @@
 
 struct axis2_svc_grp
 {
+
     /** service group name */
     axis2_char_t *svc_grp_name;
+
     /** map of services */
     axutil_hash_t *svcs;
+
     /** to store service group modules QNames */
     axutil_array_list_t *module_qnames;
+
     /** to store module ref at deploy time parsing */
     axis2_conf_t *parent;
+
     /** list of module references */
     axutil_array_list_t *module_list;
+
     /** parameter container to hold service related parameters */
     axutil_param_container_t *param_container;
+
     /** base description struct */
     axis2_desc_t *base;
 };
 
 AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL
 axis2_svc_grp_create(
-    const axutil_env_t *env)
+    const axutil_env_t * env)
 {
     axis2_svc_grp_t *svc_grp = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     svc_grp = (axis2_svc_grp_t *)
-            AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_grp_t));
+        AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_grp_t));
 
-    if (! svc_grp)
+    if (!svc_grp)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -59,7 +67,7 @@
     svc_grp->module_list = NULL;
     svc_grp->base = NULL;
 
-    svc_grp->param_container =  axutil_param_container_create(env);
+    svc_grp->param_container = axutil_param_container_create(env);
     if (!svc_grp->param_container)
     {
         axis2_svc_grp_free(svc_grp, env);
@@ -90,7 +98,7 @@
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     svc_grp->base = axis2_desc_create(env);
     if (!svc_grp->base)
     {
@@ -103,8 +111,8 @@
 
 AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL
 axis2_svc_grp_create_with_conf(
-    const axutil_env_t *env,
-    axis2_conf_t *conf)
+    const axutil_env_t * env,
+    axis2_conf_t * conf)
 {
     axis2_svc_grp_t *svc_grp = NULL;
 
@@ -116,7 +124,8 @@
         svc_grp->parent = conf;
     if (conf)
     {
-        axis2_desc_set_parent(svc_grp->base, env, axis2_conf_get_base(conf, env));
+        axis2_desc_set_parent(svc_grp->base, env,
+                              axis2_conf_get_base(conf, env));
     }
 
     return svc_grp;
@@ -125,15 +134,14 @@
 
 AXIS2_EXTERN void AXIS2_CALL
 axis2_svc_grp_free(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, void);
 
     if (svc_grp->param_container)
     {
-        axutil_param_container_free(svc_grp->param_container,
-                env);
+        axutil_param_container_free(svc_grp->param_container, env);
     }
 
     if (svc_grp->svc_grp_name)
@@ -171,9 +179,9 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_set_name(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axis2_char_t *name)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axis2_char_t * name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
@@ -191,17 +199,17 @@
 
 AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
 axis2_svc_grp_get_name(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->svc_grp_name;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_svc(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    axis2_svc_t *svc)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    axis2_svc_t * svc)
 {
     axis2_phase_resolver_t *handler_resolver = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -218,17 +226,18 @@
             return AXIS2_FAILURE;
     }
     svc_qname = axis2_svc_get_qname(svc, env);
-    svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env);
+    svc_name = axutil_qname_to_string((axutil_qname_t *) svc_qname, env);
     axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, svc);
 
     handler_resolver = axis2_phase_resolver_create_with_config_and_svc(env,
-            svc_grp->parent, svc);
+                                                                       svc_grp->
+                                                                       parent,
+                                                                       svc);
 
     if (!handler_resolver)
     {
         /* remove the previously added service */
-        axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING,
-                NULL);
+        axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
 
         return AXIS2_FAILURE;
     }
@@ -266,33 +275,33 @@
 
 AXIS2_EXTERN axis2_svc_t *AXIS2_CALL
 axis2_svc_grp_get_svc(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axutil_qname_t *qname)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axutil_qname_t * qname)
 {
     axis2_char_t *name = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, qname, NULL);
 
-    name = axutil_qname_to_string((axutil_qname_t *)qname, env);
+    name = axutil_qname_to_string((axutil_qname_t *) qname, env);
     return (axis2_svc_t *) axutil_hash_get(svc_grp->svcs, name,
-            AXIS2_HASH_KEY_STRING);
+                                           AXIS2_HASH_KEY_STRING);
 }
 
 AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
 axis2_svc_grp_get_all_svcs(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->svcs;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_remove_svc(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axutil_qname_t *svc_qname)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axutil_qname_t * svc_qname)
 {
     axis2_svc_t *svc = NULL;
     axis2_char_t *svc_name = NULL;
@@ -302,32 +311,34 @@
 
     svc = axis2_svc_grp_get_svc(svc_grp, env, svc_qname);
 
-    svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env);
-    axutil_hash_set(svc_grp->svcs, svc_name,
-            AXIS2_HASH_KEY_STRING, NULL);
+    svc_name = axutil_qname_to_string((axutil_qname_t *) svc_qname, env);
+    axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
 
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_param(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    axutil_param_t *param)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    axutil_param_t * param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
 
     if (AXIS2_TRUE == axis2_svc_grp_is_param_locked(svc_grp, env,
-            axutil_param_get_name(param, env)))
+                                                    axutil_param_get_name(param,
+                                                                          env)))
     {
         AXIS2_ERROR_SET(env->error,
-                AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
+                        AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE,
+                        AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     else
     {
-        return axutil_param_container_add_param(svc_grp->param_container, env, param);
+        return axutil_param_container_add_param(svc_grp->param_container, env,
+                                                param);
     }
 
     return AXIS2_FAILURE;
@@ -335,26 +346,27 @@
 
 AXIS2_EXTERN axutil_param_t *AXIS2_CALL
 axis2_svc_grp_get_param(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axis2_char_t *name)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axis2_char_t * name)
 {
     axutil_param_t *param = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, name, NULL);
 
-    param = axutil_param_container_get_param(svc_grp->param_container, env, name);
+    param =
+        axutil_param_container_get_param(svc_grp->param_container, env, name);
     if (param == NULL && svc_grp->parent)
     {
-        param =  axis2_conf_get_param(svc_grp->parent, env, name);
+        param = axis2_conf_get_param(svc_grp->parent, env, name);
     }
     return param;
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_all_params(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -363,9 +375,9 @@
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
 axis2_svc_grp_is_param_locked(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axis2_char_t *param_name)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axis2_char_t * param_name)
 {
     axis2_bool_t locked = AXIS2_FALSE;
     axis2_conf_t *parent = NULL;
@@ -379,7 +391,7 @@
     /* checking the locked value of parent */
     if (parent)
     {
-        locked =   axis2_conf_is_param_locked(parent, env, param_name);
+        locked = axis2_conf_is_param_locked(parent, env, param_name);
     }
     if (AXIS2_TRUE == locked)
     {
@@ -399,48 +411,48 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_module_qname(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axutil_qname_t *module_qname)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axutil_qname_t * module_qname)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return axutil_array_list_add(svc_grp->module_qnames, env,
-            module_qname);
+    return axutil_array_list_add(svc_grp->module_qnames, env, module_qname);
 }
 
 AXIS2_EXTERN axis2_conf_t *AXIS2_CALL
 axis2_svc_grp_get_parent(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->parent;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_set_parent(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    axis2_conf_t *parent)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    axis2_conf_t * parent)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
 
     if (svc_grp->parent)
-         axis2_conf_free(svc_grp->parent, env);
+        axis2_conf_free(svc_grp->parent, env);
     svc_grp->parent = parent;
     if (parent)
     {
-        axis2_desc_set_parent(svc_grp->base, env, axis2_conf_get_base(parent, env));
+        axis2_desc_set_parent(svc_grp->base, env,
+                              axis2_conf_get_base(parent, env));
     }
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_engage_module(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axutil_qname_t *module_name)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axutil_qname_t * module_name)
 {
     int i = 0;
     axis2_status_t status = AXIS2_FAILURE;
@@ -469,7 +481,8 @@
         if (0 == axutil_strcmp(modu_local, module_name_local))
         {
             AXIS2_ERROR_SET(env->error,
-                    AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC_GRP, AXIS2_FAILURE);
+                            AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC_GRP,
+                            AXIS2_FAILURE);
             return AXIS2_FAILURE;
         }
     }
@@ -481,14 +494,14 @@
     }
 
     phase_resolver = axis2_phase_resolver_create_with_config(env, svc_grp->
-            parent);
+                                                             parent);
 
     if (!phase_resolver)
     {
         return AXIS2_FAILURE;
     }
 
-    module =  axis2_conf_get_module(svc_grp->parent, env, module_name);
+    module = axis2_conf_get_module(svc_grp->parent, env, module_name);
     if (module)
     {
         axis2_svc_t *axis_svc = NULL;
@@ -502,7 +515,8 @@
             axutil_hash_this(index, NULL, NULL, &v);
             axis_svc = (axis2_svc_t *) v;
             status = axis2_phase_resolver_engage_module_to_svc(phase_resolver,
-                    env, axis_svc, module);
+                                                               env, axis_svc,
+                                                               module);
             if (!status)
             {
                 if (phase_resolver)
@@ -524,17 +538,17 @@
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_all_module_qnames(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->module_qnames;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_module_ref(
-    axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    const axutil_qname_t *moduleref)
+    axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    const axutil_qname_t * moduleref)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE);
@@ -550,24 +564,25 @@
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_all_module_refs(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->module_list;
 }
 
 AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL
 axis2_svc_grp_get_svc_grp_ctx(
-    const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env,
-    axis2_conf_ctx_t *parent)
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env,
+    axis2_conf_ctx_t * parent)
 {
     axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, parent, NULL);
 
-    svc_grp_ctx = axis2_svc_grp_ctx_create(env, (axis2_svc_grp_t *) svc_grp, parent);
+    svc_grp_ctx =
+        axis2_svc_grp_ctx_create(env, (axis2_svc_grp_t *) svc_grp, parent);
     if (!svc_grp_ctx)
     {
         return NULL;
@@ -576,16 +591,17 @@
 }
 
 AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
-axis2_svc_grp_get_param_container(const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+axis2_svc_grp_get_param_container(
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->param_container;
 }
 
 AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
-axis2_svc_grp_get_base(const axis2_svc_grp_t *svc_grp,
-    const axutil_env_t *env)
+axis2_svc_grp_get_base(
+    const axis2_svc_grp_t * svc_grp,
+    const axutil_env_t * env)
 {
     return svc_grp->base;
 }
-

Modified: webservices/axis2/trunk/c/src/core/description/transport_in_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/transport_in_desc.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/transport_in_desc.c (original)
+++ webservices/axis2/trunk/c/src/core/description/transport_in_desc.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -23,6 +24,7 @@
     axis2_flow_t *in_flow;
     axis2_flow_t *fault_in_flow;
     AXIS2_TRANSPORT_ENUMS trans_enum;
+
     /**
      * transport receiver will have a shallow copy, but will be freed by 
      * free function.
@@ -30,12 +32,14 @@
     axis2_transport_receiver_t *recv;
     axis2_phase_t *in_phase;
     axis2_phase_t *fault_phase;
+
     /** parameter container to hold transport in related parameters */
     axutil_param_container_t *param_container;
 };
 
 AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL
-axis2_transport_in_desc_create(const axutil_env_t *env,
+axis2_transport_in_desc_create(
+    const axutil_env_t * env,
     const AXIS2_TRANSPORT_ENUMS trans_enum)
 {
     axis2_transport_in_desc_t *transport_in = NULL;
@@ -43,9 +47,10 @@
     AXIS2_ENV_CHECK(env, NULL);
 
     transport_in = (axis2_transport_in_desc_t *) AXIS2_MALLOC(env->allocator,
-        sizeof(axis2_transport_in_desc_t));
+                                                              sizeof
+                                                              (axis2_transport_in_desc_t));
 
-    if (! transport_in)
+    if (!transport_in)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -60,7 +65,7 @@
     transport_in->param_container = NULL;
 
     transport_in->param_container = axutil_param_container_create(env);
-    if (! transport_in->param_container)
+    if (!transport_in->param_container)
     {
         axis2_transport_in_desc_free(transport_in, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -70,10 +75,10 @@
     return transport_in;
 }
 
-
 void AXIS2_CALL
-axis2_transport_in_desc_free(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_free(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, void);
 
@@ -99,12 +104,12 @@
 
     if (transport_in->in_phase)
     {
-         axis2_phase_free(transport_in->in_phase, env);
+        axis2_phase_free(transport_in->in_phase, env);
     }
 
     if (transport_in->fault_phase)
     {
-         axis2_phase_free(transport_in->fault_phase, env);
+        axis2_phase_free(transport_in->fault_phase, env);
     }
 
     AXIS2_FREE(env->allocator, transport_in);
@@ -113,8 +118,9 @@
 }
 
 void AXIS2_CALL
-axis2_transport_in_desc_free_void_arg(void *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_free_void_arg(
+    void *transport_in,
+    const axutil_env_t * env)
 {
     axis2_transport_in_desc_t *transport_in_l = NULL;
 
@@ -126,16 +132,18 @@
 }
 
 AXIS2_TRANSPORT_ENUMS AXIS2_CALL
-axis2_transport_in_desc_get_enum(const axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_get_enum(
+    const axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return transport_in->trans_enum;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_enum(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env,
+axis2_transport_in_desc_set_enum(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env,
     const AXIS2_TRANSPORT_ENUMS trans_enum)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -145,17 +153,19 @@
 }
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_in_desc_get_in_flow(const axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_get_in_flow(
+    const axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return transport_in->in_flow;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_in_flow(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env,
-    axis2_flow_t *in_flow)
+axis2_transport_in_desc_set_in_flow(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env,
+    axis2_flow_t * in_flow)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, in_flow, AXIS2_FAILURE);
@@ -169,16 +179,18 @@
 }
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_in_desc_get_fault_in_flow(const axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_get_fault_in_flow(
+    const axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     return transport_in->fault_in_flow;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_fault_in_flow(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env,
-    axis2_flow_t *fault_in_flow)
+axis2_transport_in_desc_set_fault_in_flow(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env,
+    axis2_flow_t * fault_in_flow)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, fault_in_flow, AXIS2_FAILURE);
@@ -192,17 +204,19 @@
 }
 
 axis2_transport_receiver_t *AXIS2_CALL
-axis2_transport_in_desc_get_recv(const axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_get_recv(
+    const axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return transport_in->recv;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_recv(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env,
-    axis2_transport_receiver_t *recv)
+axis2_transport_in_desc_set_recv(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env,
+    axis2_transport_receiver_t * recv)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, recv, AXIS2_FAILURE);
@@ -217,8 +231,9 @@
 }
 
 axis2_phase_t *AXIS2_CALL
-axis2_transport_in_desc_get_in_phase(const axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_get_in_phase(
+    const axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -226,24 +241,26 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_in_phase(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env,
-    axis2_phase_t *in_phase)
+axis2_transport_in_desc_set_in_phase(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env,
+    axis2_phase_t * in_phase)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, in_phase, AXIS2_FAILURE);
 
     if (transport_in->in_phase)
     {
-         axis2_phase_free(transport_in->in_phase, env);
+        axis2_phase_free(transport_in->in_phase, env);
     }
     transport_in->in_phase = in_phase;
     return AXIS2_SUCCESS;
 }
 
 axis2_phase_t *AXIS2_CALL
-axis2_transport_in_desc_get_fault_phase(const axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env)
+axis2_transport_in_desc_get_fault_phase(
+    const axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -251,16 +268,17 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_fault_phase(axis2_transport_in_desc_t *transport_in,
-    const axutil_env_t *env,
-    axis2_phase_t *fault_phase)
+axis2_transport_in_desc_set_fault_phase(
+    axis2_transport_in_desc_t * transport_in,
+    const axutil_env_t * env,
+    axis2_phase_t * fault_phase)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE);
 
     if (transport_in->fault_phase)
     {
-         axis2_phase_free(transport_in->fault_phase, env);
+        axis2_phase_free(transport_in->fault_phase, env);
     }
     transport_in->fault_phase = fault_phase;
     return AXIS2_SUCCESS;
@@ -268,47 +286,48 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_add_param(axis2_transport_in_desc_t *transport_in_desc,
-    const axutil_env_t *env,
-    axutil_param_t *param)
+axis2_transport_in_desc_add_param(
+    axis2_transport_in_desc_t * transport_in_desc,
+    const axutil_env_t * env,
+    axutil_param_t * param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
 
     return axutil_param_container_add_param(transport_in_desc->
-            param_container, env, param);
+                                            param_container, env, param);
 }
 
 axutil_param_t *AXIS2_CALL
-axis2_transport_in_desc_get_param(const axis2_transport_in_desc_t *transport_in_desc,
-    const axutil_env_t *env,
-    const axis2_char_t *param_name)
+axis2_transport_in_desc_get_param(
+    const axis2_transport_in_desc_t * transport_in_desc,
+    const axutil_env_t * env,
+    const axis2_char_t * param_name)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
     return axutil_param_container_get_param(transport_in_desc->param_container,
-            env, param_name);
+                                            env, param_name);
 }
 
 axis2_bool_t AXIS2_CALL
-axis2_transport_in_desc_is_param_locked(axis2_transport_in_desc_t *
-    transport_in_desc,
-    const axutil_env_t *env,
-    const axis2_char_t *param_name)
+axis2_transport_in_desc_is_param_locked(
+    axis2_transport_in_desc_t * transport_in_desc,
+    const axutil_env_t * env,
+    const axis2_char_t * param_name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
 
     return axutil_param_container_is_param_locked(transport_in_desc->
-            param_container, env, param_name);
+                                                  param_container, env,
+                                                  param_name);
 }
 
 AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
-axis2_transport_in_desc_param_container(const axis2_transport_in_desc_t *transport_in_desc,
-    const axutil_env_t *env)
+axis2_transport_in_desc_param_container(
+    const axis2_transport_in_desc_t * transport_in_desc,
+    const axutil_env_t * env)
 {
     return transport_in_desc->param_container;
 }
-
-
-

Modified: webservices/axis2/trunk/c/src/core/description/transport_out_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/description/transport_out_desc.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/description/transport_out_desc.c (original)
+++ webservices/axis2/trunk/c/src/core/description/transport_out_desc.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -25,12 +26,14 @@
     axis2_transport_sender_t *sender;
     axis2_phase_t *out_phase;
     axis2_phase_t *fault_phase;
+
     /** parameter container that holds parameter */
     axutil_param_container_t *param_container;
 };
 
 AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL
-axis2_transport_out_desc_create(const axutil_env_t *env,
+axis2_transport_out_desc_create(
+    const axutil_env_t * env,
     const AXIS2_TRANSPORT_ENUMS trans_enum)
 {
     axis2_transport_out_desc_t *transport_out = NULL;
@@ -38,9 +41,11 @@
     AXIS2_ENV_CHECK(env, NULL);
 
     transport_out = (axis2_transport_out_desc_t *) AXIS2_MALLOC(env->
-            allocator, sizeof(axis2_transport_out_desc_t));
+                                                                allocator,
+                                                                sizeof
+                                                                (axis2_transport_out_desc_t));
 
-    if (! transport_out)
+    if (!transport_out)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -55,7 +60,7 @@
     transport_out->param_container = NULL;
 
     transport_out->param_container = axutil_param_container_create(env);
-    if (! transport_out->param_container)
+    if (!transport_out->param_container)
     {
         axis2_transport_out_desc_free(transport_out, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -66,8 +71,9 @@
 }
 
 void AXIS2_CALL
-axis2_transport_out_desc_free(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_free(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, void);
 
@@ -93,12 +99,12 @@
 
     if (transport_out->out_phase)
     {
-         axis2_phase_free(transport_out->out_phase, env);
+        axis2_phase_free(transport_out->out_phase, env);
     }
 
     if (transport_out->fault_phase)
     {
-         axis2_phase_free(transport_out->fault_phase, env);
+        axis2_phase_free(transport_out->fault_phase, env);
     }
 
     AXIS2_FREE(env->allocator, transport_out);
@@ -107,8 +113,9 @@
 }
 
 void AXIS2_CALL
-axis2_transport_out_desc_free_void_arg(void *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_free_void_arg(
+    void *transport_out,
+    const axutil_env_t * env)
 {
     axis2_transport_out_desc_t *transport_out_l = NULL;
 
@@ -120,16 +127,18 @@
 }
 
 AXIS2_TRANSPORT_ENUMS AXIS2_CALL
-axis2_transport_out_desc_get_enum(const axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_get_enum(
+    const axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return transport_out->trans_enum;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_set_enum(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env,
+axis2_transport_out_desc_set_enum(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env,
     const AXIS2_TRANSPORT_ENUMS trans_enum)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -138,17 +147,19 @@
 }
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_out_desc_get_out_flow(const axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_get_out_flow(
+    const axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return transport_out->out_flow;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_set_out_flow(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env,
-    axis2_flow_t *out_flow)
+axis2_transport_out_desc_set_out_flow(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env,
+    axis2_flow_t * out_flow)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, out_flow, AXIS2_FAILURE);
@@ -162,16 +173,18 @@
 }
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_out_desc_get_fault_out_flow(const axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_get_fault_out_flow(
+    const axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     return transport_out->fault_out_flow;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_set_fault_out_flow(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env,
-    axis2_flow_t *fault_out_flow)
+axis2_transport_out_desc_set_fault_out_flow(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env,
+    axis2_flow_t * fault_out_flow)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE);
@@ -185,17 +198,19 @@
 }
 
 axis2_transport_sender_t *AXIS2_CALL
-axis2_transport_out_desc_get_sender(const axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_get_sender(
+    const axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return transport_out->sender;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_set_sender(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env,
-    axis2_transport_sender_t *sender)
+axis2_transport_out_desc_set_sender(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env,
+    axis2_transport_sender_t * sender)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, sender, AXIS2_FAILURE);
@@ -210,8 +225,9 @@
 }
 
 axis2_phase_t *AXIS2_CALL
-axis2_transport_out_desc_get_out_phase(const axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_get_out_phase(
+    const axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -219,24 +235,26 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_set_out_phase(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env,
-    axis2_phase_t *out_phase)
+axis2_transport_out_desc_set_out_phase(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env,
+    axis2_phase_t * out_phase)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, out_phase, AXIS2_FAILURE);
 
     if (transport_out->out_phase)
     {
-         axis2_phase_free(transport_out->out_phase, env);
+        axis2_phase_free(transport_out->out_phase, env);
     }
     transport_out->out_phase = out_phase;
     return AXIS2_SUCCESS;
 }
 
 axis2_phase_t *AXIS2_CALL
-axis2_transport_out_desc_get_fault_phase(const axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env)
+axis2_transport_out_desc_get_fault_phase(
+    const axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
@@ -244,16 +262,17 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_set_fault_phase(axis2_transport_out_desc_t *transport_out,
-    const axutil_env_t *env,
-    axis2_phase_t *fault_phase)
+axis2_transport_out_desc_set_fault_phase(
+    axis2_transport_out_desc_t * transport_out,
+    const axutil_env_t * env,
+    axis2_phase_t * fault_phase)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE);
 
     if (transport_out->fault_phase)
     {
-         axis2_phase_free(transport_out->fault_phase, env);
+        axis2_phase_free(transport_out->fault_phase, env);
     }
     transport_out->fault_phase = fault_phase;
     return AXIS2_SUCCESS;
@@ -261,47 +280,48 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_out_desc_add_param(axis2_transport_out_desc_t *transport_out_desc,
-    const axutil_env_t *env,
-    axutil_param_t *param)
+axis2_transport_out_desc_add_param(
+    axis2_transport_out_desc_t * transport_out_desc,
+    const axutil_env_t * env,
+    axutil_param_t * param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
 
     return axutil_param_container_add_param(transport_out_desc->
-        param_container, env, param);
+                                            param_container, env, param);
 }
 
 axutil_param_t *AXIS2_CALL
-axis2_transport_out_desc_get_param(const axis2_transport_out_desc_t *transport_out_desc,
-    const axutil_env_t *env,
-    const axis2_char_t *param_name)
+axis2_transport_out_desc_get_param(
+    const axis2_transport_out_desc_t * transport_out_desc,
+    const axutil_env_t * env,
+    const axis2_char_t * param_name)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
     return axutil_param_container_get_param(transport_out_desc->param_container,
-        env, param_name);
+                                            env, param_name);
 }
 
 axis2_bool_t AXIS2_CALL
-axis2_transport_out_desc_is_param_locked(axis2_transport_out_desc_t *
-    transport_out_desc,
-    const axutil_env_t *env,
-    const axis2_char_t *param_name)
+axis2_transport_out_desc_is_param_locked(
+    axis2_transport_out_desc_t * transport_out_desc,
+    const axutil_env_t * env,
+    const axis2_char_t * param_name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
 
     return axutil_param_container_is_param_locked(transport_out_desc->
-        param_container, env, param_name);
+                                                  param_container, env,
+                                                  param_name);
 }
 
 AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL
-axis2_transport_out_desc_param_container(const axis2_transport_out_desc_t *transport_out_desc,
-    const axutil_env_t *env)
+axis2_transport_out_desc_param_container(
+    const axis2_transport_out_desc_t * transport_out_desc,
+    const axutil_env_t * env)
 {
     return transport_out_desc->param_container;
 }
-
-
-

Modified: webservices/axis2/trunk/c/src/core/engine/addr_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/engine/addr_disp.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/engine/addr_disp.c (original)
+++ webservices/axis2/trunk/c/src/core/engine/addr_disp.c Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -27,26 +28,23 @@
 
 const axis2_char_t *AXIS2_ADDR_DISP_NAME = "addressing_based_dispatcher";
 
-static axis2_status_t AXIS2_CALL
-axis2_addr_disp_invoke(
-    axis2_handler_t *handler,
-    const axutil_env_t *env,
+static axis2_status_t AXIS2_CALL axis2_addr_disp_invoke(
+    axis2_handler_t * handler,
+    const axutil_env_t * env,
     struct axis2_msg_ctx *msg_ctx);
 
-static axis2_svc_t *AXIS2_CALL
-axis2_addr_disp_find_svc(
-    axis2_msg_ctx_t *msg_ctx,
-    const axutil_env_t *env);
-
-static axis2_op_t *AXIS2_CALL
-axis2_addr_disp_find_op(
-    axis2_msg_ctx_t *msg_ctx,
-    const axutil_env_t *env,
-    axis2_svc_t *svc);
+static axis2_svc_t *AXIS2_CALL axis2_addr_disp_find_svc(
+    axis2_msg_ctx_t * msg_ctx,
+    const axutil_env_t * env);
+
+static axis2_op_t *AXIS2_CALL axis2_addr_disp_find_op(
+    axis2_msg_ctx_t * msg_ctx,
+    const axutil_env_t * env,
+    axis2_svc_t * svc);
 
 axis2_disp_t *AXIS2_CALL
 axis2_addr_disp_create(
-    const axutil_env_t *env)
+    const axutil_env_t * env)
 {
     axis2_disp_t *disp = NULL;
     axis2_handler_t *handler = NULL;
@@ -54,7 +52,9 @@
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    name = axutil_string_create_const(env, (axis2_char_t**)&AXIS2_ADDR_DISP_NAME);
+    name =
+        axutil_string_create_const(env,
+                                   (axis2_char_t **) & AXIS2_ADDR_DISP_NAME);
     if (!name)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -72,7 +72,8 @@
     handler = axis2_disp_get_base(disp, env);
     if (!handler)
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
+                        AXIS2_FAILURE);
         axutil_string_free(name, env);
         return NULL;
     }
@@ -86,15 +87,15 @@
 
 static axis2_svc_t *AXIS2_CALL
 axis2_addr_disp_find_svc(
-    axis2_msg_ctx_t *msg_ctx,
-    const axutil_env_t *env)
+    axis2_msg_ctx_t * msg_ctx,
+    const axutil_env_t * env)
 {
     axis2_endpoint_ref_t *endpoint_ref = NULL;
     axis2_svc_t *svc = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    endpoint_ref =  axis2_msg_ctx_get_to(msg_ctx, env);
+    endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env);
 
     if (endpoint_ref)
     {
@@ -105,13 +106,15 @@
         {
             axis2_char_t **url_tokens = NULL;
             AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
-                    "Checking for service using WSA enpoint address : %s", address);
+                            "Checking for service using WSA enpoint address : %s",
+                            address);
 
             if ((axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL, address) == 0) ||
-                    (axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, address) == 0))
+                (axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, address) == 0))
             {
-                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
-                    "Endpoint address cannot be the same as WSA namespace : %s", address);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                "Endpoint address cannot be the same as WSA namespace : %s",
+                                address);
                 return NULL;
             }
 
@@ -123,11 +126,11 @@
                 {
                     axis2_conf_ctx_t *conf_ctx = NULL;
 
-                    conf_ctx =  axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
+                    conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
                     if (conf_ctx)
                     {
                         axis2_conf_t *conf = NULL;
-                        conf =  axis2_conf_ctx_get_conf(conf_ctx, env);
+                        conf = axis2_conf_ctx_get_conf(conf_ctx, env);
                         if (conf)
                         {
                             svc = axis2_conf_get_svc(conf, env, url_tokens[0]);
@@ -135,7 +138,7 @@
                             if (svc)
                             {
                                 AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
-                                        "Service found using WSA enpoint address");
+                                                "Service found using WSA enpoint address");
                             }
                         }
                     }
@@ -156,9 +159,9 @@
 
 static axis2_op_t *AXIS2_CALL
 axis2_addr_disp_find_op(
-    axis2_msg_ctx_t *msg_ctx,
-    const axutil_env_t *env,
-    axis2_svc_t *svc)
+    axis2_msg_ctx_t * msg_ctx,
+    const axutil_env_t * env,
+    axis2_svc_t * svc)
 {
     const axis2_char_t *action = NULL;
     axutil_qname_t *name = NULL;
@@ -167,36 +170,35 @@
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, svc, NULL);
 
-    action =  axis2_msg_ctx_get_wsa_action(msg_ctx, env);
+    action = axis2_msg_ctx_get_wsa_action(msg_ctx, env);
 
     if (action)
     {
         AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
-                "Checking for operation using WSA Action : %s", action);
+                        "Checking for operation using WSA Action : %s", action);
 
         name = axutil_qname_create(env, action, NULL, NULL);
         op = axis2_svc_get_op_with_qname(svc, env, name);
         if (op)
             AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
-                    "Operation found using WSA Action");
+                            "Operation found using WSA Action");
         axutil_qname_free(name, env);
     }
 
     return op;
 }
 
-
 static axis2_status_t AXIS2_CALL
 axis2_addr_disp_invoke(
-    axis2_handler_t *handler,
-    const axutil_env_t *env,
+    axis2_handler_t * handler,
+    const axutil_env_t * env,
     struct axis2_msg_ctx *msg_ctx)
 {
     axis2_relates_to_t *relates_to = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    relates_to =  axis2_msg_ctx_get_relates_to(msg_ctx, env);
+    relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env);
 
     /** first check if we can dispatch using the relates_to */
     if (relates_to)
@@ -207,40 +209,45 @@
         {
             axis2_conf_ctx_t *conf_ctx = NULL;
 
-            conf_ctx =  axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
+            conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
             if (conf_ctx)
             {
                 axis2_op_ctx_t *op_ctx = NULL;
-                const axis2_char_t *msg_id =  axis2_msg_ctx_get_msg_id(msg_ctx, env);
-                op_ctx =  axis2_conf_ctx_get_op_ctx(conf_ctx, env, msg_id);
+                const axis2_char_t *msg_id =
+                    axis2_msg_ctx_get_msg_id(msg_ctx, env);
+                op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, msg_id);
                 if (op_ctx)
                 {
                     axis2_op_t *op = NULL;
-                    op =  axis2_op_ctx_get_op(op_ctx, env);
+                    op = axis2_op_ctx_get_op(op_ctx, env);
                     if (op)
                     {
                         axis2_svc_ctx_t *svc_ctx = NULL;
-                         axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx);
-                         axis2_msg_ctx_set_op(msg_ctx, env, op);
+                        axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx);
+                        axis2_msg_ctx_set_op(msg_ctx, env, op);
                         axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx);
 
-                        svc_ctx =  axis2_op_ctx_get_parent(op_ctx, env);
+                        svc_ctx = axis2_op_ctx_get_parent(op_ctx, env);
                         if (svc_ctx)
                         {
                             axis2_svc_t *svc = NULL;
                             axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
-                             axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx);
-                            svc =  axis2_svc_ctx_get_svc(svc_ctx, env);
+                            axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx);
+                            svc = axis2_svc_ctx_get_svc(svc_ctx, env);
                             if (svc)
                             {
-                                 axis2_msg_ctx_set_svc(msg_ctx, env, svc);
+                                axis2_msg_ctx_set_svc(msg_ctx, env, svc);
                             }
-                            svc_grp_ctx = axis2_svc_ctx_get_parent(svc_ctx, env);
+                            svc_grp_ctx =
+                                axis2_svc_ctx_get_parent(svc_ctx, env);
                             if (svc_grp_ctx)
                             {
-                                axutil_string_t *svc_grp_ctx_id_str = 
-                                    axutil_string_create(env,  axis2_svc_grp_ctx_get_id(svc_grp_ctx, env));
-                                 axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str);
+                                axutil_string_t *svc_grp_ctx_id_str =
+                                    axutil_string_create(env,
+                                                         axis2_svc_grp_ctx_get_id
+                                                         (svc_grp_ctx, env));
+                                axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env,
+                                                                 svc_grp_ctx_id_str);
                                 axutil_string_free(svc_grp_ctx_id_str, env);
                             }
                             return AXIS2_SUCCESS;
@@ -249,7 +256,7 @@
                 }
             }
         }
-        
+
     }
 
     axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_addr_disp_find_svc);
@@ -257,4 +264,3 @@
 
     return axis2_disp_find_svc_and_op(handler, env, msg_ctx);
 }
-

Modified: webservices/axis2/trunk/c/src/core/engine/axis2_disp_checker.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/engine/axis2_disp_checker.h?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/engine/axis2_disp_checker.h (original)
+++ webservices/axis2/trunk/c/src/core/engine/axis2_disp_checker.h Fri Sep 28 02:52:58 2007
@@ -1,3 +1,4 @@
+
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
@@ -48,9 +49,9 @@
      * @return pointer to base handler, returns a reference not a cloned copy
      */
     AXIS2_EXTERN axis2_handler_t *AXIS2_CALL
-    axis2_disp_checker_get_base(const axis2_disp_checker_t *disp_checker,
-        const axutil_env_t *env);
-
+    axis2_disp_checker_get_base(
+        const axis2_disp_checker_t * disp_checker,
+        const axutil_env_t * env);
 
     /**
      * Gets QName.
@@ -60,8 +61,9 @@
      * cloned copy
      */
     AXIS2_EXTERN axutil_string_t *AXIS2_CALL
-    axis2_disp_checker_get_name(const axis2_disp_checker_t *disp_checker,
-        const axutil_env_t *env);
+    axis2_disp_checker_get_name(
+        const axis2_disp_checker_t * disp_checker,
+        const axutil_env_t * env);
 
     /**
      * Sets QName.
@@ -71,9 +73,10 @@
      * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
     AXIS2_EXTERN axis2_status_t AXIS2_CALL
-    axis2_disp_checker_set_name(axis2_disp_checker_t *disp_checker,
-        const axutil_env_t *env,
-        const axutil_string_t *name);
+    axis2_disp_checker_set_name(
+        axis2_disp_checker_t * disp_checker,
+        const axutil_env_t * env,
+        const axutil_string_t * name);
 
     /**
      * Frees dispatcher checker.
@@ -82,8 +85,9 @@
      * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
     AXIS2_EXTERN void AXIS2_CALL
-    axis2_disp_checker_free(axis2_disp_checker_t *disp_checker,
-        const axutil_env_t *env);
+    axis2_disp_checker_free(
+        axis2_disp_checker_t * disp_checker,
+        const axutil_env_t * env);
 
     /**
      * Creates a dispatcher checker struct instance.
@@ -91,10 +95,11 @@
      * @return pointer to newly created dispatcher checker struct
      */
     AXIS2_EXTERN axis2_disp_checker_t *AXIS2_CALL
-    axis2_disp_checker_create(const axutil_env_t *env);
-    
+    axis2_disp_checker_create(
+        const axutil_env_t * env);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif    /* AXIS2_DISP_CHECKER_H */
+#endif                          /* AXIS2_DISP_CHECKER_H */



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


Mime
View raw message