axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r429691 [1/2] - in /webservices/axis2/trunk/c: include/axis2_conf.h modules/core/engine/addr_disp.c modules/core/engine/conf.c
Date Tue, 08 Aug 2006 15:31:31 GMT
Author: samisa
Date: Tue Aug  8 08:31:30 2006
New Revision: 429691

URL: http://svn.apache.org/viewvc?rev=429691&view=rev
Log:
Fixed doc comments, parameter lists and spellings

Modified:
    webservices/axis2/trunk/c/include/axis2_conf.h
    webservices/axis2/trunk/c/modules/core/engine/addr_disp.c
    webservices/axis2/trunk/c/modules/core/engine/conf.c

Modified: webservices/axis2/trunk/c/include/axis2_conf.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_conf.h?rev=429691&r1=429690&r2=429691&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_conf.h (original)
+++ webservices/axis2/trunk/c/include/axis2_conf.h Tue Aug  8 08:31:30 2006
@@ -24,20 +24,19 @@
  * @}
  */
 
-/** @defgroup axis2_config configuration
+/** 
+ * @defgroup axis2_config configuration
  * @ingroup axis2_engine
- * Axis2 Engine Configuration
- * The palce where all the global states of Axis is accessed.
- * All the global states kept in the <code>EngineRegistry</code> and all the
- * Service states kept in the <code>MessageContext</code>. Other runtime
- * artifacts does not keep states forward from the execution.
+ * Axis2 configuration captures all configuration information. Configuration
+ * information includes user preferences along with module and 
+ * service information that is either statically configured using axis2.xml
+ * file, service.xml files and module.xml files or dynamically using the 
+ * functions defined in the ops struct related to this conf struct.
  * @{
  */
 
 /**
  * @file axis2_config.h
- * @brief axis2 engine configuration interface. Global states of all the Axis2
- * can be accessed here
  */
 
 #include <axis2_param_container.h>
@@ -69,12 +68,13 @@
     struct axis2_dep_engine;
 
     /**
-     * Engine Configuration ops struct
-     * Encapsulator struct for ops of axis2_config
+     * configuration ops struct.
+     * Encapsulator struct for ops of axis2_conf.
      */
     struct axis2_conf_ops
     {
         /**
+         * Frees conf struct.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
@@ -85,9 +85,11 @@
                     const axis2_env_t *env);
 
         /**
+         * Adds a service group to the configuration.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param svc_grp pointer to service group
+         * @param svc_grp pointer to service group, conf takes over the 
+         * ownership of the service group
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
@@ -97,29 +99,37 @@
                     struct axis2_svc_grp *svc_grp);
 
         /** 
+         * Gets a named service group.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param svc_grp_name pointer to service group name
+         * @param svc_grp_name name of the service group to be accessed
+         * @return pointer to service group with the given name if exists, 
+         * else NULL. Returns a reference, not a cloned copy
          */
         struct axis2_svc_grp *(AXIS2_CALL *
                 get_svc_grp)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_char_t *svc_grp_name);
+                    const axis2_char_t *svc_grp_name);
 
         /** 
+         * Gets all service group added to conf.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return pointer to hash table containing the service groups, returns 
+         * a reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_svc_grps)(
+                get_all_svc_grps)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Adds a service to configuration.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param svc pointer to service
+         * @param svc pointer to service, conf takes over the ownership of the 
+         * service
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
@@ -129,20 +139,24 @@
                     struct axis2_svc* svc);
 
         /**
+         * Gets a service with given name.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param svc_name pointer to service name
+         * @param svc_name service name string
+         * @return pointer to service with the given name if exists, else NULL.
+         * Returns a reference, not a cloned copy
          */
         struct axis2_svc *(AXIS2_CALL *
                 get_svc)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_char_t* svc_name);
+                    const axis2_char_t* svc_name);
 
         /**
+         * Removes the named service from configuration.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param name pointer to name
+         * @param name name of service to be removed
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
@@ -152,9 +166,10 @@
                     const axis2_char_t *name);
 
         /**
+         * Adds a parameter to configuration.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param param pointer to param
+         * @param param pointer to parameter struct to be added
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
@@ -164,9 +179,12 @@
                     axis2_param_t *param);
 
         /**
+         * Gets a parameter with the given name.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param name pointer to name
+         * @param name name of the parameter to be accessed
+         * @return pointer to parameter with the given name if exists, else NULL.
+         * Returns a reference, not a cloned copy
          */
         axis2_param_t *(AXIS2_CALL *
                 get_param)(
@@ -175,114 +193,141 @@
                     const axis2_char_t *name);
 
         /**
+         * Gets all the parameters added to the configuration.
          * @param conf pointer to conf struct
          * @param env pointer to environment
+         * @return pointer to array list containing parameters if exists, 
+         * else NULL. Returns a reference, not a cloned copy
          */
         axis2_array_list_t *(AXIS2_CALL *
-                get_params)(
+                get_all_params)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Checks if the named parameter is locked.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param param_name pointer to param name
+         * @param param_name name of the parameter
+         * @return AXIS2_TRUE if parameter is locked, else AXIS2_FALSE
          */
         axis2_bool_t (AXIS2_CALL *
                 is_param_locked)(
-                    axis2_conf_t *conf,
+                    const axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_char_t *param_name);
+                    const axis2_char_t *param_name);
 
         /**
+         * Gets in transport corresponding to the given transport QName.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param qname pointer to qname
+         * @param qname QName of transport 
+         * @return pointer to transport in description if exists, 
+         * else NULL. Returns a reference, not a cloned copy
          */
-        struct axis2_transport_in_desc *(AXIS2_CALL *
+        axis2_transport_in_desc_t *(AXIS2_CALL *
                 get_transport_in)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_qname_t *qname);
+                    const axis2_qname_t *qname);
 
         /**
+         * Adds a transport in description.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param transport  pointer to transport
+         * @param transport  pointer to transport in description. conf assumes
+         * ownership of the struct
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 add_transport_in)(
                     axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    struct axis2_transport_in_desc *transport);
+                    axis2_transport_in_desc_t *transport);
 
         /**
+         * Gets out transport corresponding to the given transport QName.
          * @param conf pointer to conf struct
          * @param env pointer to environment strcut
-         * @param qname pointer to qname
+         * @param qname pointer to transport qname
+         * @return pointer to transport out description if exists, 
+         * else NULL. Returns a reference, not a cloned copy
          */
-        struct axis2_transport_out_desc *(AXIS2_CALL *
+        axis2_transport_out_desc_t *(AXIS2_CALL *
                 get_transport_out)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_qname_t *qname);
+                    const axis2_qname_t *qname);
 
-        /**
+       /**
+        * Adds a transport out description.
         * @param conf pointer to conf struct
         * @param env pointer to environment struct
-        * @param transport pointer to transport
+        * @param transport pointer to transport out description. conf assumes
+        * ownership of the struct
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
         */
         axis2_status_t (AXIS2_CALL *
                 add_transport_out)(
                     axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    struct axis2_transport_out_desc *transport);
+                    axis2_transport_out_desc_t *transport);
 
         /**
+         * Gets all in transports.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return hash table containing all transport in descriptions. 
+         * Returns a reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_transports_in)(
+                get_all_in_transports)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Gets all out transports.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return hash table containing all transport out descriptions. 
+         * Returns a reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_transports_out)(
+                get_all_out_transports)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
-        /**
+
+       /**
+        * Gets a module with given QName.
         * @param conf pointer to conf struct
         * @param env pointer to environment struct
         * @param qname pointer to qname
-        * @return module description
+        * @return module description corresponding to the given qname
         */
-        struct axis2_module_desc *(AXIS2_CALL *
+        axis2_module_desc_t *(AXIS2_CALL *
                 get_module)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env,
                     const axis2_qname_t *qname);
 
-        /**
+       /**
+        * Gets the list of engaged modules.
         * @param conf pointer to conf struct
         * @param env pointer to environment struct
-        * @param qname pointer to qname
-        * @return  collection
+        * @return a pointer to the array list of engaged modules. Returns a 
+        * reference, not a cloned copy
         */
         axis2_array_list_t *(AXIS2_CALL *
-                get_engaged_modules)(
+                get_all_engaged_modules)( 
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Gets the in phases up to and including port dispatch phase.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to the array list of in phases up to post dispatch
+         * inclusive. Returns a reference, not a cloned copy
          */
         axis2_array_list_t *(AXIS2_CALL *
                 get_in_phases_upto_and_including_post_dispatch)(
@@ -290,67 +335,91 @@
                     const axis2_env_t *env);
 
         /**
+         * Gets the out flow. Out flow is a list of phases invoked in the out 
+         * path of execution of the engine.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to the array list of out flow phases. Returns a 
+         * reference, not a cloned copy
          */
         axis2_array_list_t *(AXIS2_CALL *
-                get_outflow)(
+                get_out_flow)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
 
-        /**
+       /**
+        * Gets the in fault flow. In fault flow is a list of phases invoked in 
+        * the in path of execution, if some fault happens.
         * @param conf pointer to conf struct
         * @param env pointer to environment struct
-        * @return array list
+        * @return a pointer to the array list of in fault flow phases. Returns a 
+        * reference, not a cloned copy
         */
         axis2_array_list_t *(AXIS2_CALL *
-                get_in_faultflow)(
+                get_in_fault_flow)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
-        /**
+       /**
+        * Gets the out fault flow. Out fault flow is a list of phases invoked in 
+        * the out path of execution, if some fault happens.
         * @param conf pointer to conf struct
         * @param env pointer to environment struct
-        * @return array list
+        * @return a pointer to the array list of out fault flow phases. Returns a 
+        * reference, not a cloned copy
         */
         axis2_array_list_t *(AXIS2_CALL *
-                get_out_faultflow)(
+                get_out_fault_flow)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Gets faulty services. A faulty service is a service that does not 
+         * meet the service configuration criteria or a service with errors in 
+         * the service dynamic link library.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to the hash table of faulty services. Returns a 
+         * reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_faulty_svcs)(
+                get_all_faulty_svcs)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Gets faulty modules. A faulty module is a module that does not 
+         * meet the module configuration criteria or a module with errors in 
+         * the service dynamic link library.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to the hash table of faulty modules. Returns a 
+         * reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_faulty_modules)(
+                get_all_faulty_modules)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
-        /*
-         * Gets all the services in the system 
+        /**        
+         * Gets all the list of services loaded into configuration.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to the hash table of services. Returns a 
+         * reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_svcs)(
+                get_all_svcs)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Checks is the named module is engaged.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module_name pointer to module name struct
+         * @param module_name pointer to QName representing the module name
+         * @return AXIS2_TRUE if named module is engaged, else AXIS2_FALSE
          */
         axis2_bool_t (AXIS2_CALL *
                 is_engaged)(
@@ -359,8 +428,11 @@
                     const axis2_qname_t *module_name);
 
         /**
+         * Gets phases information struct.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to the struct containing phases information. 
+         * Returns a reference, not a cloned copy
          */
         struct axis2_phases_info *(AXIS2_CALL *
                 get_phases_info)(
@@ -368,9 +440,12 @@
                     const axis2_env_t *env);
 
         /**
+         * Sets phases information struct.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param phases_info pointer to phases_info struct
+         * @param phases_info pointer to phases_info struct. conf assumes 
+         * ownership of the struct
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 set_phases_info)(
@@ -379,22 +454,28 @@
                     struct axis2_phases_info *phases_info);
 
         /**
+         * Adds message receiver with the given key.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param key pointer to key
+         * @param key key string with which the message receive is to be added
          * @param msg_recv pointer to message receiver 
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 add_msg_recv)(
                     axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_char_t *key,
+                    const axis2_char_t *key,
                     struct axis2_msg_recv *msg_recv);
 
         /**
+         * Gets message receiver with the given key.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param key pointer to key
+         * @param key key string corresponding to the message receiver to 
+         * be retrieved
+         * @return pointer to the message receiver with the given key if it 
+         * exists, else null. Returns a reference, not a cloned copy
          */
         struct axis2_msg_recv *(AXIS2_CALL *
                 get_msg_recv)(
@@ -403,9 +484,12 @@
                     axis2_char_t *key);
 
         /**
+         * Sets the list of out phases.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param out_phases ponter to out phases
+         * @param out_phases pointer to array list of the phases. conf assumes 
+         * ownership of the struct
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 set_out_phases)(
@@ -414,8 +498,11 @@
                     axis2_array_list_t *out_phases);
 
         /**
+         * Gets the list of out phases.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return pointer to array list of out phases. Returns a reference, 
+         * not a cloned copy
          */
         axis2_array_list_t *(AXIS2_CALL *
                 get_out_phases)(
@@ -423,40 +510,49 @@
                     const axis2_env_t *env);
 
         /**
+         * Sets fault phases for in path.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param list pointer to list 
+         * @param list pointer to array list of phases
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
-                set_in_faultphases)(
+                set_in_fault_phases)(
                     axis2_conf_t *conf,
                     const axis2_env_t *env,
                     axis2_array_list_t *list);
 
         /**
+         * Sets fault phases for out path.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param list pointer to list
+         * @param list pointer to array list of phases
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
-                set_out_faultphases)(
+                set_out_fault_phases)(
                     axis2_conf_t *conf,
                     const axis2_env_t *env,
                     axis2_array_list_t *list);
 
         /**
+         * Gets all modules configured,
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return a pointer to hash table containing the list of modules. 
+         * Returns a reference, not a cloned copy
          */
         axis2_hash_t *(AXIS2_CALL *
-                get_modules)(
+                get_all_modules)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Adds a module.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module pointer to module
+         * @param module pointer to module struct to be added
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 add_module)(
@@ -465,9 +561,10 @@
                     struct axis2_module_desc *module);
 
         /**
-         * Sets the default dispatching order
+         * Sets the default dispatchers.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 set_default_dispatchers)(
@@ -475,10 +572,11 @@
                     const axis2_env_t *env);
 
         /**
-         * Sets the custom dispatching order
+         * Sets a custom dispatching phase.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param dispatch pointer to dispatch
+         * @param dispatch pointer to phase to be dispatched
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 set_dispatch_phase)(
@@ -487,29 +585,35 @@
                     axis2_phase_t *dispatch);
 
         /**
+         * Gets the repository location.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
+         * @return returns repository location as a string
          */
-        axis2_char_t *(AXIS2_CALL *
-                get_repos)(
+        const axis2_char_t *(AXIS2_CALL *
+                get_repo)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env);
 
         /**
+         * Sets the repository location.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param axis2_repos pointer to axis2_repos struct
+         * @param axis2_repo repository location as a string
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
-                set_repos)(
+                set_repo)(
                     axis2_conf_t *conf,
                     const axis2_env_t *env,
-                    axis2_char_t *axis2_repos);
+                    axis2_char_t *axis2_repo);
 
         /**
+         * Engages the named module.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module_ref pointer to module reference
+         * @param module_ref pointer to the QName of the module to be engaged
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 engage_module)(
@@ -518,9 +622,11 @@
                     const axis2_qname_t *module_ref);
 
         /**
+         * Sets the deployment engine.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param dep_engine pointer to dep_engine 
+         * @param dep_engine pointer to dep_engine struct
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 set_dep_engine)(
@@ -529,20 +635,25 @@
                     struct axis2_dep_engine *dep_engine);
 
         /**
+         * Gets the default module version for the named module.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module_name pointer to module name 
+         * @param module_name module name string
+         * @return default module version as a string
          */
-        axis2_char_t *(AXIS2_CALL *
+        const axis2_char_t *(AXIS2_CALL *
                 get_default_module_version)(
                     const axis2_conf_t *conf,
                     const axis2_env_t *env,
                     const axis2_char_t *module_name);
 
         /**
+         * Gets the default module reference for the named module.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module_name pointer to module name 
+         * @param module_name module name string
+         * @return pointer to the module description struct corresponding to
+         * the given name
          */
         struct axis2_module_desc *(AXIS2_CALL *
                 get_default_module)(
@@ -551,23 +662,27 @@
                     const axis2_char_t *module_name);
 
         /**
+         * Adds a default module version for the named module.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module_name pointer to module name 
-         * @param module_version pointer to module version
+         * @param module_name name of the module
+         * @param module_version default version for the module
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 add_default_module_version)(
                     axis2_conf_t *conf, 
                     const axis2_env_t *env,
-                    axis2_char_t *module_name,
-                    axis2_char_t *module_version);
+                    const axis2_char_t *module_name,
+                    const axis2_char_t *module_version);
 
         /**
+         * Engages the module with the given version.
          * @param conf pointer to conf struct
          * @param env pointer to environment struct
-         * @param module_name pointer to module name
-         * @param version_id pointer to version
+         * @param module_name name of the module to be engaged
+         * @param version_id version of the module to be engaged
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
          */
         axis2_status_t (AXIS2_CALL *
                 engage_module_with_version)(
@@ -579,207 +694,207 @@
     };
 
     /**
-     * engine configuration struct
+     * configuration struct.
      */
     struct axis2_conf
     {
-        /** operations of engine configuration struct */
+        /** operations of configuration struct */
         axis2_conf_ops_t *ops;
+        /** configuration parameter container */
         axis2_param_container_t *param_container;
     };
 
-    /** create Engine configuration struct
+    /** 
+     * Creates configuration struct.
      * @param env pointer to environment struct
-     * @return pointer to newly created engine configuration
+     * @return pointer to newly created configuration
      */
     AXIS2_EXTERN axis2_conf_t *AXIS2_CALL
     axis2_conf_create(
         const axis2_env_t *env);
 
 
-/************************* Start of function macros   ***************************/
-
 /** Frees the conf.
     @sa axis2_conf_ops#free */
 #define AXIS2_CONF_FREE(conf, env) \
       ((conf)->ops->free(conf, env))
 
-/** Adds teh service group.
+/** Adds a service group.
     @sa axis2_conf_ops#add_svc_grp */
 #define AXIS2_CONF_ADD_SVC_GRP(conf, env, svc_grp) \
         ((conf)->ops->add_svc_grp (conf, env, svc_grp))
 
-/** Gets the service group.
+/** Gets the named service group.
     @sa axis2_conf_ops#get_svc_grp */
 #define AXIS2_CONF_GET_SVC_GRP(conf, env, svc_grp_name) \
         ((conf)->ops->get_svc_grp (conf, env, svc_grp_name))
 
-/** Gets the service groups.
-    @sa axis2_conf_ops#get_svc_grps */
-#define AXIS2_CONF_GET_SVC_GRPS(conf, env) \
-        ((conf)->ops->get_svc_grps (conf, env))
+/** Gets all the service groups.
+    @sa axis2_conf_ops#get_all_svc_grps */
+#define AXIS2_CONF_GET_ALL_SVC_GRPS(conf, env) \
+        ((conf)->ops->get_all_svc_grps (conf, env))
 
-/** Adds the service.
+/** Adds a service.
     @sa axis2_conf_ops#add_svc */
 #define AXIS2_CONF_ADD_SVC(conf, env, svc) \
       ((conf)->ops->add_svc (conf, env, svc))
 
-/** Gets the service.
+/** Gets the named service.
     @sa axis2_conf_ops#get_svc */
 #define AXIS2_CONF_GET_SVC(conf, env, svc_name) \
       ((conf)->ops->get_svc (conf, env, svc_name))
 
-/** Removes the service.
+/** Removes the named service.
     @sa axis2_conf_ops#remove_svc */
 #define AXIS2_CONF_REMOVE_SVC(conf, env, svc_name) \
       ((conf)->ops->remove_svc (conf, env, svc_name))
 
-/** Adds the param.
+/** Adds a parameter.
     @sa axis2_conf_ops#add_param */
 #define AXIS2_CONF_ADD_PARAM(conf, env, param) \
         ((conf)->ops->add_param(conf , env, param))
 
-/** Gets the param.
+/** Gets the named parameter.
     @sa axis2_conf_ops#get_param */
 #define AXIS2_CONF_GET_PARAM(conf, env, name) \
         ((conf)->ops->get_param(conf , env, name))
 
-/** Gets the params.
-    @sa axis2_conf_ops#_get_params */
-#define AXIS2_CONF_GET_PARAMS(conf, env) \
-        ((conf)->ops->get_params(conf , env))
+/** Gets all the parameters.
+    @sa axis2_conf_ops#get_all_params */
+#define AXIS2_CONF_GET_ALL_PARAMS(conf, env) \
+        ((conf)->ops->get_all_params(conf , env))
 
-/** Is param locked.
+/** Checks is the named parameter is locked.
     @sa axis2_conf_ops#is_param_locked */
 #define AXIS2_CONF_IS_PARAM_LOCKED(conf, env, param_name) \
         ((conf)->ops->is_param_locked(conf, env, param_name))
 
-/** Gets the transport in.
+/** Gets transport in description with given QName.
     @sa axis2_conf_ops#get_transport_in */
 #define AXIS2_CONF_GET_TRANSPORT_IN(conf, env, qname) \
         ((conf)->ops->get_transport_in(conf , env, qname))
 
-/** Adds the transport in.
+/** Adds a transport in.
     @sa axis2_conf_ops#add_transport_in */
 #define AXIS2_CONF_ADD_TRANSPORT_IN(conf, env, transport) \
         ((conf)->ops->add_transport_in(conf , env, transport))
 
-/** Gets the transport out.
+/** Gets transport out description with given QName.
     @sa axis2_conf_ops#get_transport_out */
 #define AXIS2_CONF_GET_TRANSPORT_OUT(conf, env, qname) \
         ((conf)->ops->get_transport_out(conf , env, qname))
 
-/** Adds the transport out
+/** Adds a transport out.
     @sa axis2_conf_ops#add_transport_out */
 #define AXIS2_CONF_ADD_TRANSPORT_OUT(conf, env, transport) \
         ((conf)->ops->add_transport_out(conf , env, transport))
 
-/** Gets the transports in.
-    @sa axis2_conf_ops#get_transport_in */
-#define AXIS2_CONF_GET_TRANSPORTS_IN(conf, env) \
-        ((conf)->ops->get_transports_in(conf , env))
+/** Gets all the in transports.
+    @sa axis2_conf_ops#get_all_in_transports */
+#define AXIS2_CONF_GET_ALL_IN_TRANSPORTS(conf, env) \
+        ((conf)->ops->get_all_in_transports(conf , env))
+
+/** Gets all the out transport.
+    @sa axis2_conf_ops#get_all_out_transports */
+#define AXIS2_CONF_GET_ALL_OUT_TRANSPORTS(conf, env) \
+        ((conf)->ops->get_all_out_transports(conf , env))
 
-/** Gets the transport out.
-    @sa axis2_conf_ops#get_transport_out */
-#define AXIS2_CONF_GET_TRANSPORTS_OUT(conf, env) \
-        ((conf)->ops->get_transports_out(conf , env))
-
-/** Gets the module.
+/** Gets the named module.
     @sa axis2_conf_ops#get_module */
 #define AXIS2_CONF_GET_MODULE(conf, env, qname) \
         ((conf)->ops->get_module(conf , env, qname))
 
-/** Gets the engaged modules.
-    @sa axis2_conf_ops#get_engaged_modules */
-#define AXIS2_CONF_GET_ENGAGED_MODULES(conf, env) \
-        ((conf)->ops->get_engaged_modules(conf , env))
+/** Gets all the engaged modules.
+    @sa axis2_conf_ops#get_all_engaged_modules */
+#define AXIS2_CONF_GET_ALL_ENGAGED_MODULES(conf, env) \
+        ((conf)->ops->get_all_engaged_modules(conf , env))
 
-/** Get in phases upot and including post dispatch.
+/** Get in phases up to and including post dispatch.
     @sa axis2_conf_ops#get_in_phases_upto_and_including_post_dispatch */
 #define AXIS2_CONF_GET_IN_PHASES_UPTO_AND_INCLUDING_POST_DISPATCH(conf, env) \
         ((conf)->ops->get_in_phases_upto_and_including_post_dispatch(conf , env))
 
-/** Gets the outflow.
-    @sa axis2_conf_ops#get_outflow */
-#define AXIS2_CONF_GET_OUTFLOW(conf, env) \
-        ((conf)->ops->get_outflow(conf , env))
+/** Gets out flow.
+    @sa axis2_conf_ops#get_out_flow */
+#define AXIS2_CONF_GET_OUT_FLOW(conf, env) \
+        ((conf)->ops->get_out_flow(conf , env))
 
-/** Gets the in fault flow.
+/** Gets in fault flow.
     @sa axis2_conf_ops#get_in_fault_flow */
 #define AXIS2_CONF_GET_IN_FAULT_FLOW(conf, env) \
-        ((conf)->ops->get_in_faultflow(conf , env))
+        ((conf)->ops->get_in_fault_flow(conf , env))
 
-/** Gets the out fault flow.
+/** Gets out fault flow.
     @sa axis2_conf_ops#get_out_fault_flow */
 #define AXIS2_CONF_GET_OUT_FAULT_FLOW(conf, env) \
-        ((conf)->ops->get_out_faultflow(conf , env))
+        ((conf)->ops->get_out_fault_flow(conf , env))
 
-/** Gets the faulty services.
-    @sa axis2_conf_ops#get_faulty_svcs */
-#define AXIS2_CONF_GET_FAULTY_SVCS(conf, env) \
-        ((conf)->ops->get_faulty_svcs(conf , env))
-
-/** Gets the faulty modules.
-    @sa axis2_conf_ops#get_faulty_modules */
-#define AXIS2_CONF_GET_FAULTY_MODULES(conf, env) \
-        ((conf)->ops->get_faulty_modules(conf , env))
-
-/** Gets the services.
-    @sa axis2_conf_ops#get_svcs */
-#define AXIS2_CONF_GET_SVCS(conf, env) \
-        ((conf)->ops->get_svcs(conf , env))
+/** Gets all faulty services.
+    @sa axis2_conf_ops#get_all_faulty_svcs */
+#define AXIS2_CONF_GET_ALL_FAULTY_SVCS(conf, env) \
+        ((conf)->ops->get_all_faulty_svcs(conf , env))
+
+/** Gets all faulty modules.
+    @sa axis2_conf_ops#get_all_faulty_modules */
+#define AXIS2_CONF_GET_ALL_FAULTY_MODULES(conf, env) \
+        ((conf)->ops->get_all_faulty_modules(conf , env))
+
+/** Gets all services.
+    @sa axis2_conf_ops#get_all_svcs */
+#define AXIS2_CONF_GET_ALL_SVCS(conf, env) \
+        ((conf)->ops->get_all_svcs(conf , env))
 
-/** Is engaged.
+/** Checks if the named module is engaged.
     @sa axis2_conf_ops#is_engaged */
 #define AXIS2_CONF_IS_ENGAGED(conf, env, module_name) \
         ((conf)->ops->is_engaged(conf , env, module_name))
 
-/** Gets the phase info.
-    @sa axis2_conf_ops#get_phasesinfo */
-#define AXIS2_CONF_GET_PHASESINFO(conf, env) \
+/** Gets phase information.
+    @sa axis2_conf_ops#get_phases_info */
+#define AXIS2_CONF_GET_PHASES_INFO(conf, env) \
         ((conf)->ops->get_phases_info(conf , env))
 
-/** Sets the phase info.
-    @sa axis2_conf_ops#set_phasesinfo */
-#define AXIS2_CONF_SET_PHASESINFO(conf, env, phases_info) \
+/** Sets phase information.
+    @sa axis2_conf_ops#set_phases_info */
+#define AXIS2_CONF_SET_PHASES_INFO(conf, env, phases_info) \
         ((conf)->ops->set_phases_info(conf , env, phases_info))
 
-/** Adds the message receiver.
+/** Adds a message receiver with the given name.
     @sa axis2_conf_ops#add_msg_recv */
 #define AXIS2_CONF_ADD_MSG_RECV(conf, env, key, msg_recv) \
         ((conf)->ops->add_msg_recv(conf , env, key, msg_recv))
 
-/** Gets the message receiver.
+/** Gets the message receiver with given key.
     @sa axis2_conf_ops#get_msg_recv */
 #define AXIS2_CONF_GET_MSG_RECV(conf, env, key) \
         ((conf)->ops->get_msg_recv(conf , env, key))
 
-/** Sets the out phases.
+/** Sets out phases.
     @sa axis2_conf_ops#set_out_phases */
 #define AXIS2_CONF_SET_OUT_PHASES(conf, env, out_phases) \
         ((conf)->ops->set_out_phases(conf , env, out_phases))
 
-/** Gets the out phases.
+/** Gets out phases.
     @sa axis2_conf_ops#get_out_phases */
 #define AXIS2_CONF_GET_OUT_PHASES(conf, env) \
         ((conf)->ops->get_out_phases(conf , env))
 
 /** Sets in fault phases.
-    @sa axis2_conf_ops#set_in_faultphases */
-#define AXIS2_CONF_SET_IN_FAULTPHASES(conf, env, list) \
-        ((conf)->ops->set_in_faultphases(conf , env, list))
+    @sa axis2_conf_ops#set_in_fault_phases */
+#define AXIS2_CONF_SET_IN_FAULT_PHASES(conf, env, list) \
+        ((conf)->ops->set_in_fault_phases(conf , env, list))
 
 /** Sets out fault phases.
-    @sa axis2_conf_ops#set_out_faultphases */
-#define AXIS2_CONF_SET_OUT_FAULTPHASES(conf, env, list) \
-        ((conf)->ops->set_out_faultphases(conf , env, list))
-
-/** Gets the modules.
-    @sa axis2_conf_ops#get_modules */
-#define AXIS2_CONF_GET_MODULES(conf, env) \
-        ((conf)->ops->get_modules(conf , env))
+    @sa axis2_conf_ops#set_out_fault_phases */
+#define AXIS2_CONF_SET_OUT_FAULT_PHASES(conf, env, list) \
+        ((conf)->ops->set_out_fault_phases(conf , env, list))
+
+/** Gets all the modules.
+    @sa axis2_conf_ops#get_all_modules */
+#define AXIS2_CONF_GET_ALL_MODULES(conf, env) \
+        ((conf)->ops->get_all_modules(conf , env))
 
-/** Adds the modules.
+/** Adds a module.
     @sa axis2_conf_ops#add_module */
 #define AXIS2_CONF_ADD_MODULE(conf, env, module) \
         ((conf)->ops->add_module(conf , env, module))
@@ -789,27 +904,27 @@
 #define AXIS2_CONF_SET_DEFAULT_DISPATCHERS(conf, env) \
         ((conf)->ops->set_default_dispatchers(conf , env))
 
-/** Sets the dispatch phase.
+/** Sets a custom dispatch phase.
     @sa axis2_conf_ops#set_dispatch_phase */
 #define AXIS2_CONF_SET_DISPATCH_PHASE(conf, env, dispatch) \
         ((conf)->ops->set_dispatch_phase(conf , env, dispatch))
 
-/** Gets the repos.
-    @sa axis2_conf_ops#get_repos */
-#define AXIS2_CONF_GET_REPOS(conf, env) \
-        ((conf)->ops->get_repos(conf , env))
-
-/** Sets the repos.
-    @sa axis2_conf_ops#set_repos */
-#define AXIS2_CONF_SET_REPOS(conf, env, axis2_repos) \
-        ((conf)->ops->set_repos(conf , env, axis2_repos))
+/** Gets repository location.
+    @sa axis2_conf_ops#get_repo */
+#define AXIS2_CONF_GET_REPO(conf, env) \
+        ((conf)->ops->get_repo(conf , env))
+
+/** Sets repository location.
+    @sa axis2_conf_ops#set_repo */
+#define AXIS2_CONF_SET_REPO(conf, env, axis2_repos) \
+        ((conf)->ops->set_repo(conf , env, axis2_repos))
 
-/** Engages the module.
+/** Engages a module.
     @sa axis2_conf_ops#engage_module */
 #define AXIS2_CONF_ENGAGE_MODULE(conf, env, module_ref) \
         ((conf)->ops->engage_module(conf , env, module_ref))
 
-/** Sets the dip engine.
+/** Sets the deployment engine.
     @sa axis2_conf_ops#set_dep_engine */
 #define AXIS2_CONF_SET_DEP_ENGINE(conf, env, dep_engine) \
         ((conf)->ops->set_dep_engine(conf, env, dep_engine))
@@ -824,17 +939,15 @@
 #define AXIS2_CONF_GET_DEFAULT_MODULE(conf, env, module_name)\
         ((conf)->ops->get_default_module(conf, env, module_name))
 
-/** Adds the default module version.
+/** Adds the default module version for a named module.
     @sa axis2_conf_ops#add_default_module_version */
 #define AXIS2_CONF_ADD_DEFAULT_MODULE_VERSION(conf, env, mod_name, mod_ver)\
         ((conf)->ops->add_default_module_version(conf, env, mod_name, mod_ver))
 
-/** Engages the module with version.
+/** Engages a module with a given version.
     @sa axis2_conf_ops#engage_module_with_version */
 #define AXIS2_CONF_ENGAGE_MODULE_WITH_VERSION(conf, env, mod_name, mod_ver)\
         ((conf)->ops->engage_module_with_version(conf, env, mod_name, mod_ver))
-
-/************************* End of function macros *****************************/
 
 /** @} */
 #ifdef __cplusplus

Modified: webservices/axis2/trunk/c/modules/core/engine/addr_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/addr_disp.c?rev=429691&r1=429690&r2=429691&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/addr_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/addr_disp.c Tue Aug  8 08:31:30 2006
@@ -1,18 +1,18 @@
 /*
- * Copyright 2004,2005 The Apache Software Foundation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+* Copyright 2004,2005 The Apache Software Foundation.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 
 #include <axis2_disp.h>
 #include <axis2_handler_desc.h>
@@ -24,106 +24,95 @@
 #include <axis2_addr.h>
 #include <axis2_utils.h>
 
-axis2_status_t AXIS2_CALL 
-axis2_addr_disp_invoke (struct axis2_handler * handler, 
-                        const axis2_env_t *env,
-                        struct axis2_msg_ctx *msg_ctx);
-                        
-axis2_svc_t* AXIS2_CALL 
-axis2_addr_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
-                        const axis2_env_t *env);
-                        
-axis2_op_t* AXIS2_CALL 
-axis2_addr_disp_find_op(axis2_msg_ctx_t *msg_ctx, 
-                        const axis2_env_t *env,
-                        axis2_svc_t *svc);
-                        
-
-
-axis2_disp_t* AXIS2_CALL 
-axis2_addr_disp_create(const axis2_env_t *env) 
+axis2_status_t AXIS2_CALL
+axis2_addr_disp_invoke (
+    axis2_handler_t *handler,
+    const axis2_env_t *env,
+    struct axis2_msg_ctx *msg_ctx);
+
+axis2_svc_t *AXIS2_CALL
+axis2_addr_disp_find_svc(
+    axis2_msg_ctx_t *msg_ctx,
+    const axis2_env_t *env);
+
+axis2_op_t *AXIS2_CALL
+axis2_addr_disp_find_op(
+    axis2_msg_ctx_t *msg_ctx,
+    const axis2_env_t *env,
+    axis2_svc_t *svc);
+
+axis2_disp_t *AXIS2_CALL
+axis2_addr_disp_create(
+    const axis2_env_t *env)
 {
     axis2_disp_t *disp = NULL;
     axis2_handler_t *handler = NULL;
     axis2_qname_t *qname = NULL;
-    
+
     AXIS2_ENV_CHECK(env, NULL);
 
-    qname = axis2_qname_create(env, "addressing_based_dispatcher", 
-                                                "http://axis.ws.apache.org",
-                                                NULL);
-    
+    qname = axis2_qname_create(env, "addressing_based_dispatcher",
+            "http://axis.ws.apache.org",
+            NULL);
+
     disp = axis2_disp_create(env, qname);
     if (!disp)
-    { 
+    {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;        
+        return NULL;
     }
-    
+
     handler = AXIS2_DISP_GET_BASE(disp, env);
     if (!handler)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
-        return NULL;        
+        return NULL;
     }
 
     handler->ops->invoke = axis2_addr_disp_invoke;
-    
+
     AXIS2_QNAME_FREE(qname, env);
-    
+
     return disp;
 }
 
-    
-/** The struct that inherits from this struct
-    should implement the find_service and find_op methods and assing the 
-    respective function pointers in the base struct.
-    Here we have only the dummy implementation to gauard against erros due to 
-    the failure to provide an impl version by mistake.
- */
-
-/**
- * finds the service
- *
- * @param messageContext
- * @return
- */
-axis2_svc_t* AXIS2_CALL 
-axis2_addr_disp_find_svc(axis2_msg_ctx_t *msg_ctx, 
-                         const axis2_env_t *env) 
-{    
+axis2_svc_t *AXIS2_CALL
+axis2_addr_disp_find_svc(
+    axis2_msg_ctx_t *msg_ctx,
+    const axis2_env_t *env)
+{
     axis2_endpoint_ref_t *endpoint_ref = NULL;
     axis2_svc_t *svc = NULL;
-    
-    AXIS2_ENV_CHECK(env, NULL);    
-    
+
+    AXIS2_ENV_CHECK(env, NULL);
+
     endpoint_ref = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
-    
+
     if (endpoint_ref)
     {
-        axis2_char_t *address = NULL;        
+        axis2_char_t *address = NULL;
 
         address = AXIS2_ENDPOINT_REF_GET_ADDRESS(endpoint_ref, env);
         if (address)
         {
             axis2_char_t **url_tokens = NULL;
-            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
-                "Checking for service using WSA enpoint address : %s", address);
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                    "Checking for service using WSA enpoint address : %s", address);
 
-            if ( (AXIS2_STRCMP(AXIS2_WSA_ANONYMOUS_URL, address) == 0 ) || 
-                  (AXIS2_STRCMP(AXIS2_WSA_NAMESPACE_SUBMISSION, address) == 0 ))
+            if ( (AXIS2_STRCMP(AXIS2_WSA_ANONYMOUS_URL, address) == 0 ) ||
+                    (AXIS2_STRCMP(AXIS2_WSA_NAMESPACE_SUBMISSION, address) == 0 ))
             {
                 return NULL;
             }
-            
+
             url_tokens = axis2_parse_request_url_for_svc_and_op(env, address);
-            
+
             if (url_tokens)
-            {                
+            {
                 if (url_tokens[0])
-                {                    
+                {
                     axis2_conf_ctx_t *conf_ctx = NULL;
-                    
+
                     conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
                     if (conf_ctx)
                     {
@@ -132,79 +121,74 @@
                         if (conf)
                         {
                             axis2_qname_t *qname = axis2_qname_create(env, url_tokens[0], NULL, NULL);
-                
+
                             svc = AXIS2_CONF_GET_SVC(conf, env, AXIS2_QNAME_GET_LOCALPART(qname, env));
-                            
+
                             AXIS2_QNAME_FREE(qname, env);
-                            if(svc)
-                                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
+                            if (svc)
+                                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                                         "Service found using WSA enpoint address");
                         }
-                    }                    
+                    }
                     AXIS2_FREE(env->allocator, url_tokens[0]);
                 }
-                if(url_tokens[1])
+                if (url_tokens[1])
                 {
                     AXIS2_FREE(env->allocator, url_tokens[1]);
                 }
                 AXIS2_FREE(env->allocator, url_tokens);
-                url_tokens = NULL; 
+                url_tokens = NULL;
             }
         }
     }
-        
+
     return svc;
 }
 
-/**
- * finds the op
- *
- * @param service
- * @param msg_ctx
- * @return
- */
-axis2_op_t* AXIS2_CALL 
-axis2_addr_disp_find_op(axis2_msg_ctx_t *msg_ctx, 
-                        const axis2_env_t *env,
-                        axis2_svc_t *svc)
+axis2_op_t *AXIS2_CALL
+axis2_addr_disp_find_op(
+    axis2_msg_ctx_t *msg_ctx,
+    const axis2_env_t *env,
+    axis2_svc_t *svc)
 {
     axis2_char_t *action = NULL;
     axis2_qname_t *qname = NULL;
     axis2_op_t *op = NULL;
-    
+
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, svc, NULL);
-    
+
     action = AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx, env);
-    
+
     if (action)
     {
-        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                 "Checking for operation using WSA Action : %s", action);
-        
+
         qname = axis2_qname_create(env, action, NULL, NULL);
         op = AXIS2_SVC_GET_OP_WITH_QNAME(svc, env, qname);
         if (op)
-            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
                     "Operation found using WSA Action");
         AXIS2_QNAME_FREE(qname, env);
     }
-    
+
     return op;
 }
 
 
-axis2_status_t AXIS2_CALL 
-axis2_addr_disp_invoke(struct axis2_handler * handler, 
-                       const axis2_env_t *env,
-                       struct axis2_msg_ctx *msg_ctx)
+axis2_status_t AXIS2_CALL
+axis2_addr_disp_invoke(
+    axis2_handler_t *handler,
+    const axis2_env_t *env,
+    struct axis2_msg_ctx *msg_ctx)
 {
     axis2_relates_to_t *relates_to = NULL;
-    
-    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);    
-    
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
     relates_to = AXIS2_MSG_CTX_GET_RELATES_TO(msg_ctx, env);
-    
+
     /** first check if we can dispatch using the relates_to */
     if (relates_to)
     {
@@ -213,7 +197,7 @@
         if (relates_to_value && AXIS2_STRCMP(relates_to_value, "") != 0 )
         {
             axis2_conf_ctx_t *conf_ctx = NULL;
-            
+
             conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
             if (conf_ctx)
             {
@@ -230,7 +214,7 @@
                         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);
                         if (svc_ctx)
                         {
@@ -245,20 +229,19 @@
                             svc_grp_ctx = AXIS2_SVC_CTX_GET_PARENT(svc_ctx, env);
                             if (svc_grp_ctx)
                             {
-                                AXIS2_MSG_CTX_SET_SVC_GRP_CTX_ID(msg_ctx, env, 
-                                    AXIS2_SVC_GRP_CTX_GET_ID(svc_grp_ctx, env) );
+                                AXIS2_MSG_CTX_SET_SVC_GRP_CTX_ID(msg_ctx, env,
+                                        AXIS2_SVC_GRP_CTX_GET_ID(svc_grp_ctx, env) );
                             }
-                        }                      
-                        
+                        }
                     }
                 }
-            }            
+            }
         }
         return AXIS2_SUCCESS;
     }
-    
+
     msg_ctx->ops->find_svc = axis2_addr_disp_find_svc;
     msg_ctx->ops->find_op = axis2_addr_disp_find_op;
-    
+
     return axis2_disp_invoke(handler, env, msg_ctx);
 }



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