axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From p...@apache.org
Subject svn commit: r431578 - in /webservices/axis2/trunk/c: include/axis2_op.h modules/core/description/flow.c modules/core/description/op.c
Date Tue, 15 Aug 2006 12:00:09 GMT
Author: pini
Date: Tue Aug 15 05:00:08 2006
New Revision: 431578

URL: http://svn.apache.org/viewvc?rev=431578&view=rev
Log:
more formatting changes.

Modified:
    webservices/axis2/trunk/c/include/axis2_op.h
    webservices/axis2/trunk/c/modules/core/description/flow.c
    webservices/axis2/trunk/c/modules/core/description/op.c

Modified: webservices/axis2/trunk/c/include/axis2_op.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_op.h?rev=431578&r1=431577&r2=431578&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_op.h (original)
+++ webservices/axis2/trunk/c/include/axis2_op.h Tue Aug 15 05:00:08 2006
@@ -17,10 +17,15 @@
 #ifndef AXIS2_OP_H
 #define AXIS2_OP_H
 
+/** 
+ * @defgroup axis2_op operation
+ * @ingroup axis2_desc
+ * @{
+ */
 /**
-  * @file axis2_op.h
-  * @brief axis2 op interface
-  */
+ * @file axis2_op.h
+ * @brief axis2 op interface
+ */
 
 #include <axis2_param_container.h>
 #include <axis2_wsdl_op.h>
@@ -41,568 +46,912 @@
 {
 #endif
 
-/** @defgroup axis2_op operation
-  * @ingroup axis2_desc
-  * @{
-  */
-
-struct axis2_wsdl_op;    
-struct axis2_svc;
-struct axis2_msg_recv;
-struct axis2_param_container;
-struct axis2_module_desc; 
-struct axis2_op;
-struct axis2_wsdl_feature;
-struct axis2_wsdl_property; 
-struct axis2_wsdl_fault_ref;  
-struct axis2_relates_to;
-struct axis2_op_ctx;
-struct axis2_svc_ctx;    
-struct axis2_msg_ctx; 
-struct axis2_msg;
-struct axis2_conf;
-typedef struct axis2_op_ops axis2_op_ops_t;    
-typedef struct axis2_op axis2_op_t;    
 
-#define AXIS2_SOAP_ACTION "soapAction"
+    struct axis2_wsdl_op;
+    struct axis2_svc;
+    struct axis2_msg_recv;
+    struct axis2_param_container;
+    struct axis2_module_desc;
+    struct axis2_op;
+    struct axis2_wsdl_feature;
+    struct axis2_wsdl_property;
+    struct axis2_wsdl_fault_ref;
+    struct axis2_relates_to;
+    struct axis2_op_ctx;
+    struct axis2_svc_ctx;
+    struct axis2_msg_ctx;
+    struct axis2_msg;
+    struct axis2_conf;
+    /** Type name for struct axis2_op_ops */
+    typedef struct axis2_op_ops axis2_op_ops_t;
+    /** Type name for struct axis2_op */
+    typedef struct axis2_op axis2_op_t;
 
-/** 
- * @brief Operation ops struct
- * Encapsulator struct for ops of axis2_op
- */    
-AXIS2_DECLARE_DATA struct axis2_op_ops
-{
-    /** 
-     * De-allocate memory
-      * @return status code
-      */
-    axis2_status_t (AXIS2_CALL *
-    free) (axis2_op_t *op, 
-           const axis2_env_t *env);
+#define AXIS2_SOAP_ACTION "soapAction"
 
     /**
-     * De-allocate memory
-     * @param void op to be freed
-      * @return status code
-      */
-    axis2_status_t (AXIS2_CALL *
-    free_void_arg) (void *op, 
+     * Operation ops struct
+     * Encapsulator struct for ops of axis2_op
+     */
+    AXIS2_DECLARE_DATA struct axis2_op_ops
+    {
+        /**
+         * De-allocate memory
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_status_t (AXIS2_CALL *
+                free)(
+                    axis2_op_t *op,
                     const axis2_env_t *env);
 
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_status_t (AXIS2_CALL *
+                free_void_arg)(
+                    void *op,
+                    const axis2_env_t *env);
 
-    /**
-     * Method addParameter
-     *
-     * @param param Parameter that will be added
-     */
-    axis2_status_t (AXIS2_CALL *
-    add_param)(axis2_op_t *op, 
-                const axis2_env_t *env, 
-                axis2_param_t *param);
 
-    /**
-     * Method getParameter
-     *
-     * @param name Name of the parameter
-     */
-    axis2_param_t *(AXIS2_CALL *
-    get_param)(axis2_op_t *op, 
-                const axis2_env_t *env,
-                const axis2_char_t *name);
+        /**
+         * Method addParameter
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param param Parameter that will be added
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_param)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_param_t *param);
 
+        /**
+         * Method getParameter
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param name Name of the parameter
+         */
+        axis2_param_t *(AXIS2_CALL *
+                get_param)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    const axis2_char_t *name);
 
-    axis2_array_list_t *(AXIS2_CALL *
-    get_params) (axis2_op_t *op, 
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_params)(
+                    axis2_op_t *op,
                     const axis2_env_t *env);
 
-    /**
-     * To check whether a given paramter is locked
-     */
-    axis2_bool_t (AXIS2_CALL *
-    is_param_locked) (axis2_op_t *op, 
-                        const axis2_env_t *env,
-                        axis2_char_t *param_name);
-
-    axis2_status_t (AXIS2_CALL *
-    set_parent) (axis2_op_t *op, 
-                 const axis2_env_t *env,
-                 struct axis2_svc *service_desc);
-
-    struct axis2_svc *(AXIS2_CALL *
-    get_parent) (axis2_op_t *op, 
-                 const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    set_qname) (axis2_op_t *op, 
-                const axis2_env_t *env,
-                axis2_qname_t *qname);
-
-    axis2_qname_t *(AXIS2_CALL *
-    get_qname) (void *op, 
-                const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    set_msg_exchange_pattern) (axis2_op_t *op, 
-                                const axis2_env_t *env,
-                                const axis2_char_t *pattern);
-
-    axis2_char_t *(AXIS2_CALL *
-    get_msg_exchange_pattern) (axis2_op_t *op, 
-                                const axis2_env_t *env);
+        /**
+         * To check whether a given paramter is locked
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param param_name pointer to param name
+         */
+        axis2_bool_t (AXIS2_CALL *
+                is_param_locked)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_char_t *param_name);
 
-    axis2_status_t (AXIS2_CALL *
-    set_msg_recv) (axis2_op_t *op, 
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param service_desc pointer to service description
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_parent)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_svc *service_desc);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        struct axis2_svc *(AXIS2_CALL *
+                get_parent)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param qname pointer to qname
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_qname)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_qname_t *qname);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_qname_t *(AXIS2_CALL *
+                get_qname)(
+                    void *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param pattern pointer to pattern
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_msg_exchange_pattern)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    const axis2_char_t *pattern);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_char_t *(AXIS2_CALL *
+                get_msg_exchange_pattern)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param msg_recv pointer to message receiver
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_msg_recv)(
+                    axis2_op_t *op,
                     const axis2_env_t *env,
                     struct axis2_msg_recv *msg_recv);
 
-    struct axis2_msg_recv *(AXIS2_CALL *
-    get_msg_recv) (
-        axis2_op_t *op, 
-        const axis2_env_t *env);
-                                        
-    axis2_char_t *(AXIS2_CALL *
-    get_style) (
-        axis2_op_t *op,
-        const axis2_env_t *env);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        struct axis2_msg_recv *(AXIS2_CALL *
+                get_msg_recv)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    axis2_status_t  (AXIS2_CALL *
-    set_style) (axis2_op_t *op,
-                const axis2_env_t *env,
-                axis2_char_t *style);
-                                                
-    /**
-     * To ebgage a module it is reuired to use this method
-     *
-     * @param moduleref
-     */
-    axis2_status_t (AXIS2_CALL *
-    engage_module) (
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        struct axis2_module_desc *moduleref,
-        struct axis2_conf *conf);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_char_t *(AXIS2_CALL *
+                get_style)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    axis2_status_t (AXIS2_CALL *
-    add_to_engage_module_list) (axis2_op_t *op,
-                                const axis2_env_t *env,
-                                struct axis2_module_desc *module_name);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param style pointer to style
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_style)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_char_t *style);
 
-    /**
-     * Method getEngadgedModules
-     *
-     */
-    axis2_array_list_t *(AXIS2_CALL *
-    get_modules) (axis2_op_t *op,
-                  const axis2_env_t *env);
+        /**
+         * To ebgage a module it is reuired to use this method
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param moduleref pointer to module ref
+         * @param conf pointer to configuration
+         */
+        axis2_status_t (AXIS2_CALL *
+                engage_module)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_module_desc *moduleref,
+                    struct axis2_conf *conf);
 
-    /**
-     * This method will simply map the String URI of the Message exchange
-     * pattern to a integer. Further in the first lookup it will cash the looked
-     * up value so that the subsequent method calls will be extremely efficient.
-     *
-     */
-    int (AXIS2_CALL *
-    get_axis_specific_mep_const) (axis2_op_t *op,
-                                  const axis2_env_t *env);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param module_name pointer to module name
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_to_engage_module_list)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_module_desc *module_name);
 
-    axis2_array_list_t *(AXIS2_CALL *
-    get_phases_in_fault_flow) (axis2_op_t *op,
-                               const axis2_env_t *env);
+        /**
+         * Method getEngadgedModules
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_modules)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
+        /**
+         * This method will simply map the String URI of the Message exchange
+         * pattern to a integer. Further in the first lookup it will cash the looked
+         * up value so that the subsequent method calls will be extremely efficient.
+         *
+         */
+        int (AXIS2_CALL *
+                get_axis_specific_mep_const)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    axis2_array_list_t *(AXIS2_CALL *
-    get_phases_out_fault_flow) (axis2_op_t *op,
-                                const axis2_env_t *env);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_phases_in_fault_flow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
 
-    axis2_array_list_t * (AXIS2_CALL *
-    get_phases_outflow) (axis2_op_t *op,
-                         const axis2_env_t *env);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_phases_out_fault_flow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_phases_outflow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    axis2_array_list_t *(AXIS2_CALL *
-    get_remaining_phases_inflow) (axis2_op_t *op,
-                                  const axis2_env_t *env);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_remaining_phases_inflow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    /**
-     * @param list
-     */
-    axis2_status_t (AXIS2_CALL *
-    set_phases_in_fault_flow) (axis2_op_t *op,
-                        const axis2_env_t *env,
-                        axis2_array_list_t *list);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_phases_in_fault_flow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_array_list_t *list);
 
-    /**
-     * @param list
-     */
-    axis2_status_t (AXIS2_CALL *
-    set_phases_out_fault_flow) (axis2_op_t *op,
-                        const axis2_env_t *env,
-                        axis2_array_list_t *list);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param list pointer to list
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_phases_out_fault_flow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_array_list_t *list);
 
-    /**
-     * @param list
-     */
-    axis2_status_t (AXIS2_CALL *
-    set_phases_outflow) (axis2_op_t *op,
-                   const axis2_env_t *env,
-                   axis2_array_list_t *list);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param list pointer to list
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_phases_outflow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_array_list_t *list);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param list pointer to list
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_remaining_phases_inflow)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_array_list_t *list);
 
-    /**
-     * @param list
-     */
-    axis2_status_t (AXIS2_CALL *
-    set_remaining_phases_inflow) (axis2_op_t *op,
-                          const axis2_env_t *env,
-                          axis2_array_list_t *list);
-                                                    
-    axis2_status_t (AXIS2_CALL *
-    add_module) (axis2_op_t *op,
-             const axis2_env_t *env,
-             axis2_qname_t *module_name);
-
-    axis2_array_list_t *(AXIS2_CALL *
-    get_module_refs) (axis2_op_t *op,
-                      const axis2_env_t *env);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param module_name pointer to module name
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_module)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_qname_t *module_name);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_array_list_t *(AXIS2_CALL *
+                get_module_refs)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    axis2_linked_list_t *(AXIS2_CALL *
-    get_in_faults) (axis2_op_t *op,
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_linked_list_t *(AXIS2_CALL *
+                get_in_faults)(
+                    axis2_op_t *op,
                     const axis2_env_t *env);
 
-    axis2_status_t (AXIS2_CALL *
-    set_in_faults) (axis2_op_t *op,
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param in_faults pointer to in faults
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_in_faults)(
+                    axis2_op_t *op,
                     const axis2_env_t *env,
                     axis2_linked_list_t *in_faults);
 
-    struct axis2_wsdl_msg_ref *(AXIS2_CALL *
-    get_input_msg) (axis2_op_t *op,
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        struct axis2_wsdl_msg_ref *(AXIS2_CALL *
+                get_input_msg)(
+                    axis2_op_t *op,
                     const axis2_env_t *env);
 
-    axis2_status_t (AXIS2_CALL *
-    set_input_msg) (axis2_op_t *op,
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param input_msg pointer to input message
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_input_msg)(
+                    axis2_op_t *op,
                     const axis2_env_t *env,
                     struct axis2_wsdl_msg_ref *input_msg);
 
-    axis2_linked_list_t *(AXIS2_CALL *
-    get_out_faults) (axis2_op_t *op,
-                     const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    set_out_faults) (axis2_op_t *op,
-                     const axis2_env_t *env,
-                     axis2_linked_list_t *out_faults);
-
-    struct axis2_wsdl_msg_ref *(AXIS2_CALL *
-    get_output_msg) (axis2_op_t *op,
-                     const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    set_output_msg) (axis2_op_t *op,
-                     const axis2_env_t *env,
-                     struct axis2_wsdl_msg_ref *output_msg);
-
-    axis2_bool_t (AXIS2_CALL *
-    is_safe) (axis2_op_t *op,
-              const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    set_safety) (axis2_op_t *op,
-                 const axis2_env_t *env,
-                 axis2_bool_t safe);
-                                    
-    axis2_char_t *(AXIS2_CALL *
-    get_target_namespace) (axis2_op_t *op,
-                           const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    add_in_fault) (axis2_op_t *op,
-                   const axis2_env_t *env,
-                   struct axis2_wsdl_fault_ref *in_fault);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_linked_list_t *(AXIS2_CALL *
+                get_out_faults)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param out_faults pointer to out faults
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_out_faults)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_linked_list_t *out_faults);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        struct axis2_wsdl_msg_ref *(AXIS2_CALL *
+                get_output_msg)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param output_msg pointer to output message
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_output_msg)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_wsdl_msg_ref *output_msg);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_bool_t (AXIS2_CALL *
+                is_safe)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param safe safe
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_safety)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    axis2_bool_t safe);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_char_t *(AXIS2_CALL *
+                get_target_namespace)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
 
-    axis2_status_t (AXIS2_CALL *
-    add_out_fault) (axis2_op_t *op,
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param in_fault pointer to in fault
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_in_fault)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_wsdl_fault_ref *in_fault);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param out_fault pointer to out fault
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_out_fault)(
+                    axis2_op_t *op,
                     const axis2_env_t *env,
                     struct axis2_wsdl_fault_ref *out_fault);
 
-    axis2_status_t (AXIS2_CALL *
-    add_feature) (axis2_op_t *op,
-                  const axis2_env_t *env,
-                  struct axis2_wsdl_feature *feature);
-
-    axis2_linked_list_t *(AXIS2_CALL *
-    get_features) (axis2_op_t *op,
-                   const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL *
-    add_property) (axis2_op_t *op,
-                   const axis2_env_t *env,
-                   struct axis2_wsdl_property *wsdl_property);
-
-    axis2_linked_list_t *(AXIS2_CALL *
-    get_Properties) (axis2_op_t *op,
-                     const axis2_env_t *env);
-
-    axis2_status_t (AXIS2_CALL * 
-    set_wsdl_op) (axis2_op_t *op,
-                  const axis2_env_t *env,
-                  struct axis2_wsdl_op *wsdl_op);
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param feature pointer to feature
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_feature)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_wsdl_feature *feature);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_linked_list_t *(AXIS2_CALL *
+                get_features)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param wsdl_property pointer to wsdl property
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_property)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_wsdl_property *wsdl_property);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_linked_list_t *(AXIS2_CALL *
+                get_Properties)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param wsdl_op pointer to wsdl op
+         */
+        axis2_status_t (AXIS2_CALL *
+                set_wsdl_op)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_wsdl_op *wsdl_op);
+
+        /**
+         * This method is responsible for finding a MEPContext for an incomming
+         * messages. An incomming message can be of two states.
+         * <p/>
+         * 1)This is a new incomming message of a given MEP. 2)This message is a
+         * part of an MEP which has already begun.
+         * <p/>
+         * The method is special cased for the two MEPs
+         * <p/>
+         * #IN_ONLY #IN_OUT
+         * <p/>
+         * for two reasons. First reason is the wide usage and the second being that
+         * the need for the MEPContext to be saved for further incomming messages.
+         * <p/>
+         * In the event that MEP of this op is different from the two MEPs
+         * deafulted above the decession of creating a new or this message relates
+         * to a MEP which already in business is decided by looking at the WSA
+         * Relates TO of the incomming message.
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param msg_ctx pointer to message context
+         * @param svc_ctx pointer to service context
+         */
+        struct axis2_op_ctx *(AXIS2_CALL *
+                find_op_ctx)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_msg_ctx *msg_ctx,
+                    struct axis2_svc_ctx *svc_ctx);
+
+        /**
+         * This will not create a new op context if there is no one already.
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param msg_ctx pointer to message context
+         */
+        struct axis2_op_ctx *(AXIS2_CALL *
+                find_for_existing_op_ctx)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_msg_ctx *msg_ctx);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        axis2_status_t (AXIS2_CALL *
+                register_op_ctx)(
+                    axis2_op_t *op,
+                    const axis2_env_t *env,
+                    struct axis2_msg_ctx *msg_ctx,
+                    struct axis2_op_ctx *op_ctx);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         */
+        struct axis2_msg *(AXIS2_CALL *
+                get_msg)(
+                    const axis2_op_t *op,
+                    const axis2_env_t *env,
+                    const axis2_char_t *label);
+
+        /**
+         * @param op pointer to operation
+         * @param env pointer to environment struct
+         * @param label pointer to label
+         * @param msg pointer to message 
+         */
+        axis2_status_t (AXIS2_CALL *
+                add_msg)(
+                    const axis2_op_t *op,
+                    const axis2_env_t *env,
+                    const axis2_char_t *label,
+                    const struct axis2_msg *msg);
+
+    };
 
     /**
-     * This method is responsible for finding a MEPContext for an incomming
-     * messages. An incomming message can be of two states.
-     * <p/>
-     * 1)This is a new incomming message of a given MEP. 2)This message is a
-     * part of an MEP which has already begun.
-     * <p/>
-     * The method is special cased for the two MEPs
-     * <p/>
-     * #IN_ONLY #IN_OUT
-     * <p/>
-     * for two reasons. First reason is the wide usage and the second being that
-     * the need for the MEPContext to be saved for further incomming messages.
-     * <p/>
-     * In the event that MEP of this op is different from the two MEPs
-     * deafulted above the decession of creating a new or this message relates
-     * to a MEP which already in business is decided by looking at the WSA
-     * Relates TO of the incomming message.
-     *
-     * @param msgContext
+     * Operaton struct
      */
-    struct axis2_op_ctx *(AXIS2_CALL *
-    find_op_ctx) (axis2_op_t *op,
-               const axis2_env_t *env,
-               struct axis2_msg_ctx *msg_ctx, 
-               struct axis2_svc_ctx *svc_ctx);
+    AXIS2_DECLARE_DATA struct axis2_op
+    {
+        axis2_wsdl_op_t base;
+        axis2_op_ops_t *ops;
+        struct axis2_param_container *param_container;
+    };
 
     /**
-     * This will not create a new op context if there is no one already.
-     * @param msgContext
-     * @return
+     * Creates op struct
+     * @param env pointer to environment struct
+     * @return pointer to newly created op
      */
-    struct axis2_op_ctx *(AXIS2_CALL *
-    find_for_existing_op_ctx) (axis2_op_t *op,
-                        const axis2_env_t *env,
-                        struct axis2_msg_ctx *msg_ctx);
-                                            
-    axis2_status_t (AXIS2_CALL *
-    register_op_ctx) (axis2_op_t *op,
-                 const axis2_env_t *env,
-                 struct axis2_msg_ctx *msg_ctx,
-                 struct axis2_op_ctx *op_ctx);                                    
-
-    struct axis2_msg *(AXIS2_CALL *
-    get_msg)(
-        const axis2_op_t *op, 
-        const axis2_env_t *env, 
-        const axis2_char_t *label);
-
-    axis2_status_t (AXIS2_CALL *
-    add_msg)(
-        const axis2_op_t *op, 
-        const axis2_env_t *env, 
-        const axis2_char_t *label, 
-        const struct axis2_msg *msg);
-
-};
-
-/** 
- * @brief Operaton struct
- *   Axis2 Operation   
- */  
-AXIS2_DECLARE_DATA struct axis2_op
-{
-    axis2_wsdl_op_t base;
-   axis2_op_ops_t *ops;
-    struct axis2_param_container *param_container;
-};
+    AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+    axis2_op_create(
+        const axis2_env_t *env);
 
-/** 
- * Creates op struct
- * @return pointer to newly created op
- */
-AXIS2_EXTERN axis2_op_t * AXIS2_CALL
-axis2_op_create (const axis2_env_t *env);
+    /**
+     * Creates op struct with name
+     * @param env pointer to environment struct
+     * @param name pointer to name
+     * @return pointer to newly created op
+     */
+    AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+    axis2_op_create_with_qname(
+        const axis2_env_t *env,
+        axis2_qname_t *name);
 
-/** 
- * Creates op struct with name
- * @param name op name
- * @return pointer to newly created op
- */
-AXIS2_EXTERN axis2_op_t * AXIS2_CALL
-axis2_op_create_with_qname (const axis2_env_t *env, 
-                            axis2_qname_t *name);
+    /**
+     * Creates op struct with wsdl op
+     * @param wsdl_op wsdl op
+     * @return pointer to newly created op
+     */
+    AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+    axis2_op_create_with_wsdl_op(
+        const axis2_env_t *env,
+        struct axis2_wsdl_op *wsdl_op);
 
-/** 
- * Creates op struct with wsdl op
- * @param wsdl_op wsdl op
- * @return pointer to newly created op
- */
-AXIS2_EXTERN axis2_op_t * AXIS2_CALL 
-axis2_op_create_with_wsdl_op (const axis2_env_t *env, 
-                              struct axis2_wsdl_op *wsdl_op);
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_op_free_void_arg(void *op,
-                       const axis2_env_t *env);
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_free_void_arg(
+        void *op,
+        const axis2_env_t *env);
 
 /************************** Start of function macros **************************/
 
+/** Frees the operation.
+    @sa axis2_op_ops#free */
 #define AXIS2_OP_FREE(op, env) \
         ((op)->ops->free (op, env))
 
+/** Adds the param.
+    @sa axis2_op_ops#add_param */
 #define AXIS2_OP_ADD_PARAM(op, env, param) \
       ((op)->ops->add_param (op, env, param))
 
+/** Gets the param.
+    @sa axis2_op_ops#get_param */
 #define AXIS2_OP_GET_PARAM(op, env, key) \
       ((op)->ops->get_param (op, env, key))
 
+/** Gets the params.
+    @sa axis2_op_ops#get_params */
 #define AXIS2_OP_GET_PARAMS(op, env) \
       ((op)->ops->get_params (op, env))
 
+/** Is param locked.
+    @sa axis2_op_ops#is_param_locked */
 #define AXIS2_OP_IS_PARAM_LOCKED(op, env, param_name) \
         ((op)->ops->is_param_locked(op, env, param_name))
 
+/** Set parent.
+    @sa axis2_op_ops#set_parent */
 #define AXIS2_OP_SET_PARENT(op, env, service_desc) \
         ((op)->ops->set_parent (op, env, service_desc))
 
+/** Get parent.
+    @sa axis2_op_ops#get_parent */
 #define AXIS2_OP_GET_PARENT(op, env) \
       ((op)->ops->get_parent (op, env))
 
+/** Sets the message receiver.
+    @sa axis2_op_ops#set_msg_recv */
 #define AXIS2_OP_SET_MSG_RECV(op, env, msg_recv) \
         ((op)->ops->set_msg_recv (op, env, msg_recv))
 
+/** Gets the message receiver.
+    @sa axis2_op_ops#get_msg_recv */
 #define AXIS2_OP_GET_MSG_RECV(op, env) \
       ((op)->ops->get_msg_recv (op, env))
 
+/** Sets the qname.
+    @sa axis2_op_ops#set_qname */
 #define AXIS2_OP_SET_QNAME(op, env, qname) \
       ((op)->ops->set_qname (op, env, qname))
-        
+
+/** Gets the qname.
+    @sa axis2_op_ops#get_qname */
 #define AXIS2_OP_GET_QNAME(op, env) \
       (((axis2_op_t *) op)->ops->get_qname (op, env))
 
+/** Sets the message exchange pattern.
+    @sa axis2_op_ops#set_msg_exchange_pattern */
 #define AXIS2_OP_SET_MSG_EXCHANGE_PATTERN(op , env, \
         msg_exchange_pattern) \
       ((op)->ops->set_msg_exchange_pattern (op, env, \
         msg_exchange_pattern))
 
+/** Gets the message exchange pattern.
+    @sa axis2_op_ops#get_msg_exchange_pattern */
 #define AXIS2_OP_GET_MSG_EXCHANGE_PATTERN(op, env) \
       ((op)->ops->get_msg_exchange_pattern (op, env))
-        
+
+/** Gets the style.
+    @sa axis2_op_ops#get_style */
 #define AXIS2_OP_GET_STYLE(op, env) \
       ((op)->ops->get_style (op, env))
-        
+
+/** Sets the style.
+    @sa axis2_op_ops#set_style */
 #define AXIS2_OP_SET_STYLE(op, env, style) \
-      ((op)->ops->set_style (op, env, style))   
+      ((op)->ops->set_style (op, env, style))
 
+/** Engages the module.
+    @sa axis2_op_ops#engage_module */
 #define AXIS2_OP_ENGAGE_MODULE(op, env, moduleref, conf) \
       ((op)->ops->engage_module (op, env, moduleref, conf))
-        
+
+/** Add to engage module list.
+    @sa axis2_op_ops#add_to_engage_module_list */
 #define AXIS2_OP_ADD_TO_ENGAGE_MODULE_LIST(op, env, module_name) \
       ((op)->ops->add_to_engage_module_list (op, env, module_name))
 
+/** Get modules.
+    @sa axis2_op_ops#get_modules */
 #define AXIS2_OP_GET_MODULES(op, env) \
       ((op)->ops->get_modules (op, env))
-        
+
+/** Gets the axis specific mep const
+    @sa axis2_op_ops#get_axis_specific_mep_const */
 #define AXIS2_OP_GET_AXIS_SPECIFIC_MEP_CONST(op, env) \
       ((op)->ops->get_axis_specific_mep_const (op, env))
 
+/** Gets the in fault flow.
+    @sa axis2_op_ops#get_phases_in_fault_flow */
 #define AXIS2_OP_GET_PHASES_IN_FAULT_FLOW(op, env) \
       ((op)->ops->get_phases_in_fault_flow (op, env))
-        
+
+/** Gets the phases out flow.
+    @sa axis2_op_ops#get_phases_out_fault_flow */
 #define AXIS2_OP_GET_PHASES_OUT_FAULT_FLOW(op, env) \
       ((op)->ops->get_phases_out_fault_flow (op, env))
 
+/** Gets the phases outflow.
+    @sa axis2_op_ops#get_phases_outflow */
 #define AXIS2_OP_GET_PHASES_OUTFLOW(op, env) \
       ((op)->ops->get_phases_outflow (op, env))
- 
+
+/** Gets the remaining phases in flow.
+    @sa axis2_op_ops#get_ramaining_phases_inflow */
 #define AXIS2_OP_GET_REMAINING_PHASES_INFLOW(op, env) \
-      ((op)->ops->get_remaining_phases_inflow (op, env))    
+      ((op)->ops->get_remaining_phases_inflow (op, env))
 
+/** Sets the phases in fault flow.
+    @sa axis2_op_ops#set_phases_in_fault_flow */
 #define AXIS2_OP_SET_PHASES_IN_FAULT_FLOW(op, env, list) \
-      ((op)->ops->set_phases_in_fault_flow (op, env, list))    
+      ((op)->ops->set_phases_in_fault_flow (op, env, list))
 
+/** Sets the phases out fault flow.
+    @sa axis2_op_ops#set_phases_out_fault_flow */
 #define AXIS2_OP_SET_PHASES_OUT_FAULT_FLOW(op, env, list) \
-      ((op)->ops->set_phases_out_fault_flow (op, env, list))   
+      ((op)->ops->set_phases_out_fault_flow (op, env, list))
 
+/** Sets the phases out flow.
+    @sa axis2_op_ops#set_phases_outflow */
 #define AXIS2_OP_SET_PHASES_OUTFLOW(op, env, list) \
-      ((op)->ops->set_phases_outflow (op, env, list)) 
-        
+      ((op)->ops->set_phases_outflow (op, env, list))
+
+/** Sets the remaining phases in flow.
+    @sa axis2_op_ops#set_remaining_phases_inflow */
 #define AXIS2_OP_SET_REMAINING_PHASES_INFLOW(op, env, list) \
       ((op)->ops->set_remaining_phases_inflow (op, env, list))
-        
+
+/** Adds the module.
+    @sa axis2_op_ops#add_module */
 #define AXIS2_OP_ADD_MODULE(op, env, module_name) \
       ((op)->ops->add_module (op, env, module_name))
 
+/** Gets the module refs.
+    @sa axis2_op_ops#get_module_refs */
 #define AXIS2_OP_GET_MODULE_REFS(op, env) \
       ((op)->ops->get_module_refs (op, env))
-        
+
+/** Gets the in faults.
+    @sa axis2_op_ops#get_in_faults */
 #define AXIS2_OP_GET_IN_FAULTS(op, env) \
       ((op)->ops->get_in_faults (op, env))
 
+/** Sets the in faults.
+    @sa axis2_op_ops#set_in_faults */
 #define AXIS2_OP_SET_IN_FAULTS(op, env) \
       ((op)->ops->set_in_faults (op, env, in_faults))
-        
+
+/** Sets the input message.
+    @sa axis2_op_ops#get_input_msg */
 #define AXIS2_OP_GET_INPUT_MSG(op, env) \
       ((op)->ops->get_input_msg (op, env))
 
+/** Sets the input message.
+    @sa axis2_op_ops#set_input_msg */
 #define AXIS2_OP_SET_INPUT_MSG(op, env) \
       ((op)->ops->set_input_msg (op, env, input_msg))
-        
+
+/** Sets the out faults.
+    @sa axis2_op_ops#get_out_faults */
 #define AXIS2_OP_GET_OUT_FAULTS(op, env) \
       ((op)->ops->get_out_faults (op, env))
 
+/** Sets the out faults.
+    @sa axis2_op_ops#set_out_faults */
 #define AXIS2_OP_SET_OUT_FAULTS(op, env) \
       ((op)->ops->set_out_faults (op, env, out_faults))
-        
+
+/** Gets the output message.
+    @sa axis2_op_ops#get_output_msg */
 #define AXIS2_OP_GET_OUTPUT_MSG(op, env) \
       ((op)->ops->get_output_msg (op, env))
 
+/** Sets the output message.
+    @sa axis2_op_ops#set_output_msg */
 #define AXIS2_OP_SET_OUTPUT_MSG(op, env) \
       ((op)->ops->set_output_msg (op, env, output_msg))
-        
+
+/** Is safe.
+    @sa axis2_op_ops#is_safe */
 #define AXIS2_OP_IS_SAFE(op, env) \
       ((op)->ops->is_safe (op, env))
 
+/** Set safety.
+    @sa axis2_op_ops#set_safety */
 #define AXIS2_OP_SET_SAFETY(op, env, safe) \
       ((op)->ops->set_safety (op, env, safe))
-        
+
+/** Gets the target namespace.
+    @sa axis2_op_ops#get_target_namespace */
 #define AXIS2_OP_GET_TARGET_NAMESPACE(op, env) \
       ((op)->ops->get_target_namespace (op, env))
 
+/** Adds the in fault.
+    @sa axis2_op_ops#add_in_fault */
 #define AXIS2_OP_ADD_IN_FAULT(op, env, in_fault) \
       ((op)->ops->add_in_fault (op, env, in_fault))
-        
+
+/** Adds the out fault.
+    @sa axis2_op_ops#add_out_fault */
 #define AXIS2_OP_ADD_OUT_FAULT(op, env, out_fault) \
       ((op)->ops->add_out_fault (op, env, out_fault))
 
+/** Adds the feature.
+    @sa axis2_op_ops#add_feature */
 #define AXIS2_OP_ADD_FEATURE(op, env, feature) \
       ((op)->ops->add_feature (op, env, feature))
-        
+
+/** Gets the features.
+    @sa axis2_op_ops#get_features */
 #define AXIS2_OP_GET_FEATURES(op, env) \
       ((op)->ops->get_features(op, env))
 
+/** Adds the property.
+    @sa axis2_op_ops#add_property */
 #define AXIS2_OP_ADD_PROPERTY(op, env, wsdl_property) \
       ((op)->ops->add_property (op, env, wsdl_property))
-        
+
+/** Gets the properties.
+    @sa axis2_op_ops#get_properties */
 #define AXIS2_OP_GET_PROPERTIES(op, env) \
       ((op)->ops->get_properties (op, env, properties))
 
+/** Sets the wsdl operation.
+    @sa axis2_op_ops#set_wsdl_op */
 #define AXIS2_OP_SET_WSDL_OP(op, env, wsdl_op) \
       ((op)->ops->set_wsdl_op (op, env, wsdl_op))
-  
 
+
+/** Finds the operation context.
+    @sa axis2_op_ops#find_op_ctx */
 #define AXIS2_OP_FIND_OP_CTX(op, env, msg_ctx, svc_ctx) \
       ((op)->ops->find_op_ctx (op, env, msg_ctx, svc_ctx))
-        
+
+/** Finds for existing operation context.
+    @sa axis2_op_ops#find_for_existing_op_ctx */
 #define AXIS2_OP_FIND_FOR_EXISTING_OP_CTX(op, env, wsdl_op) \
       ((op)->ops->find_for_existing_op_ctx (op, env, wsdl_op))
 
+/** Registers the operation conetxt.
+    @sa axis2_op_ops#_register_op_ctx */
 #define AXIS2_OP_REGISTER_OP_CTX(op, env, msg_ctx, wsdl_op) \
       ((op)->ops->register_op_ctx (op, env, msg_ctx, wsdl_op))
 
+/** Gets the message.
+    @sa axis2_op_ops#get_msg */
 #define AXIS2_OP_GET_MSG(op, env, label) \
       ((op)->ops->get_msg(op, env, label))
 
+/** Adds the message.
+    @sa axis2_op_ops#add_msg */
 #define AXIS2_OP_ADD_MSG(op, env, label, msg) \
       ((op)->ops->add_msg(op, env, label, msg))
 

Modified: webservices/axis2/trunk/c/modules/core/description/flow.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/flow.c?rev=431578&r1=431577&r2=431578&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/flow.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/flow.c Tue Aug 15 05:00:08 2006
@@ -60,7 +60,7 @@
 /************************** End of Function headers ************************/
 
 AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
-axis2_flow_create (
+axis2_flow_create(
     const axis2_env_t *env)
 {
     axis2_flow_impl_t *flow_impl = NULL;

Modified: webservices/axis2/trunk/c/modules/core/description/op.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/op.c?rev=431578&r1=431577&r2=431578&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/op.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/op.c Tue Aug 15 05:00:08 2006
@@ -22,7 +22,7 @@
 
 /** 
  * @brief Operaton struct impl
- *   Axis2 Operations  
+ * Axis2 Operations  
  */ 
 typedef struct axis2_op_impl
 {
@@ -37,277 +37,274 @@
     /*To store deploytime module refs */
     axis2_array_list_t *modulerefs;
     
-} axis2_op_impl_t;
+}
+axis2_op_impl_t;
 
 #define AXIS2_INTF_TO_IMPL(op) ((axis2_op_impl_t *)op)
    
 /*************************** Function headers *********************************/
 
 axis2_status_t AXIS2_CALL
-axis2_op_free (
-        axis2_op_t *op, 
-        const axis2_env_t *env);   
+axis2_op_free(
+    axis2_op_t *op, 
+    const axis2_env_t *env);   
 
 axis2_status_t AXIS2_CALL 
-axis2_op_add_param (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        axis2_param_t *param);
-
-axis2_param_t * AXIS2_CALL
-axis2_op_get_param (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        const axis2_char_t *name);
-
-axis2_array_list_t * AXIS2_CALL
-axis2_op_get_params (
-        axis2_op_t *op, 
-        const axis2_env_t *env);
+axis2_op_add_param(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_param_t *param);
+
+axis2_param_t *AXIS2_CALL
+axis2_op_get_param(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    const axis2_char_t *name);
+
+axis2_array_list_t *AXIS2_CALL
+axis2_op_get_params(
+    axis2_op_t *op, 
+    const axis2_env_t *env);
 
 axis2_bool_t AXIS2_CALL
 axis2_op_is_param_locked(
-        axis2_op_t *op, 
-        const axis2_env_t *env
-    ,   axis2_char_t *param_name);
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_char_t *param_name);
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_parent (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        axis2_svc_t *svc);
-
-axis2_svc_t * AXIS2_CALL
-axis2_op_get_parent (
-        axis2_op_t *op, 
-        const axis2_env_t *env);
+axis2_op_set_parent(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_svc_t *svc);
+
+axis2_svc_t *AXIS2_CALL
+axis2_op_get_parent(
+    axis2_op_t *op, 
+    const axis2_env_t *env);
       
 axis2_status_t AXIS2_CALL
-axis2_op_set_msg_recv (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        struct axis2_msg_recv *msg_recv);
-
-struct axis2_msg_recv * AXIS2_CALL
-axis2_op_get_msg_recv (
-        axis2_op_t *op, 
-        const axis2_env_t *env);
+axis2_op_set_msg_recv(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    struct axis2_msg_recv *msg_recv);
+
+struct axis2_msg_recv *AXIS2_CALL
+axis2_op_get_msg_recv(
+    axis2_op_t *op, 
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_qname (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        axis2_qname_t *qname);
+axis2_op_set_qname(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_qname_t *qname);
                             
-axis2_qname_t * AXIS2_CALL
-axis2_op_get_qname (
-        void *op, 
-        const axis2_env_t *env);
+axis2_qname_t *AXIS2_CALL
+axis2_op_get_qname(
+    void *op, 
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_msg_exchange_pattern (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        const axis2_char_t *pattern);
+axis2_op_set_msg_exchange_pattern(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    const axis2_char_t *pattern);
       
-axis2_char_t * AXIS2_CALL
-axis2_op_get_msg_exchange_pattern (
-        axis2_op_t *op, 
-        const axis2_env_t *env);
-
-axis2_char_t * AXIS2_CALL
-axis2_op_get_style (
-        axis2_op_t *op,
-        const axis2_env_t *env);
+axis2_char_t *AXIS2_CALL
+axis2_op_get_msg_exchange_pattern(
+    axis2_op_t *op, 
+    const axis2_env_t *env);
+
+axis2_char_t *AXIS2_CALL
+axis2_op_get_style(
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t  AXIS2_CALL
-axis2_op_set_style (
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_char_t *style);
+axis2_op_set_style(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_char_t *style);
 
 axis2_status_t AXIS2_CALL
 axis2_op_engage_module(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_module_desc_t *moduleref,
-        axis2_conf_t *conf);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_module_desc_t *moduleref,
+    axis2_conf_t *conf);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_to_engage_module_list(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_module_desc_t *module_name);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_module_desc_t *module_name);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_op_get_modules(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 int AXIS2_CALL
 axis2_op_get_axis_specific_mep_const(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_op_get_phases_in_fault_flow(
-        axis2_op_t *op,
-        const axis2_env_t *env);
-
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_op_get_phases_out_fault_flow(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
-axis2_array_list_t * AXIS2_CALL
+axis2_array_list_t *AXIS2_CALL
 axis2_op_get_phases_outflow(
-        axis2_op_t *op,
-        const axis2_env_t *env);
-
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_op_get_remaining_phases_inflow(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_phases_in_fault_flow(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_array_list_t *list);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_phases_out_fault_flow(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_array_list_t *list);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_phases_outflow(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_array_list_t *list);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_remaining_phases_inflow(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_array_list_t *list);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_module(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_qname_t *module_name);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_qname_t *module_name);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_op_get_module_refs(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_linked_list_t *AXIS2_CALL
 axis2_op_get_in_faults(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_in_faults(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_linked_list_t *in_faults);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_linked_list_t *in_faults);
 
 struct axis2_wsdl_msg_ref *AXIS2_CALL
 axis2_op_get_input_msg(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_input_msg(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        struct axis2_wsdl_msg_ref *input_msg); 
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_wsdl_msg_ref *input_msg); 
 
 
 axis2_linked_list_t *AXIS2_CALL
 axis2_op_get_out_faults(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_out_faults(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_linked_list_t *out_faults);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_linked_list_t *out_faults);
 
 struct axis2_wsdl_msg_ref *AXIS2_CALL
 axis2_op_get_output_msg(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_output_msg(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        struct axis2_wsdl_msg_ref *output_msg); 
-
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_wsdl_msg_ref *output_msg); 
 
 axis2_bool_t AXIS2_CALL
 axis2_op_is_safe(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_set_safety(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_bool_t safe);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_bool_t safe);
 
 axis2_char_t *AXIS2_CALL
 axis2_op_get_target_namespace(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_in_fault(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_wsdl_fault_ref_t *in_fault);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_fault_ref_t *in_fault);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_out_fault(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_wsdl_fault_ref_t *out_fault);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_fault_ref_t *out_fault);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_feature(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_wsdl_feature_t *feature);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_feature_t *feature);
 
 axis2_linked_list_t *AXIS2_CALL
 axis2_op_get_features(
-        axis2_op_t *op,
-        const axis2_env_t *env); 
-
+    axis2_op_t *op,
+    const axis2_env_t *env); 
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_property(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_wsdl_property_t *wsdl_property);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_property_t *wsdl_property);
 
 axis2_linked_list_t *AXIS2_CALL
 axis2_op_get_Properties(
-        axis2_op_t *op,
-        const axis2_env_t *env);
+    axis2_op_t *op,
+    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL 
 axis2_op_set_wsdl_op(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_wsdl_op_t *wsdl_op);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_op_t *wsdl_op);
 
 /**
  * This method is responsible for finding a MEPContext for an incomming
@@ -332,10 +329,10 @@
  */
 struct axis2_op_ctx *AXIS2_CALL
 axis2_op_find_op_ctx(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        struct axis2_msg_ctx *msg_ctx, 
-        struct axis2_svc_ctx *svc_ctx);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_msg_ctx *msg_ctx, 
+    struct axis2_svc_ctx *svc_ctx);
 
 /**
  * This will not create a new op context if there is no one already.
@@ -344,62 +341,64 @@
  */
 axis2_op_ctx_t *AXIS2_CALL
 axis2_op_find_for_existing_op_ctx(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        struct axis2_msg_ctx *msg_ctx);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_msg_ctx *msg_ctx);
                                         
 axis2_status_t AXIS2_CALL
 axis2_op_register_op_ctx(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        struct axis2_msg_ctx *msg_ctx,
-        struct axis2_op_ctx *op_ctx);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_msg_ctx *msg_ctx,
+    struct axis2_op_ctx *op_ctx);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_msg_ctx_in_only(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_msg_ctx_t *msg_ctx,
-        axis2_op_ctx_t *op_ctx);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx);
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_msg_ctx_out_only(axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_msg_ctx_t *msg_ctx,
-        axis2_op_ctx_t *op_ctx);
+axis2_op_add_msg_ctx_out_only(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx);
 
 axis2_status_t AXIS2_CALL
 axis2_op_add_msg_ctx_in_out(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_msg_ctx_t *msg_ctx,
-        axis2_op_ctx_t *op_ctx);
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx);
     
 axis2_status_t AXIS2_CALL
 axis2_op_add_msg_ctx_out_in(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_msg_ctx_t *msg_ctx,
-        axis2_op_ctx_t *op_ctx);        
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx);        
 
-axis2_msg_t * AXIS2_CALL
+axis2_msg_t *AXIS2_CALL
 axis2_op_get_msg(
-        const axis2_op_t *op, 
-        const axis2_env_t *env, 
-        const axis2_char_t *label);
+    const axis2_op_t *op, 
+    const axis2_env_t *env, 
+    const axis2_char_t *label);
     
 axis2_status_t AXIS2_CALL
 axis2_op_add_msg(
-        const axis2_op_t *op, 
-        const axis2_env_t *env, 
-        const axis2_char_t *label, 
-        const axis2_msg_t *msg);
+   const axis2_op_t *op, 
+   const axis2_env_t *env, 
+   const axis2_char_t *label, 
+   const axis2_msg_t *msg);
 
                                 
 /************************* End of function headers ****************************/   
 
-AXIS2_EXTERN axis2_op_t * AXIS2_CALL
-axis2_op_create (const axis2_env_t *env)
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
+axis2_op_create(
+    const axis2_env_t *env)
 {
     axis2_param_container_t *param_container_l = NULL;
     axis2_array_list_t *array_list_l = NULL;
@@ -412,15 +411,15 @@
  
     AXIS2_ENV_CHECK(env, NULL);
    
-   op_impl =  (axis2_op_impl_t *) AXIS2_MALLOC (env->allocator,
-      sizeof (axis2_op_impl_t));
+    op_impl =  (axis2_op_impl_t *) AXIS2_MALLOC (env->allocator,
+        sizeof (axis2_op_impl_t));
      
-   if(NULL == op_impl)
-   {
-      AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+    if(NULL == op_impl)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
-   }
-    
+    }
+        
     op_impl->parent = NULL;
     op_impl->base = NULL;
     op_impl->msg_recv = NULL;
@@ -432,73 +431,73 @@
     
     op_impl->op.param_container = (axis2_param_container_t *)
       axis2_param_container_create(env);      
-   if(NULL == op_impl->op.param_container)
-   {
+    if(NULL == op_impl->op.param_container)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);   
         return NULL;        
-   }
+    }
    
-   op_impl->base = axis2_desc_create(env);
-   if(NULL == op_impl->base)
-   {
+    op_impl->base = axis2_desc_create(env);
+    if(NULL == op_impl->base)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);   
         return NULL;        
-   }
+    }
    
    /* create and set up child messages */
-   msg = axis2_msg_create(env);
-   if (!msg)
-   {
+    msg = axis2_msg_create(env);
+    if (!msg)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);   
         return NULL;        
-   }
-   AXIS2_MSG_SET_DIRECTION(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_IN);
-   AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
-   axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_IN, msg);
+    }
+    AXIS2_MSG_SET_DIRECTION(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_IN);
+    AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
+    axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_IN, msg);
    
-   msg = axis2_msg_create(env);
-   if (!msg)
-   {
+    msg = axis2_msg_create(env);
+    if (!msg)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);   
         return NULL;        
-   }
-   AXIS2_MSG_SET_DIRECTION(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_OUT);
-   AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
-   axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_OUT, msg);
+    }
+    AXIS2_MSG_SET_DIRECTION(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_OUT);
+    AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
+    axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_OUT, msg);
    
-   msg = axis2_msg_create(env);
-   if (!msg)
-   {
+    msg = axis2_msg_create(env);
+    if (!msg)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);   
         return NULL;        
-   }   
-   AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
-   AXIS2_MSG_SET_FLOW(msg, env, NULL);
-   axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_IN_FAULT, msg);
+    }   
+    AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
+    AXIS2_MSG_SET_FLOW(msg, env, NULL);
+    axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_IN_FAULT, msg);
    
-   msg = axis2_msg_create(env);
-   if (!msg)
-   {
+    msg = axis2_msg_create(env);
+    if (!msg)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);   
         return NULL;        
-   }   
-   AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
-   AXIS2_MSG_SET_FLOW(msg, env, NULL);
-   axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_OUT_FAULT, msg);
-
-   op_impl->wsdl_op = (axis2_wsdl_op_t *) axis2_wsdl_op_create(env);      
-   if(NULL == op_impl->wsdl_op)
-   {
+    }   
+    AXIS2_MSG_SET_PARENT(msg, env, &(op_impl->op));
+    AXIS2_MSG_SET_FLOW(msg, env, NULL);
+    axis2_op_add_msg(&(op_impl->op), env, AXIS2_MSG_OUT_FAULT, msg);
+
+    op_impl->wsdl_op = (axis2_wsdl_op_t *) axis2_wsdl_op_create(env);      
+    if(NULL == op_impl->wsdl_op)
+    {
         axis2_op_free(&(op_impl->op), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;      
-   }
+    }
     /* Set the function pointers of the base */
     op_impl->op.base.ops = AXIS2_MALLOC(env->allocator, 
         sizeof(axis2_wsdl_op_ops_t));
@@ -599,30 +598,30 @@
     }
 
     op_impl->op.ops = AXIS2_MALLOC(env->allocator, sizeof(axis2_op_ops_t));
-   if(NULL == op_impl->op.ops)
-   {
+    if(NULL == op_impl->op.ops)
+    {
         axis2_op_free(&(op_impl->op), env);
-      AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
-   }
+    }
    
-   op_impl->op.ops->free = axis2_op_free;
-   op_impl->op.ops->free_void_arg = axis2_op_free_void_arg;
-   op_impl->op.ops->add_param = axis2_op_add_param;
-   op_impl->op.ops->get_param = axis2_op_get_param;
-   op_impl->op.ops->get_params = axis2_op_get_params;
-   op_impl->op.ops->set_parent = axis2_op_set_parent;
-   op_impl->op.ops->get_parent = axis2_op_get_parent;
-   op_impl->op.ops->set_msg_recv = axis2_op_set_msg_recv;
-   op_impl->op.ops->get_msg_recv = axis2_op_get_msg_recv;
+    op_impl->op.ops->free = axis2_op_free;
+    op_impl->op.ops->free_void_arg = axis2_op_free_void_arg;
+    op_impl->op.ops->add_param = axis2_op_add_param;
+    op_impl->op.ops->get_param = axis2_op_get_param;
+    op_impl->op.ops->get_params = axis2_op_get_params;
+    op_impl->op.ops->set_parent = axis2_op_set_parent;
+    op_impl->op.ops->get_parent = axis2_op_get_parent;
+    op_impl->op.ops->set_msg_recv = axis2_op_set_msg_recv;
+    op_impl->op.ops->get_msg_recv = axis2_op_get_msg_recv;
     op_impl->op.ops->set_qname = axis2_op_set_qname;
-   op_impl->op.ops->get_qname = axis2_op_get_qname; 
-   op_impl->op.ops->set_msg_exchange_pattern 
+    op_impl->op.ops->get_qname = axis2_op_get_qname; 
+    op_impl->op.ops->set_msg_exchange_pattern 
       = axis2_op_set_msg_exchange_pattern; 
-   op_impl->op.ops->get_msg_exchange_pattern
+    op_impl->op.ops->get_msg_exchange_pattern
       = axis2_op_get_msg_exchange_pattern;
     op_impl->op.ops->set_style = axis2_op_set_style;
-   op_impl->op.ops->get_style = axis2_op_get_style; 
+    op_impl->op.ops->get_style = axis2_op_get_style; 
     op_impl->op.ops->engage_module = axis2_op_engage_module;
     op_impl->op.ops->add_to_engage_module_list = axis2_op_add_to_engage_module_list;
     op_impl->op.ops->get_modules = axis2_op_get_modules;
@@ -664,10 +663,12 @@
     return &(op_impl->op);
 }
 
-axis2_op_t * AXIS2_CALL
-axis2_op_create_with_qname (const axis2_env_t *env, axis2_qname_t *qname)
+axis2_op_t *AXIS2_CALL
+axis2_op_create_with_qname(
+    const axis2_env_t *env, 
+    axis2_qname_t *qname)
 {
-   axis2_op_impl_t *op_impl = NULL;
+    axis2_op_impl_t *op_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -675,11 +676,11 @@
     
     op_impl = (axis2_op_impl_t *) axis2_op_create(env);
     
-   if(NULL == op_impl)
-   {
-      AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+    if(NULL == op_impl)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
-   }
+    }
     
     if(!op_impl->wsdl_op)
     {
@@ -691,46 +692,49 @@
             return NULL;      
         }
     }
-   status = axis2_op_set_qname(&(op_impl->op), env, qname);
+    status = axis2_op_set_qname(&(op_impl->op), env, qname);
     if(AXIS2_SUCCESS != status)
     {
         axis2_op_free(&(op_impl->op), env);
         return NULL;
     }
     
-   return &(op_impl->op);   
+    return &(op_impl->op);   
 }
 
-axis2_op_t * AXIS2_CALL
-axis2_op_create_with_wsdl_op (const axis2_env_t *env, 
-                                            axis2_wsdl_op_t *wsdl_op)
+axis2_op_t *AXIS2_CALL
+axis2_op_create_with_wsdl_op(
+    const axis2_env_t *env, 
+    axis2_wsdl_op_t *wsdl_op)
 {
-   axis2_op_impl_t *op_impl = NULL;
+    axis2_op_impl_t *op_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, wsdl_op, NULL);
     
     op_impl = (axis2_op_impl_t *) axis2_op_create(env);
     
-   if(NULL == op_impl)
-   {
-      AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+    if(NULL == op_impl)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
-   }
+    }
    
-   if(NULL != op_impl->wsdl_op)
+    if(NULL != op_impl->wsdl_op)
     {
         AXIS2_WSDL_OP_FREE(op_impl->wsdl_op, env);
     }
     op_impl->wsdl_op = wsdl_op;
        
-   return &(op_impl->op);   
+    return &(op_impl->op);   
 }
 
 /*************************** Start of op impls *************************/
 
 axis2_status_t AXIS2_CALL 
-axis2_op_free (axis2_op_t *op, const axis2_env_t *env)
+axis2_op_free(
+    axis2_op_t *op, 
+    const axis2_env_t *env)
 { 
     axis2_op_impl_t *op_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -802,8 +806,9 @@
 }   
 
 axis2_status_t AXIS2_CALL
-axis2_op_free_void_arg(void *op,
-                        const axis2_env_t *env)
+axis2_op_free_void_arg(
+    void *op,
+    const axis2_env_t *env)
 {
     axis2_op_t *op_l = NULL;
     
@@ -814,9 +819,10 @@
 }
 
 axis2_status_t AXIS2_CALL 
-axis2_op_add_param (axis2_op_t *op, 
-                                const axis2_env_t *env,       
-                              axis2_param_t *param)
+axis2_op_add_param(
+    axis2_op_t *op, 
+    const axis2_env_t *env,       
+    axis2_param_t *param)
 {
     axis2_op_impl_t *op_impl = NULL;
     axis2_char_t *param_name = NULL;
@@ -842,11 +848,11 @@
     return status;
 }
 
-axis2_param_t * AXIS2_CALL
-axis2_op_get_param (
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        const axis2_char_t *param_name)
+axis2_param_t *AXIS2_CALL
+axis2_op_get_param(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    const axis2_char_t *param_name)
 {
     axis2_op_impl_t *op_impl = NULL;
     axis2_param_t *param = NULL;
@@ -861,10 +867,10 @@
     return param;
 }
 
-axis2_array_list_t * AXIS2_CALL
+axis2_array_list_t *AXIS2_CALL
 axis2_op_get_params(
-        axis2_op_t *op, 
-        const axis2_env_t *env)
+    axis2_op_t *op, 
+    const axis2_env_t *env)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -876,9 +882,9 @@
 
 axis2_bool_t AXIS2_CALL 
 axis2_op_is_param_locked(
-        axis2_op_t *op, 
-        const axis2_env_t *env,
-        axis2_char_t *param_name)
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_char_t *param_name)
 {
     axis2_svc_t *parent = NULL;
     axis2_param_t *param = NULL;
@@ -902,9 +908,10 @@
 }
 
 axis2_status_t AXIS2_CALL 
-axis2_op_set_parent (axis2_op_t *op, 
-                                const axis2_env_t *env,
-                              axis2_svc_t *svc)
+axis2_op_set_parent(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_svc_t *svc)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -921,9 +928,10 @@
    return AXIS2_SUCCESS;
 }
 
-axis2_svc_t * AXIS2_CALL
-axis2_op_get_parent (axis2_op_t *op, 
-                                const axis2_env_t *env)
+axis2_svc_t *AXIS2_CALL
+axis2_op_get_parent(
+    axis2_op_t *op, 
+    const axis2_env_t *env)
 {           
    AXIS2_ENV_CHECK(env, NULL);
     
@@ -931,9 +939,10 @@
 }
 
 axis2_status_t AXIS2_CALL 
-axis2_op_set_msg_recv (axis2_op_t *op, 
-                                const axis2_env_t *env,
-                              struct axis2_msg_recv *msg_recv)
+axis2_op_set_msg_recv(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    struct axis2_msg_recv *msg_recv)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -952,18 +961,20 @@
    return AXIS2_SUCCESS;
 }
 
-struct axis2_msg_recv * AXIS2_CALL
-axis2_op_get_msg_recv (axis2_op_t *op, 
-                                const axis2_env_t *env)
+struct axis2_msg_recv *AXIS2_CALL
+axis2_op_get_msg_recv(
+    axis2_op_t *op, 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(op)->msg_recv;
 }
  
 axis2_status_t AXIS2_CALL
-axis2_op_set_qname (axis2_op_t *op, 
-                            const axis2_env_t *env,
-                            axis2_qname_t *qname)
+axis2_op_set_qname(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    axis2_qname_t *qname)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -973,10 +984,10 @@
     return AXIS2_WSDL_OP_SET_QNAME(op_impl->wsdl_op, env, qname);
 }
     
-axis2_qname_t * AXIS2_CALL
-axis2_op_get_qname (
-        void *op, 
-        const axis2_env_t *env)
+axis2_qname_t *AXIS2_CALL
+axis2_op_get_qname(
+    void *op, 
+    const axis2_env_t *env)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -988,9 +999,10 @@
 }
 
 axis2_status_t AXIS2_CALL 
-axis2_op_set_msg_exchange_pattern (axis2_op_t *op, 
-                                            const axis2_env_t *env,
-                                          const axis2_char_t *pattern)
+axis2_op_set_msg_exchange_pattern(
+    axis2_op_t *op, 
+    const axis2_env_t *env,
+    const axis2_char_t *pattern)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1002,9 +1014,10 @@
         pattern);
 }
 
-axis2_char_t * AXIS2_CALL
-axis2_op_get_msg_exchange_pattern (axis2_op_t *op, 
-                                            const axis2_env_t *env)
+axis2_char_t *AXIS2_CALL
+axis2_op_get_msg_exchange_pattern(
+    axis2_op_t *op, 
+    const axis2_env_t *env)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1014,9 +1027,10 @@
     return AXIS2_WSDL_OP_GET_MSG_EXCHANGE_PATTERN(op_impl->wsdl_op, env);
 }
 
-axis2_char_t * AXIS2_CALL
-axis2_op_get_style (axis2_op_t *op,
-                            const axis2_env_t *env)
+axis2_char_t *AXIS2_CALL
+axis2_op_get_style(
+    axis2_op_t *op,
+    const axis2_env_t *env)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1026,9 +1040,10 @@
 }
 
 axis2_status_t  AXIS2_CALL
-axis2_op_set_style (axis2_op_t *op,
-                            const axis2_env_t *env,
-                            axis2_char_t *style)
+axis2_op_set_style(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_char_t *style)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1041,10 +1056,10 @@
 
 axis2_status_t AXIS2_CALL
 axis2_op_engage_module(
-        axis2_op_t *op,
-        const axis2_env_t *env,
-        axis2_module_desc_t *moduleref,
-        axis2_conf_t *conf) 
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_module_desc_t *moduleref,
+    axis2_conf_t *conf) 
 {
     axis2_op_impl_t *op_impl = NULL;
     int index = 0;
@@ -1125,9 +1140,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_to_engage_module_list(axis2_op_t *op,
-                                            const axis2_env_t *env,
-                                            axis2_module_desc_t *module_desc) 
+axis2_op_add_to_engage_module_list(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_module_desc_t *module_desc) 
 {
     axis2_op_impl_t *op_impl = NULL;
     axis2_array_list_t *collection_module = NULL;
@@ -1173,8 +1189,9 @@
 }
 
 axis2_array_list_t *AXIS2_CALL
-axis2_op_get_modules(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_modules(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     axis2_property_t *property = NULL;
@@ -1191,8 +1208,9 @@
 }
 
 int AXIS2_CALL
-axis2_op_get_axis_specific_mep_const(axis2_op_t *op,
-                                                const axis2_env_t *env) 
+axis2_op_get_axis_specific_mep_const(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     int temp = 0;
@@ -1261,8 +1279,9 @@
 }
 
 axis2_array_list_t *AXIS2_CALL
-axis2_op_get_phases_in_fault_flow(axis2_op_t *op,
-                                            const axis2_env_t *env) 
+axis2_op_get_phases_in_fault_flow(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -1281,8 +1300,9 @@
 
 
 axis2_array_list_t *AXIS2_CALL
-axis2_op_get_phases_out_fault_flow(axis2_op_t *op,
-                                            const axis2_env_t *env) 
+axis2_op_get_phases_out_fault_flow(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -1300,9 +1320,10 @@
 }
 
 
-axis2_array_list_t * AXIS2_CALL
-axis2_op_get_phases_outflow(axis2_op_t *op,
-                                        const axis2_env_t *env) 
+axis2_array_list_t *AXIS2_CALL
+axis2_op_get_phases_outflow(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -1322,8 +1343,8 @@
 
 axis2_array_list_t *AXIS2_CALL
 axis2_op_get_remaining_phases_inflow(
-        axis2_op_t *op,
-        const axis2_env_t *env) 
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -1341,9 +1362,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_phases_in_fault_flow(axis2_op_t *op,
-                                            const axis2_env_t *env,
-                                            axis2_array_list_t *list) 
+axis2_op_set_phases_in_fault_flow(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1365,9 +1387,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_phases_out_fault_flow(axis2_op_t *op,
-                                            const axis2_env_t *env,
-                                            axis2_array_list_t *list) 
+axis2_op_set_phases_out_fault_flow(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1388,9 +1411,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_phases_outflow(axis2_op_t *op,
-                                        const axis2_env_t *env,
-                                        axis2_array_list_t *list) 
+axis2_op_set_phases_outflow(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1412,9 +1436,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_remaining_phases_inflow(axis2_op_t *op,
-                                                const axis2_env_t *env,
-                                                axis2_array_list_t *list) 
+axis2_op_set_remaining_phases_inflow(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_array_list_t *list) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1435,9 +1460,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_module(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_qname_t *module_qname) 
+axis2_op_add_module(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_qname_t *module_qname) 
 {
     axis2_op_impl_t *op_impl = NULL;
     axis2_qname_t *module_qname_l = NULL;
@@ -1452,16 +1478,18 @@
 }
 
 axis2_array_list_t *AXIS2_CALL
-axis2_op_get_module_refs(axis2_op_t *op,
-                                    const axis2_env_t *env) 
+axis2_op_get_module_refs(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(op)->modulerefs;
 }
 
 axis2_linked_list_t *AXIS2_CALL
-axis2_op_get_in_faults(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_in_faults(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1472,9 +1500,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_in_faults(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_linked_list_t *in_faults) 
+axis2_op_set_in_faults(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_linked_list_t *in_faults) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1486,8 +1515,9 @@
 }
 
 struct axis2_wsdl_msg_ref *AXIS2_CALL
-axis2_op_get_input_msg(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_input_msg(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1498,9 +1528,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_input_msg(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                struct axis2_wsdl_msg_ref *input_msg) 
+axis2_op_set_input_msg(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_wsdl_msg_ref *input_msg) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1512,8 +1543,9 @@
 }
 
 axis2_linked_list_t *AXIS2_CALL
-axis2_op_get_out_faults(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_out_faults(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1524,9 +1556,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_out_faults(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_linked_list_t *out_faults) 
+axis2_op_set_out_faults(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_linked_list_t *out_faults) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1538,8 +1571,9 @@
 }
 
 struct axis2_wsdl_msg_ref *AXIS2_CALL
-axis2_op_get_output_msg(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_output_msg(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1550,9 +1584,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_output_msg(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                struct axis2_wsdl_msg_ref *output_msg) 
+axis2_op_set_output_msg(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_wsdl_msg_ref *output_msg) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1564,8 +1599,9 @@
 }
 
 axis2_bool_t AXIS2_CALL
-axis2_op_is_safe(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_is_safe(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1576,9 +1612,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_set_safety(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_bool_t safe) 
+axis2_op_set_safety(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_bool_t safe) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1589,8 +1626,9 @@
 }
 
 axis2_char_t *AXIS2_CALL
-axis2_op_get_target_namespace(axis2_op_t *op,
-                                        const axis2_env_t *env) 
+axis2_op_get_target_namespace(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1602,9 +1640,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_in_fault(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_wsdl_fault_ref_t *in_fault) 
+axis2_op_add_in_fault(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_fault_ref_t *in_fault) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1616,9 +1655,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_out_fault(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_wsdl_fault_ref_t *out_fault) 
+axis2_op_add_out_fault(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_fault_ref_t *out_fault) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1630,9 +1670,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_feature(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_wsdl_feature_t *feature) 
+axis2_op_add_feature(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_feature_t *feature) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1645,8 +1686,9 @@
 }
 
 axis2_linked_list_t *AXIS2_CALL
-axis2_op_get_features(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_features(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1658,9 +1700,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_property(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_wsdl_property_t *wsdl_property) 
+axis2_op_add_property(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_property_t *wsdl_property) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1673,8 +1716,9 @@
 }
 
 axis2_linked_list_t *AXIS2_CALL
-axis2_op_get_Properties(axis2_op_t *op,
-                                const axis2_env_t *env) 
+axis2_op_get_Properties(
+    axis2_op_t *op,
+    const axis2_env_t *env) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1686,9 +1730,10 @@
 }
 
 axis2_status_t AXIS2_CALL 
-axis2_op_set_wsdl_op(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_wsdl_op_t *wsdl_op) 
+axis2_op_set_wsdl_op(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_wsdl_op_t *wsdl_op) 
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1709,10 +1754,11 @@
 }
 
 axis2_op_ctx_t *AXIS2_CALL
-axis2_op_find_op_ctx(axis2_op_t *op,
-                        const axis2_env_t *env,
-                        struct axis2_msg_ctx *msg_ctx, 
-                        struct axis2_svc_ctx *svc_ctx)
+axis2_op_find_op_ctx(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    struct axis2_msg_ctx *msg_ctx, 
+    struct axis2_svc_ctx *svc_ctx)
 {
     axis2_op_impl_t *op_impl = NULL;
     axis2_op_ctx_t *op_ctx = NULL;
@@ -1765,9 +1811,10 @@
 }
 
 axis2_op_ctx_t *AXIS2_CALL
-axis2_op_find_for_existing_op_ctx(axis2_op_t *op,
-                                    const axis2_env_t *env,
-                                    axis2_msg_ctx_t *msg_ctx)
+axis2_op_find_for_existing_op_ctx(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx)
 {
     axis2_op_ctx_t *op_ctx = NULL;
     axis2_relates_to_t *relates_to = NULL;
@@ -1808,10 +1855,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_register_op_ctx(axis2_op_t *op,
-                            const axis2_env_t *env,
-                            axis2_msg_ctx_t *msg_ctx,
-                            axis2_op_ctx_t *op_ctx)
+axis2_op_register_op_ctx(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx)
 {
     axis2_conf_ctx_t *conf_ctx = NULL;
     axis2_char_t *msg_id = NULL;
@@ -1851,10 +1899,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_msg_ctx_in_only(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_msg_ctx_t *msg_ctx,
-                                axis2_op_ctx_t *op_ctx)
+axis2_op_add_msg_ctx_in_only(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx)
 {
     axis2_op_impl_t *op_impl = NULL;
     
@@ -1881,10 +1930,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_msg_ctx_out_only(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_msg_ctx_t *msg_ctx,
-                                axis2_op_ctx_t *op_ctx)
+axis2_op_add_msg_ctx_out_only(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
@@ -1909,10 +1959,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_op_add_msg_ctx_in_out(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_msg_ctx_t *msg_ctx,
-                                axis2_op_ctx_t *op_ctx)
+axis2_op_add_msg_ctx_in_out(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx)
 {
     axis2_hash_t *mep = NULL;
     axis2_msg_ctx_t *in_msg_ctx = NULL;
@@ -1948,10 +1999,11 @@
 }
     
 axis2_status_t AXIS2_CALL
-axis2_op_add_msg_ctx_out_in(axis2_op_t *op,
-                                const axis2_env_t *env,
-                                axis2_msg_ctx_t *msg_ctx,
-                                axis2_op_ctx_t *op_ctx)
+axis2_op_add_msg_ctx_out_in(
+    axis2_op_t *op,
+    const axis2_env_t *env,
+    axis2_msg_ctx_t *msg_ctx,
+    axis2_op_ctx_t *op_ctx)
 {
     axis2_hash_t *mep = NULL;
     axis2_msg_ctx_t *in_msg_ctx = NULL;
@@ -1986,8 +2038,9 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_msg_t * AXIS2_CALL
-axis2_op_get_msg(const axis2_op_t *op, 
+axis2_msg_t *AXIS2_CALL
+axis2_op_get_msg(
+    const axis2_op_t *op, 
     const axis2_env_t *env, 
     const axis2_char_t *label)
 {
@@ -2002,7 +2055,8 @@
 }
     
 axis2_status_t AXIS2_CALL
-axis2_op_add_msg(const axis2_op_t *op, 
+axis2_op_add_msg(
+    const axis2_op_t *op, 
     const axis2_env_t *env, 
     const axis2_char_t *label, 
     const axis2_msg_t *msg)



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