axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r437720 - in /webservices/axis2/trunk/c: include/ modules/core/context/ modules/core/deployment/ modules/core/description/ modules/core/engine/ modules/core/phaseresolver/
Date Mon, 28 Aug 2006 14:59:52 GMT
Author: samisa
Date: Mon Aug 28 07:59:48 2006
New Revision: 437720

URL: http://svn.apache.org/viewvc?rev=437720&view=rev
Log:
Fixed transport in API docs and API itself. Also updated related structs using the API

Modified:
    webservices/axis2/trunk/c/include/axis2_transport_in_desc.h
    webservices/axis2/trunk/c/modules/core/context/msg_ctx.c
    webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c
    webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c
    webservices/axis2/trunk/c/modules/core/description/transport_out_desc.c
    webservices/axis2/trunk/c/modules/core/engine/conf.c
    webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c

Modified: webservices/axis2/trunk/c/include/axis2_transport_in_desc.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_transport_in_desc.h?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_transport_in_desc.h (original)
+++ webservices/axis2/trunk/c/include/axis2_transport_in_desc.h Mon Aug 28 07:59:48 2006
@@ -20,7 +20,13 @@
 /** 
  * @defgroup axis2_transport_in_desc transport in description
  * @ingroup axis2_desc
- * Description.
+ * transport in description represents a transport receiver configured in 
+ * Axis2 configuration. There can be multiple transport receivers configured 
+ * in axis2.xml file and each of them will be represented with a transport 
+ * in description instance. deployment engine takes care of creating and 
+ * instantiating transport in descriptions.
+ * transport in description encapsulates flows related to the transport in 
+ * and also holds a reference to related transport receiver.
  * @{
  */
 
@@ -46,102 +52,129 @@
 {
 #endif
 
-    struct axis2_phase;
-    struct axis2_transport_receiver;
     /** Type name for struct axis2_transport_in_desc */
     typedef struct axis2_transport_in_desc axis2_transport_in_desc_t;
     /** Type name for struct axis2_transport_in_desc_ops  */
     typedef struct axis2_transport_in_desc_ops axis2_transport_in_desc_ops_t;
 
+    struct axis2_phase;
+    struct axis2_transport_receiver;
+
     /**
-     * Description Transport In ops struct
-     * Encapsulator struct for ops of axis2_transport_in_desc
+     * transport in description ops struct.
+     * Encapsulator struct for ops of axis2_transport_in_desc.
      */
     struct axis2_transport_in_desc_ops
     {
         /** 
-         * De-allocate memory
-         * @param transport_in_desc pointer to transport in description
+         * Frees transport in description. 
+         * @param transport_in_desc pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
                 free)(
                     axis2_transport_in_desc_t *transport_in_desc,
                     const axis2_env_t *env);
 
-    /**
-     * De-allocate memory
-     * @param void transport_in to be freed
-     * @return status code
-     */
+        /**
+         * Frees transport in description given as a void parameter.
+         * @param transport_in pointer to transport in description as a void 
+         * pointer
+         * @param env pointer to environment struct
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+         */
         axis2_status_t (AXIS2_CALL *
             free_void_arg) (
                     void *transport_in,
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in
+         * Gets QName.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return pointer to QName
          */
-        axis2_qname_t *(AXIS2_CALL *
+        const axis2_qname_t *(AXIS2_CALL *
                 get_qname)(
                     const axis2_transport_in_desc_t *transport_in,
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in
+         * Sets QName.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param qname pointer to qname struct
+         * @param qname pointer to QName, this method creates a clone of QName
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
                 set_qname)(
                     struct axis2_transport_in_desc *transport_in,
                     const axis2_env_t *env,
-                    axis2_qname_t *qname);
+                    const axis2_qname_t *qname);
 
         /**
-         * @param transport_in pointer to transport in
+         * Gets in flow. In flow represents the list of phases invoked 
+         * along the receive path.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return pointer to flow representing in flow, returns a reference,
+         * not a cloned copy
          */
         struct axis2_flow *(AXIS2_CALL *
-                get_inflow)(
+                get_in_flow)(
                     const axis2_transport_in_desc_t *transport_in,
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in 
-         * @param env pointer to environment struct
-         * @param inflow pointer to in flow
+         * Sets in flow. In flow represents the list of phases invoked 
+         * along the receive path.
+         * @param transport_in pointer to transport in description struct
+         * @param env pointer to environment struct
+         * @param in_flow pointer to in flow representing in flow, transport in 
+         * description assumes ownership of the flow
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
-                set_inflow)(
+                set_in_flow)(
                     struct axis2_transport_in_desc *transport_in,
                     const axis2_env_t *env,
-                    struct axis2_flow *inflow);
+                    struct axis2_flow *in_flow);
 
         /**
-         * @param transport_in pointer to transport in
+         * Gets fault in flow. Fault in flow represents the list of phases 
+         * invoked along the receive path if a fault happens.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return pointer to flow representing fault in flow, returns a 
+         * reference, not a cloned copy 
          */
         struct axis2_flow *(AXIS2_CALL *
-                get_faultflow)(
+                get_fault_in_flow)(
                     const axis2_transport_in_desc_t *transport_in,
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in
-         * @param env pointer to environment struct
-         * @param faultflow pointer to fault flow
+         * Sets fault in flow. Fault in flow represents the list of phases 
+         * invoked along the receive path if a fault happens.
+         * @param transport_in pointer to transport in description struct
+         * @param env pointer to environment struct
+         * @param fault_in_flow pointer to flow representing fault in flow, 
+         * transport in description assumes the ownership of the flow
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
-                set_faultflow)(
+                set_fault_in_flow)(
                     struct axis2_transport_in_desc *transport_in,
                     const axis2_env_t *env,
-                    struct axis2_flow *faultflow);
+                    struct axis2_flow *fault_in_flow);
 
         /**
-         * @param transport_in pointer to transport in
+         * Gets transport receiver associated with the transport in description.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return pointer to transport receiver, returns a reference, not 
+         * a cloned copy
          */
         struct axis2_transport_receiver *(AXIS2_CALL *
                 get_recv)(
@@ -149,9 +182,12 @@
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in
+         * Sets transport receiver associated with the transport in description.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param recv pointer to transport receiver
+         * @param recv pointer to transport receiver, transport in 
+         * description assumes ownership of the receiver
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
                 set_recv)(
@@ -160,8 +196,10 @@
                     struct axis2_transport_receiver *recv);
 
         /**
-         * @param transport_in pointer to transport in
+         * Gets the transport in phase associated with transport in description.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return transport in phase, returns a reference, not a cloned copy
          */
         struct axis2_phase *(AXIS2_CALL *
                 get_in_phase)(
@@ -169,9 +207,12 @@
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in
+         * Sets the transport in phase associated with transport in description.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param in_phase pointer to in phase
+         * @param in_phase pointer to phase representing transport in phase, 
+         * transport in description assumes ownership of phase
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
                 set_in_phase)(
@@ -180,29 +221,36 @@
                     struct axis2_phase *in_phase);
 
         /**
-         * @param transport_in pointer to transport in
+         * Gets the transport fault phase associated with transport in description.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
+         * @return pointer to phase representing fault phase
          */
         struct axis2_phase *(AXIS2_CALL *
-                get_faultphase)(
+                get_fault_phase)(
                     const axis2_transport_in_desc_t *transport_in,
                     const axis2_env_t *env);
 
         /**
-         * @param transport_in pointer to transport in
+         * Sets the transport fault phase associated with transport in description.
+         * @param transport_in pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param faultphase pointer to fault phase
+         * @param fault_phase pointer to fault phase
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
-                set_faultphase)(
+                set_fault_phase)(
                     struct axis2_transport_in_desc *transport_in,
                     const axis2_env_t *env,
-                    struct axis2_phase *faultphase);
+                    struct axis2_phase *fault_phase);
 
         /**
-         * @param transport_in_desc pointer to transport in description
+         * Adds given parameter.
+         * @param transport_in_desc pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param param pointer to param
+         * @param param pointer to parameter, transport in description assumes
+         * ownership of parameter
+         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
         axis2_status_t (AXIS2_CALL *
                 add_param)(
@@ -211,137 +259,146 @@
                     axis2_param_t *param);
 
         /**
-         * @param transport_in_desc pointer to transport in description
+         * Gets named parameter.
+         * @param transport_in_desc pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param param_name pointer to parameter name
+         * @param param_name parameter name string
+         * @return pointer to named parameter if it exists, else NULL. Returns
+         * a reference, not a cloned copy
          */
         axis2_param_t *(AXIS2_CALL *
                 get_param)(
                     const axis2_transport_in_desc_t *transport_in_desc,
                     const axis2_env_t *env,
-                    axis2_char_t *param_name);
+                    const axis2_char_t *param_name);
 
         /**
-         * @param transport_in_desc pointer to transport in description
+         * Checks if the named parameter is locked.
+         * @param transport_in_desc pointer to transport in description struct
          * @param env pointer to environment struct
-         * @param param_name pointer to parameter name
+         * @param param_name parameter name string
+         * @return AXIS2_TRUE if named parameter is locked, else AXIS2_FALSE
          */
         axis2_bool_t (AXIS2_CALL *
                 is_param_locked)(
                     axis2_transport_in_desc_t *transport_in_desc,
                     const axis2_env_t *env,
-                    axis2_char_t *param_name);
+                    const axis2_char_t *param_name);
     };
 
     /**
-     * transport in description struct
+     * transport in description struct.
      */
     struct axis2_transport_in_desc
     {
         /** transport in description struct ops */
         axis2_transport_in_desc_ops_t *ops;
+        /** parameter container to hold transport in related parameters */
         axis2_param_container_t *param_container;
     };
 
     /**
-     * Creates phase holder struct
+     * Creates transport in description with given QName.
      * @param env pointer to environment struct
-     * @param qname pointer to qname
+     * @param qname pointer to QName
      * @return pointer to newly created phase holder
      */
     AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL
     axis2_transport_in_desc_create_with_qname (
             const axis2_env_t *env,
-            axis2_qname_t *qname);
+            const axis2_qname_t *qname);
 
-    axis2_status_t AXIS2_CALL
-    axis2_transport_in_desc_free_void_arg(
+    /**
+     * Frees transport in description given as a void parameter.
+     * @param transport_in pointer to transport in description as a void 
+     * pointer
+     * @param env pointer to environment struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+     axis2_status_t AXIS2_CALL
+     axis2_transport_in_desc_free_void_arg(
             void *transport_in,
             const axis2_env_t *env);
 
-/*************************** Function macros **********************************/
-
-/** Frees the transport in description.
+/** Frees transport in description.
     @sa axis2_transport_in_desc_ops#free */
 #define AXIS2_TRANSPORT_IN_DESC_FREE(transport_in_desc, env) \
       ((transport_in_desc)->ops->free (transport_in_desc, env))
 
-/** Gets the qualified name.
+/** Gets QName.
     @sa axis2_transport_in_desc_ops#get_qname */
 #define AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env) \
       ((transport_in_desc)->ops->get_qname (transport_in_desc, env))
 
-/** Sets the qualified name.
+/** Sets QName.
     @sa axis2_transport_in_desc_ops#set_qname */
 #define AXIS2_TRANSPORT_IN_DESC_SET_QNAME(transport_in_desc, env, qname) \
       ((transport_in_desc)->ops->set_qname (transport_in_desc, env, qname))
 
-/** Gets the in flow.
-    @sa axis2_transport_in_desc_ops#get_inflow */
+/** Gets in flow.
+    @sa axis2_transport_in_desc_ops#get_in_flow */
 #define AXIS2_TRANSPORT_IN_DESC_GET_IN_FLOW(transport_in_desc, env) \
-      ((transport_in_desc)->ops->get_inflow (transport_in_desc, env))
+      ((transport_in_desc)->ops->get_in_flow (transport_in_desc, env))
 
-/** Sets the in flow.
-    @sa axis2_transport_in_desc_ops#set_inflow */
-#define AXIS2_TRANSPORT_IN_DESC_SET_IN_FLOW(transport_in_desc, env, inflow) \
-      ((transport_in_desc)->ops->set_inflow (transport_in_desc, env, inflow))
-
-/** Gets the fault flow.
-    @sa axis2_transport_in_desc_ops#get_faultflow */
-#define AXIS2_TRANSPORT_IN_DESC_GET_FAULTFLOW(transport_in_desc, env) \
-      ((transport_in_desc)->ops->get_faultflow (transport_in_desc, env))
-
-/** Sets the fault flow.
-    @sa axis2_transport_in_desc_ops#set_faultflow */
-#define AXIS2_TRANSPORT_IN_DESC_SET_FAULTFLOW(transport_in_desc, env, faultflow) \
-      ((transport_in_desc)->ops->set_faultflow (transport_in_desc, env, faultflow))
+/** Sets in flow.
+    @sa axis2_transport_in_desc_ops#set_in_flow */
+#define AXIS2_TRANSPORT_IN_DESC_SET_IN_FLOW(transport_in_desc, env, in_flow) \
+      ((transport_in_desc)->ops->set_in_flow (transport_in_desc, env, in_flow))
+
+/** Gets fault flow.
+    @sa axis2_transport_in_desc_ops#get_fault_in_flow */
+#define AXIS2_TRANSPORT_IN_DESC_GET_FAULT_IN_FLOW(transport_in_desc, env) \
+      ((transport_in_desc)->ops->get_fault_in_flow (transport_in_desc, env))
+
+/** Sets fault flow.
+    @sa axis2_transport_in_desc_ops#set_fault_in_flow */
+#define AXIS2_TRANSPORT_IN_DESC_SET_FAULT_IN_FLOW(transport_in_desc, env, fault_in_flow) \
+      ((transport_in_desc)->ops->set_fault_in_flow (transport_in_desc, env, fault_in_flow))
 
-/** Gets the receiver.
+/** Gets transport receiver.
     @sa axis2_transport_in_desc_ops#get_recv */
 #define AXIS2_TRANSPORT_IN_DESC_GET_RECV(transport_in_desc, env) \
       ((transport_in_desc)->ops->get_recv (transport_in_desc, env))
 
-/** Sets the receiver.
+/** Sets transport receiver.
     @sa axis2_transport_in_desc_ops#set_recv */
 #define AXIS2_TRANSPORT_IN_DESC_SET_RECV(transport_in_desc, env, recv) \
       ((transport_in_desc)->ops->set_recv (transport_in_desc, env, recv))
 
-/** Gets the in phase.
+/** Gets in phase.
     @sa axis2_transport_in_desc_ops#get_in_phase */
 #define AXIS2_TRANSPORT_IN_DESC_GET_IN_PHASE(transport_in_desc, env) \
       ((transport_in_desc)->ops->get_in_phase (transport_in_desc, env))
 
-/** Sets the in phase.
+/** Sets in phase.
     @sa axis2_transport_in_desc_ops#set_in_phase */
 #define AXIS2_TRANSPORT_IN_DESC_SET_IN_PHASE(transport_in_desc, env, in_phase) \
       ((transport_in_desc)->ops->set_in_phase (transport_in_desc, env, in_phase))
 
-/** Gets the fault phase.
-    @sa axis2_transport_in_desc_ops#get_faultphase */
-#define AXIS2_TRANSPORT_IN_DESC_GET_FAULTPHASE(transport_in_desc, env) \
-      ((transport_in_desc)->ops->get_faultphase (transport_in_desc, env))
-
-/** Sets the fault phase.
-    @sa axis2_transport_in_desc_ops#set_faultphase */
-#define AXIS2_TRANSPORT_IN_DESC_SET_FAULTPHASE(transport_in_desc, env, faultphase) \
-      ((transport_in_desc)->ops->set_faultphase (transport_in_desc, env, faultphase))
+/** Gets fault phase.
+    @sa axis2_transport_in_desc_ops#get_fault_phase */
+#define AXIS2_TRANSPORT_IN_DESC_GET_FAULT_PHASE(transport_in_desc, env) \
+      ((transport_in_desc)->ops->get_fault_phase (transport_in_desc, env))
+
+/** Sets fault phase.
+    @sa axis2_transport_in_desc_ops#set_fault_phase */
+#define AXIS2_TRANSPORT_IN_DESC_SET_FAULT_PHASE(transport_in_desc, env, fault_phase) \
+      ((transport_in_desc)->ops->set_fault_phase (transport_in_desc, env, fault_phase))
 
-/** Adds the parameter.
+/** Adds parameter.
     @sa axis2_transport_in_desc_ops#add_param */
 #define AXIS2_TRANSPORT_IN_DESC_ADD_PARAM(transport_in_desc, env, param) \
       ((transport_in_desc)->ops->add_param (transport_in_desc, env, param))
 
-/** Gets the parameter.
+/** Gets named parameter.
     @sa axis2_transport_in_desc_ops#get_param */
 #define AXIS2_TRANSPORT_IN_DESC_GET_PARAM(transport_in_desc, env, param_name) \
       ((transport_in_desc)->ops->get_param (transport_in_desc, env, param_name))
 
-/** Is param locked.
+/** Checks if the named parameter is locked.
     @sa axis2_transport_in_desc_ops#is_param_locked */
 #define AXIS2_TRANSPORT_IN_DESC_IS_PARAM_LOCKED(transport_in_desc, env, param_name) \
       ((transport_in_desc)->ops->is_param_locked (transport_in_desc, env, param_name))
-
-/*************************** End of function macros ***************************/
 
 /** @} */
 

Modified: webservices/axis2/trunk/c/modules/core/context/msg_ctx.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/context/msg_ctx.c?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/context/msg_ctx.c (original)
+++ webservices/axis2/trunk/c/modules/core/context/msg_ctx.c Mon Aug 28 07:59:48 2006
@@ -725,9 +725,11 @@
         msg_ctx_impl->conf_ctx = conf_ctx;
 
     if (msg_ctx_impl->transport_in_desc)
-        msg_ctx_impl->transport_in_desc_qname = AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env);
+        msg_ctx_impl->transport_in_desc_qname = 
+            (axis2_qname_t *)AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env);
     if (msg_ctx_impl->transport_out_desc)
-        msg_ctx_impl->transport_out_desc_qname = AXIS2_TRANSPORT_OUT_DESC_GET_QNAME(transport_out_desc, env);
+        msg_ctx_impl->transport_out_desc_qname = 
+            (axis2_qname_t *)AXIS2_TRANSPORT_OUT_DESC_GET_QNAME(transport_out_desc, env);
     
     msg_ctx_impl->msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
     if (!(msg_ctx_impl->msg_info_headers))
@@ -1587,7 +1589,7 @@
     {
         AXIS2_INTF_TO_IMPL(msg_ctx)->transport_in_desc = transport_in_desc;
         AXIS2_INTF_TO_IMPL(msg_ctx)->transport_in_desc_qname = 
-            AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env);
+            (axis2_qname_t *)AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env);
     }
     
     return AXIS2_SUCCESS;
@@ -1605,7 +1607,7 @@
     {
         AXIS2_INTF_TO_IMPL(msg_ctx)->transport_out_desc = transport_out_desc;
         AXIS2_INTF_TO_IMPL(msg_ctx)->transport_out_desc_qname = 
-            AXIS2_TRANSPORT_OUT_DESC_GET_QNAME(transport_out_desc, env);
+            (axis2_qname_t *)AXIS2_TRANSPORT_OUT_DESC_GET_QNAME(transport_out_desc, env);
     }
     
     return AXIS2_SUCCESS;

Modified: webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c Mon Aug 28 07:59:48 2006
@@ -1071,7 +1071,7 @@
                 flow = AXIS2_DESC_BUILDER_PROCESS_FLOW(conf_builder->desc_builder,
                     env, in_fault_flow_element, builder_impl->conf->
                         param_container, in_fault_flow_node);
-                status = AXIS2_TRANSPORT_IN_DESC_SET_FAULTFLOW(transport_in, 
+                status = AXIS2_TRANSPORT_IN_DESC_SET_FAULT_IN_FLOW(transport_in, 
                     env, flow);
                 if(AXIS2_SUCCESS != status)
                 {

Modified: webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c Mon Aug 28 07:59:48 2006
@@ -1,67 +1,45 @@
 /*
- * 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_transport_in_desc.h>
 #include <axis2_transport_receiver.h>
 
-/** 
- * @brief Description transport in struct impl
- * Transport in
- * Represents a incoming transport deployed in AXis2
- */ 
 typedef struct axis2_transport_in_desc_impl
 {
-   axis2_transport_in_desc_t transport_in;    
-    /** 
-     * Field flowInclude 
-     * This will have a shallow copy and will not be freed by the descructor
-     */
-    axis2_flow_t *inflow;
-    /** 
-     * Field flowInclude 
-     * This will have a shallow copy and will not be freed by the descructor
-     */
-    axis2_flow_t *faultflow;
-    /** 
-     * Field name
-     * This will have a shallow copy and will not be freed by the descructor
-     */
+    axis2_transport_in_desc_t transport_in;
+    axis2_flow_t *in_flow;
+    axis2_flow_t *fault_in_flow;
     axis2_qname_t *qname;
     /**
-     * This will have a shallow copy, but will be freed by the descructor
+     * transport receiver will have a shallow copy, but will be freed by 
+     * free function.
      */
     axis2_transport_receiver_t *recv;
-    /** to store handler in inFlow */
     axis2_phase_t *in_phase;
-    /** to store handler Fault in inFlow */
-    axis2_phase_t *faultphase;
-    
-}
-axis2_transport_in_desc_impl_t;
+    axis2_phase_t *fault_phase;
+} axis2_transport_in_desc_impl_t;
 
 #define AXIS2_INTF_TO_IMPL(transport_in) ((axis2_transport_in_desc_impl_t *)transport_in)
 
-/************************* Function prototypes ********************************/
-
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_free(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env);
 
-axis2_qname_t *AXIS2_CALL
+const axis2_qname_t *AXIS2_CALL
 axis2_transport_in_desc_get_qname(
     const axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env);
@@ -70,29 +48,29 @@
 axis2_transport_in_desc_set_qname(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_qname_t *qname);
+    const axis2_qname_t *qname);
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_in_desc_get_inflow(
+axis2_transport_in_desc_get_in_flow(
     const axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_inflow(
+axis2_transport_in_desc_set_in_flow(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_flow_t *inflow);
+    axis2_flow_t *in_flow);
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_in_desc_get_faultflow(
+axis2_transport_in_desc_get_fault_in_flow(
     const axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_faultflow(
+axis2_transport_in_desc_set_fault_in_flow(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_flow_t *faultflow);
+    axis2_flow_t *fault_in_flow);
 
 axis2_transport_receiver_t *AXIS2_CALL
 axis2_transport_in_desc_get_recv(
@@ -115,17 +93,17 @@
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
     axis2_phase_t *in_phase);
-                                            
+
 axis2_phase_t *AXIS2_CALL
-axis2_transport_in_desc_get_faultphase(
+axis2_transport_in_desc_get_fault_phase(
     const axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_faultphase(
+axis2_transport_in_desc_set_fault_phase(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_phase_t *faultphase);
+    axis2_phase_t *fault_phase);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_add_param(
@@ -137,185 +115,183 @@
 axis2_transport_in_desc_get_param(
     const axis2_transport_in_desc_t *transport_in_desc,
     const axis2_env_t *env,
-    axis2_char_t *param_name);
+    const axis2_char_t *param_name);
 
 axis2_bool_t AXIS2_CALL
 axis2_transport_in_desc_is_param_locked(
     axis2_transport_in_desc_t *
     transport_in_desc,
     const axis2_env_t *env,
-    axis2_char_t *param_name);
+    const axis2_char_t *param_name);
 
-/************************** End of function prototypes ************************/
 
-AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL 
+AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL
 axis2_transport_in_desc_create_with_qname(
-    const axis2_env_t *env, 
-    axis2_qname_t *qname)
+    const axis2_env_t *env,
+    const axis2_qname_t *qname)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, qname, NULL);
-    
+
     transport_in_impl = (axis2_transport_in_desc_impl_t *) AXIS2_MALLOC(env->
-        allocator, sizeof(axis2_transport_in_desc_impl_t));
-   
-   if(NULL == transport_in_impl)
+            allocator, sizeof(axis2_transport_in_desc_impl_t));
+
+    if (NULL == transport_in_impl)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     transport_in_impl->qname = NULL;
     transport_in_impl->in_phase = NULL;
-    transport_in_impl->faultphase = NULL;
-    transport_in_impl->inflow = NULL;
-    transport_in_impl->faultflow = NULL;
+    transport_in_impl->fault_phase = NULL;
+    transport_in_impl->in_flow = NULL;
+    transport_in_impl->fault_in_flow = NULL;
     transport_in_impl->recv = NULL;
-    transport_in_impl->transport_in.ops = NULL; 
+    transport_in_impl->transport_in.ops = NULL;
     transport_in_impl->transport_in.param_container = NULL;
-    
+
     transport_in_impl->transport_in.param_container = axis2_param_container_create(env);
-    if(NULL == transport_in_impl->transport_in.param_container)
+    if (NULL == transport_in_impl->transport_in.param_container)
     {
         axis2_transport_in_desc_free(&(transport_in_impl->transport_in), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     transport_in_impl->qname = AXIS2_QNAME_CLONE(qname, env);
-    
-   transport_in_impl->transport_in.ops = 
-      AXIS2_MALLOC (env->allocator, sizeof(axis2_transport_in_desc_ops_t));
-   if(NULL == transport_in_impl->transport_in.ops)
+
+    transport_in_impl->transport_in.ops =
+        AXIS2_MALLOC (env->allocator, sizeof(axis2_transport_in_desc_ops_t));
+    if (NULL == transport_in_impl->transport_in.ops)
     {
         axis2_transport_in_desc_free(&(transport_in_impl->transport_in), 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;
     }
-    
+
     transport_in_impl->transport_in.ops->free = axis2_transport_in_desc_free;
-    transport_in_impl->transport_in.ops->free_void_arg = 
+    transport_in_impl->transport_in.ops->free_void_arg =
         axis2_transport_in_desc_free_void_arg;
-    
-   transport_in_impl->transport_in.ops->get_qname =  
+
+    transport_in_impl->transport_in.ops->get_qname =
         axis2_transport_in_desc_get_qname;
-   transport_in_impl->transport_in.ops->set_qname =  
+    transport_in_impl->transport_in.ops->set_qname =
         axis2_transport_in_desc_set_qname;
-   transport_in_impl->transport_in.ops->get_inflow =  
-        axis2_transport_in_desc_get_inflow;
-   transport_in_impl->transport_in.ops->set_inflow = 
-        axis2_transport_in_desc_set_inflow;
-    transport_in_impl->transport_in.ops->get_faultflow = 
-        axis2_transport_in_desc_get_faultflow;
-    transport_in_impl->transport_in.ops->set_faultflow = 
-        axis2_transport_in_desc_set_faultflow;
-    transport_in_impl->transport_in.ops->get_recv = 
+    transport_in_impl->transport_in.ops->get_in_flow =
+        axis2_transport_in_desc_get_in_flow;
+    transport_in_impl->transport_in.ops->set_in_flow =
+        axis2_transport_in_desc_set_in_flow;
+    transport_in_impl->transport_in.ops->get_fault_in_flow =
+        axis2_transport_in_desc_get_fault_in_flow;
+    transport_in_impl->transport_in.ops->set_fault_in_flow =
+        axis2_transport_in_desc_set_fault_in_flow;
+    transport_in_impl->transport_in.ops->get_recv =
         axis2_transport_in_desc_get_recv;
-    transport_in_impl->transport_in.ops->set_recv = 
+    transport_in_impl->transport_in.ops->set_recv =
         axis2_transport_in_desc_set_recv;
-    transport_in_impl->transport_in.ops->get_in_phase = 
+    transport_in_impl->transport_in.ops->get_in_phase =
         axis2_transport_in_desc_get_in_phase;
-    transport_in_impl->transport_in.ops->set_in_phase = 
+    transport_in_impl->transport_in.ops->set_in_phase =
         axis2_transport_in_desc_set_in_phase;
-    transport_in_impl->transport_in.ops->get_faultphase = 
-        axis2_transport_in_desc_get_faultphase;
-    transport_in_impl->transport_in.ops->set_faultphase = 
-        axis2_transport_in_desc_set_faultphase;
-    transport_in_impl->transport_in.ops->add_param = 
-    axis2_transport_in_desc_add_param;
-    transport_in_impl->transport_in.ops->get_param = 
-    axis2_transport_in_desc_get_param;
-    transport_in_impl->transport_in.ops->is_param_locked = 
-    axis2_transport_in_desc_is_param_locked;
-    
-   return &(transport_in_impl->transport_in);
+    transport_in_impl->transport_in.ops->get_fault_phase =
+        axis2_transport_in_desc_get_fault_phase;
+    transport_in_impl->transport_in.ops->set_fault_phase =
+        axis2_transport_in_desc_set_fault_phase;
+    transport_in_impl->transport_in.ops->add_param =
+        axis2_transport_in_desc_add_param;
+    transport_in_impl->transport_in.ops->get_param =
+        axis2_transport_in_desc_get_param;
+    transport_in_impl->transport_in.ops->is_param_locked =
+        axis2_transport_in_desc_is_param_locked;
+
+    return &(transport_in_impl->transport_in);
 }
 
-/***************************Function implementation****************************/
 
-axis2_status_t AXIS2_CALL 
+axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_free(
-    axis2_transport_in_desc_t *transport_in, 
+    axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    
+
     if (transport_in_impl->recv)
     {
         AXIS2_TRANSPORT_RECEIVER_FREE(transport_in_impl->recv, env);
         transport_in_impl->recv = NULL;
     }
-      
-   if(NULL != transport_in->ops)
+
+    if (NULL != transport_in->ops)
     {
         AXIS2_FREE(env->allocator, transport_in->ops);
         transport_in->ops = NULL;
     }
-    
-    if(NULL != transport_in->param_container)
+
+    if (NULL != transport_in->param_container)
     {
         AXIS2_PARAM_CONTAINER_FREE(transport_in->param_container, env);
         transport_in->param_container = NULL;
     }
-    
-    if(NULL != transport_in_impl->qname)
+
+    if (NULL != transport_in_impl->qname)
     {
         AXIS2_QNAME_FREE(transport_in_impl->qname, env);
         transport_in_impl->qname = NULL;
     }
-    
-    if(transport_in_impl->inflow)
-    {   
-        AXIS2_FLOW_FREE(transport_in_impl->inflow, env);        
-        transport_in_impl->inflow = NULL;
-    }
-    
-    if(transport_in_impl->faultflow)
-    {   
-        AXIS2_FLOW_FREE(transport_in_impl->faultflow, env);        
-        transport_in_impl->faultflow = NULL;
-    }
-    
-    if(transport_in_impl->in_phase)
-    {   
-        AXIS2_FLOW_FREE(transport_in_impl->in_phase, env);        
+
+    if (transport_in_impl->in_flow)
+    {
+        AXIS2_FLOW_FREE(transport_in_impl->in_flow, env);
+        transport_in_impl->in_flow = NULL;
+    }
+
+    if (transport_in_impl->fault_in_flow)
+    {
+        AXIS2_FLOW_FREE(transport_in_impl->fault_in_flow, env);
+        transport_in_impl->fault_in_flow = NULL;
+    }
+
+    if (transport_in_impl->in_phase)
+    {
+        AXIS2_FLOW_FREE(transport_in_impl->in_phase, env);
         transport_in_impl->in_phase = NULL;
     }
-    
-    if(transport_in_impl->faultphase)
-    {   
-        AXIS2_FLOW_FREE(transport_in_impl->faultphase, env);        
-        transport_in_impl->faultphase = NULL;
+
+    if (transport_in_impl->fault_phase)
+    {
+        AXIS2_FLOW_FREE(transport_in_impl->fault_phase, env);
+        transport_in_impl->fault_phase = NULL;
     }
-    
+
     AXIS2_FREE(env->allocator, transport_in_impl);
-    
-   return AXIS2_SUCCESS;
+
+    return AXIS2_SUCCESS;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_free_void_arg(
-        void *transport_in,
-        const axis2_env_t *env)
+    void *transport_in,
+    const axis2_env_t *env)
 {
     axis2_transport_in_desc_t *transport_in_l = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     transport_in_l = (axis2_transport_in_desc_t *) transport_in;
     return axis2_transport_in_desc_free(transport_in_l, env);
 }
 
-axis2_qname_t *AXIS2_CALL
+const axis2_qname_t *AXIS2_CALL
 axis2_transport_in_desc_get_qname(
     const axis2_transport_in_desc_t *transport_in,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_in)->qname;
@@ -325,16 +301,16 @@
 axis2_transport_in_desc_set_qname(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_qname_t *qname) 
+    const axis2_qname_t *qname)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
-    
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    
-    if(transport_in_impl->qname)
+
+    if (transport_in_impl->qname)
     {
         AXIS2_QNAME_FREE(transport_in_impl->qname, env);
         transport_in_impl->qname = NULL;
@@ -344,66 +320,66 @@
 }
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_in_desc_get_inflow(
+axis2_transport_in_desc_get_in_flow(
     const axis2_transport_in_desc_t *transport_in,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(transport_in)->inflow;
+    return AXIS2_INTF_TO_IMPL(transport_in)->in_flow;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_inflow(
+axis2_transport_in_desc_set_in_flow(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_flow_t *inflow) 
+    axis2_flow_t *in_flow)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, inflow, AXIS2_FAILURE);
-    
+    AXIS2_PARAM_CHECK(env->error, in_flow, AXIS2_FAILURE);
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    if(transport_in_impl->inflow)
+    if (transport_in_impl->in_flow)
     {
-        AXIS2_FLOW_FREE(transport_in_impl->inflow, env);
-        transport_in_impl->inflow = NULL;
+        AXIS2_FLOW_FREE(transport_in_impl->in_flow, env);
+        transport_in_impl->in_flow = NULL;
     }
-    transport_in_impl->inflow = inflow;
+    transport_in_impl->in_flow = in_flow;
     return AXIS2_SUCCESS;
 }
 
 axis2_flow_t *AXIS2_CALL
-axis2_transport_in_desc_get_faultflow(
+axis2_transport_in_desc_get_fault_in_flow(
     const axis2_transport_in_desc_t *transport_in,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
-    return AXIS2_INTF_TO_IMPL(transport_in)->faultflow;
+    return AXIS2_INTF_TO_IMPL(transport_in)->fault_in_flow;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_faultflow(
+axis2_transport_in_desc_set_fault_in_flow(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_flow_t *faultflow) 
+    axis2_flow_t *fault_in_flow)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, faultflow, AXIS2_FAILURE);
-    
+    AXIS2_PARAM_CHECK(env->error, fault_in_flow, AXIS2_FAILURE);
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    if(transport_in_impl->faultflow)
+    if (transport_in_impl->fault_in_flow)
     {
-        AXIS2_FLOW_FREE(transport_in_impl->faultflow, env);
-        transport_in_impl->faultflow = NULL;
+        AXIS2_FLOW_FREE(transport_in_impl->fault_in_flow, env);
+        transport_in_impl->fault_in_flow = NULL;
     }
-    transport_in_impl->faultflow = faultflow;
+    transport_in_impl->fault_in_flow = fault_in_flow;
     return AXIS2_SUCCESS;
 }
 
 axis2_transport_receiver_t *AXIS2_CALL
 axis2_transport_in_desc_get_recv(
     const axis2_transport_in_desc_t *transport_in,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_in)->recv;
@@ -413,20 +389,20 @@
 axis2_transport_in_desc_set_recv(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_transport_receiver_t *recv) 
+    axis2_transport_receiver_t *recv)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, recv, AXIS2_FAILURE);
-   
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    
+
     if (transport_in_impl->recv)
     {
         AXIS2_TRANSPORT_RECEIVER_FREE(transport_in_impl->recv, env);
         transport_in_impl->recv = NULL;
     }
-      
+
     transport_in_impl->recv = recv;
     return AXIS2_SUCCESS;
 }
@@ -434,10 +410,10 @@
 axis2_phase_t *AXIS2_CALL
 axis2_transport_in_desc_get_in_phase(
     const axis2_transport_in_desc_t *transport_in,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return AXIS2_INTF_TO_IMPL(transport_in)->in_phase;
 }
 
@@ -445,15 +421,15 @@
 axis2_transport_in_desc_set_in_phase(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_phase_t *in_phase) 
+    axis2_phase_t *in_phase)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, in_phase, AXIS2_FAILURE);
-    
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    if(transport_in_impl->in_phase)
+    if (transport_in_impl->in_phase)
     {
         AXIS2_FLOW_FREE(transport_in_impl->in_phase, env);
         transport_in_impl->in_phase = NULL;
@@ -463,35 +439,35 @@
 }
 
 axis2_phase_t *AXIS2_CALL
-axis2_transport_in_desc_get_faultphase(
+axis2_transport_in_desc_get_fault_phase(
     const axis2_transport_in_desc_t *transport_in,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
-    return AXIS2_INTF_TO_IMPL(transport_in)->faultphase;
+
+    return AXIS2_INTF_TO_IMPL(transport_in)->fault_phase;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_transport_in_desc_set_faultphase(
+axis2_transport_in_desc_set_fault_phase(
     axis2_transport_in_desc_t *transport_in,
     const axis2_env_t *env,
-    axis2_phase_t *faultphase) 
+    axis2_phase_t *fault_phase)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, faultphase, AXIS2_FAILURE);
-    
+    AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE);
+
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
-    if(transport_in_impl->faultphase)
+    if (transport_in_impl->fault_phase)
     {
-        AXIS2_FLOW_FREE(transport_in_impl->faultphase, env);
-        transport_in_impl->faultphase = NULL;
+        AXIS2_FLOW_FREE(transport_in_impl->fault_phase, env);
+        transport_in_impl->fault_phase = NULL;
     }
-    transport_in_impl->faultphase = faultphase;
+    transport_in_impl->fault_phase = fault_phase;
     return AXIS2_SUCCESS;
-    
+
 }
 
 axis2_status_t AXIS2_CALL
@@ -501,8 +477,8 @@
     axis2_param_t *param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);    
-    
+    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
+
     return AXIS2_PARAM_CONTAINER_ADD_PARAM(transport_in_desc->
             param_container, env, param);
 }
@@ -511,13 +487,13 @@
 axis2_transport_in_desc_get_param(
     const axis2_transport_in_desc_t *transport_in_desc,
     const axis2_env_t *env,
-    axis2_char_t *param_name)
+    const axis2_char_t *param_name)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK(env->error, param_name, NULL);    
-    
-    return AXIS2_PARAM_CONTAINER_GET_PARAM(transport_in_desc->param_container, 
-        env, param_name);
+    AXIS2_PARAM_CHECK(env->error, param_name, NULL);
+
+    return AXIS2_PARAM_CONTAINER_GET_PARAM(transport_in_desc->param_container,
+            env, param_name);
 }
 
 axis2_bool_t AXIS2_CALL
@@ -525,11 +501,11 @@
     axis2_transport_in_desc_t *
     transport_in_desc,
     const axis2_env_t *env,
-    axis2_char_t *param_name)
+    const axis2_char_t *param_name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
 
     return AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(transport_in_desc->
-        param_container, env, param_name);
+            param_container, env, param_name);
 }

Modified: webservices/axis2/trunk/c/modules/core/description/transport_out_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/transport_out_desc.c?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/transport_out_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/transport_out_desc.c Mon Aug 28 07:59:48 2006
@@ -1,61 +1,62 @@
 /*
- * 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_transport_out_desc.h>
-    
-/** 
+
+/**
  * @brief Description transport out struct impl
  * Transport out
  * Represents a incoming transport deployed in AXis2
- */ 
+ */
 typedef struct axis2_transport_out_desc_impl
 {
     axis2_transport_out_desc_t transport_out;
-    
-    /** 
-     * Field flowInclude 
+
+    /**
+     * Field flowInclude
      * This will have a shallow copy and will not be freed by the descructor
      */
     axis2_flow_t *outflow;
-    
-    /** 
-     * Field flowInclude 
+
+    /**
+     * Field flowInclude
      * This will have a shallow copy and will not be freed by the descructor
      */
     axis2_flow_t *faultflow;
-        
-    /** 
+
+    /**
      * Field name
      * This will have a shallow copy and will not be freed by the descructor
      */
     axis2_qname_t *qname;
-    
+
     /**
      * This will have a shallow copy, but will be freed by the descructor
      */
     axis2_transport_sender_t *sender;
-    
+
     /** to store handler in inFlow */
     axis2_phase_t *out_phase;
-        
+
     /** to store handler Fault in inFlow */
     axis2_phase_t *faultphase;
-    
-    
-} axis2_transport_out_desc_impl_t;
+
+
+}
+axis2_transport_out_desc_impl_t;
 
 #define AXIS2_INTF_TO_IMPL(transport_out) ((axis2_transport_out_desc_impl_t *)transport_out)
 
@@ -120,7 +121,7 @@
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
     axis2_phase_t *out_phase);
-                                            
+
 axis2_phase_t *AXIS2_CALL
 axis2_transport_out_desc_get_faultphase(
     const axis2_transport_out_desc_t *transport_out,
@@ -155,23 +156,23 @@
 
 AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL
 axis2_transport_out_desc_create_with_qname(
-    const axis2_env_t *env, 
+    const axis2_env_t *env,
     axis2_qname_t *qname)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
-     
+
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, qname, NULL);
-   
+
     transport_out_impl = (axis2_transport_out_desc_impl_t *) AXIS2_MALLOC(env->
-        allocator, sizeof(axis2_transport_out_desc_impl_t));
-   
-    if(NULL == transport_out_impl)
+            allocator, sizeof(axis2_transport_out_desc_impl_t));
+
+    if (NULL == transport_out_impl)
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     transport_out_impl->qname = NULL;
     transport_out_impl->out_phase = NULL;
     transport_out_impl->faultphase = NULL;
@@ -180,127 +181,127 @@
     transport_out_impl->sender = NULL;
     transport_out_impl->transport_out.ops = NULL;
     transport_out_impl->transport_out.param_container = NULL;
-    
+
     transport_out_impl->transport_out.param_container = axis2_param_container_create(env);
-    if(NULL == transport_out_impl->transport_out.param_container)
+    if (NULL == transport_out_impl->transport_out.param_container)
     {
         axis2_transport_out_desc_free(&(transport_out_impl->transport_out), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    
+
     transport_out_impl->qname = AXIS2_QNAME_CLONE(qname, env);
-    
-    transport_out_impl->transport_out.ops = 
-      AXIS2_MALLOC (env->allocator, sizeof(axis2_transport_out_desc_ops_t));
-    if(NULL == transport_out_impl->transport_out.ops)
+
+    transport_out_impl->transport_out.ops =
+        AXIS2_MALLOC (env->allocator, sizeof(axis2_transport_out_desc_ops_t));
+    if (NULL == transport_out_impl->transport_out.ops)
     {
         axis2_transport_out_desc_free(&(transport_out_impl->transport_out), 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;
     }
-    
+
     transport_out_impl->transport_out.ops->free = axis2_transport_out_desc_free;
-    transport_out_impl->transport_out.ops->free_void_arg = 
+    transport_out_impl->transport_out.ops->free_void_arg =
         axis2_transport_out_desc_free_void_arg;
-    
-    transport_out_impl->transport_out.ops->get_qname =  
+
+    transport_out_impl->transport_out.ops->get_qname =
         axis2_transport_out_desc_get_qname;
-    transport_out_impl->transport_out.ops->set_qname =  
+    transport_out_impl->transport_out.ops->set_qname =
         axis2_transport_out_desc_set_qname;
-    transport_out_impl->transport_out.ops->get_outflow =  
+    transport_out_impl->transport_out.ops->get_outflow =
         axis2_transport_out_desc_get_outflow;
-    transport_out_impl->transport_out.ops->set_outflow = 
+    transport_out_impl->transport_out.ops->set_outflow =
         axis2_transport_out_desc_set_outflow;
-    transport_out_impl->transport_out.ops->get_faultflow = 
+    transport_out_impl->transport_out.ops->get_faultflow =
         axis2_transport_out_desc_get_faultflow;
-    transport_out_impl->transport_out.ops->set_faultflow = 
+    transport_out_impl->transport_out.ops->set_faultflow =
         axis2_transport_out_desc_set_faultflow;
-    transport_out_impl->transport_out.ops->get_sender = 
+    transport_out_impl->transport_out.ops->get_sender =
         axis2_transport_out_desc_get_sender;
-    transport_out_impl->transport_out.ops->set_sender = 
+    transport_out_impl->transport_out.ops->set_sender =
         axis2_transport_out_desc_set_sender;
-    transport_out_impl->transport_out.ops->get_out_phase = 
+    transport_out_impl->transport_out.ops->get_out_phase =
         axis2_transport_out_desc_get_out_phase;
-    transport_out_impl->transport_out.ops->set_out_phase = 
+    transport_out_impl->transport_out.ops->set_out_phase =
         axis2_transport_out_desc_set_out_phase;
-    transport_out_impl->transport_out.ops->get_faultphase = 
+    transport_out_impl->transport_out.ops->get_faultphase =
         axis2_transport_out_desc_get_faultphase;
-    transport_out_impl->transport_out.ops->set_faultphase = 
+    transport_out_impl->transport_out.ops->set_faultphase =
         axis2_transport_out_desc_set_faultphase;
-    transport_out_impl->transport_out.ops->add_param = 
-    axis2_transport_out_desc_add_param;
-    transport_out_impl->transport_out.ops->get_param = 
-    axis2_transport_out_desc_get_param;
-    transport_out_impl->transport_out.ops->is_param_locked = 
-    axis2_transport_out_desc_is_param_locked;
-    
+    transport_out_impl->transport_out.ops->add_param =
+        axis2_transport_out_desc_add_param;
+    transport_out_impl->transport_out.ops->get_param =
+        axis2_transport_out_desc_get_param;
+    transport_out_impl->transport_out.ops->is_param_locked =
+        axis2_transport_out_desc_is_param_locked;
+
     return &(transport_out_impl->transport_out);
 }
 
 /***************************Function implementation****************************/
 
-axis2_status_t AXIS2_CALL 
+axis2_status_t AXIS2_CALL
 axis2_transport_out_desc_free(
-    axis2_transport_out_desc_t *transport_out, 
+    axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
-    
+
     if (transport_out_impl->sender)
     {
         AXIS2_TRANSPORT_SENDER_FREE(transport_out_impl->sender, env);
         transport_out_impl->sender = NULL;
     }
-    
-    if(NULL != transport_out->ops)
+
+    if (NULL != transport_out->ops)
     {
         AXIS2_FREE(env->allocator, transport_out->ops);
         transport_out->ops = NULL;
     }
-    
-    if(NULL != transport_out_impl->transport_out.param_container)
+
+    if (NULL != transport_out_impl->transport_out.param_container)
     {
         AXIS2_PARAM_CONTAINER_FREE(transport_out_impl->transport_out.param_container, env);
         transport_out_impl->transport_out.param_container = NULL;
     }
-    
-    if(NULL != transport_out_impl->qname)
+
+    if (NULL != transport_out_impl->qname)
     {
         AXIS2_QNAME_FREE(transport_out_impl->qname, env);
         transport_out_impl->qname = NULL;
     }
-    
-    if(transport_out_impl->outflow)
-    {   
-        AXIS2_FLOW_FREE(transport_out_impl->outflow, env);        
+
+    if (transport_out_impl->outflow)
+    {
+        AXIS2_FLOW_FREE(transport_out_impl->outflow, env);
         transport_out_impl->outflow = NULL;
     }
-    
-    if(transport_out_impl->faultflow)
-    {   
-        AXIS2_FLOW_FREE(transport_out_impl->faultflow, env);        
+
+    if (transport_out_impl->faultflow)
+    {
+        AXIS2_FLOW_FREE(transport_out_impl->faultflow, env);
         transport_out_impl->faultflow = NULL;
     }
-    
-    if(transport_out_impl->out_phase)
-    {   
-        AXIS2_FLOW_FREE(transport_out_impl->out_phase, env);        
+
+    if (transport_out_impl->out_phase)
+    {
+        AXIS2_FLOW_FREE(transport_out_impl->out_phase, env);
         transport_out_impl->out_phase = NULL;
     }
-    
-    if(transport_out_impl->faultphase)
-    {   
-        AXIS2_FLOW_FREE(transport_out_impl->faultphase, env);        
+
+    if (transport_out_impl->faultphase)
+    {
+        AXIS2_FLOW_FREE(transport_out_impl->faultphase, env);
         transport_out_impl->faultphase = NULL;
     }
-    
+
     AXIS2_FREE(env->allocator, transport_out_impl);
-    
+
     return AXIS2_SUCCESS;
 }
 
@@ -310,9 +311,9 @@
     const axis2_env_t *env)
 {
     axis2_transport_out_desc_t *transport_out_l = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    
+
     transport_out_l = (axis2_transport_out_desc_t *) transport_out;
     return axis2_transport_out_desc_free(transport_out_l, env);
 }
@@ -320,7 +321,7 @@
 axis2_qname_t *AXIS2_CALL
 axis2_transport_out_desc_get_qname(
     const axis2_transport_out_desc_t *transport_out,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_out)->qname;
@@ -330,13 +331,13 @@
 axis2_transport_out_desc_set_qname(
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
-    axis2_qname_t *qname) 
+    axis2_qname_t *qname)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
-    
-    if(transport_out_impl->qname)
+
+    if (transport_out_impl->qname)
     {
         AXIS2_QNAME_FREE(transport_out_impl->qname, env);
         transport_out_impl->qname = NULL;
@@ -348,7 +349,7 @@
 axis2_flow_t *AXIS2_CALL
 axis2_transport_out_desc_get_outflow(
     const axis2_transport_out_desc_t *transport_out,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_out)->outflow;
@@ -358,14 +359,14 @@
 axis2_transport_out_desc_set_outflow(
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
-    axis2_flow_t *outflow) 
+    axis2_flow_t *outflow)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, outflow, AXIS2_FAILURE);
-    
+
     transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
-    if(transport_out_impl->outflow)
+    if (transport_out_impl->outflow)
     {
         AXIS2_FLOW_FREE(transport_out_impl->outflow, env);
         transport_out_impl->outflow = NULL;
@@ -377,7 +378,7 @@
 axis2_flow_t *AXIS2_CALL
 axis2_transport_out_desc_get_faultflow(
     const axis2_transport_out_desc_t *transport_out,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(transport_out)->faultflow;
 }
@@ -386,14 +387,14 @@
 axis2_transport_out_desc_set_faultflow(
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
-    axis2_flow_t *faultflow) 
+    axis2_flow_t *faultflow)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, faultflow, AXIS2_FAILURE);
-    
+
     transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
-    if(transport_out_impl->faultflow)
+    if (transport_out_impl->faultflow)
     {
         AXIS2_FLOW_FREE(transport_out_impl->faultflow, env);
         transport_out_impl->faultflow = NULL;
@@ -405,7 +406,7 @@
 axis2_transport_sender_t *AXIS2_CALL
 axis2_transport_out_desc_get_sender(
     const axis2_transport_out_desc_t *transport_out,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_out)->sender;
@@ -415,12 +416,12 @@
 axis2_transport_out_desc_set_sender(
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
-    axis2_transport_sender_t *sender) 
+    axis2_transport_sender_t *sender)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, sender, AXIS2_FAILURE);
-    
+
     transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
 
     if (transport_out_impl->sender)
@@ -428,7 +429,7 @@
         AXIS2_TRANSPORT_SENDER_FREE(transport_out_impl->sender, env);
         transport_out_impl->sender = NULL;
     }
-    
+
     transport_out_impl->sender = sender;
     return AXIS2_SUCCESS;
 }
@@ -436,10 +437,10 @@
 axis2_phase_t *AXIS2_CALL
 axis2_transport_out_desc_get_out_phase(
     const axis2_transport_out_desc_t *transport_out,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return AXIS2_INTF_TO_IMPL(transport_out)->out_phase;
 }
 
@@ -447,15 +448,15 @@
 axis2_transport_out_desc_set_out_phase(
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
-    axis2_phase_t *out_phase) 
+    axis2_phase_t *out_phase)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, out_phase, AXIS2_FAILURE);
-    
+
     transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
-    if(transport_out_impl->out_phase)
+    if (transport_out_impl->out_phase)
     {
         AXIS2_FLOW_FREE(transport_out_impl->out_phase, env);
         transport_out_impl->out_phase = NULL;
@@ -467,10 +468,10 @@
 axis2_phase_t *AXIS2_CALL
 axis2_transport_out_desc_get_faultphase(
     const axis2_transport_out_desc_t *transport_out,
-    const axis2_env_t *env) 
+    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    
+
     return AXIS2_INTF_TO_IMPL(transport_out)->faultphase;
 }
 
@@ -478,22 +479,22 @@
 axis2_transport_out_desc_set_faultphase(
     axis2_transport_out_desc_t *transport_out,
     const axis2_env_t *env,
-    axis2_phase_t *faultphase) 
+    axis2_phase_t *faultphase)
 {
     axis2_transport_out_desc_impl_t *transport_out_impl = NULL;
-    
+
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, faultphase, AXIS2_FAILURE);
-    
+
     transport_out_impl = AXIS2_INTF_TO_IMPL(transport_out);
-    if(transport_out_impl->faultphase)
+    if (transport_out_impl->faultphase)
     {
         AXIS2_FLOW_FREE(transport_out_impl->faultphase, env);
         transport_out_impl->faultphase = NULL;
     }
     transport_out_impl->faultphase = faultphase;
     return AXIS2_SUCCESS;
-    
+
 }
 
 axis2_status_t AXIS2_CALL
@@ -503,8 +504,8 @@
     axis2_param_t *param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);    
-    
+    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
+
     return AXIS2_PARAM_CONTAINER_ADD_PARAM(transport_out_desc->
             param_container, env, param);
 }
@@ -516,10 +517,10 @@
     axis2_char_t *param_name)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK(env->error, param_name, NULL);    
-    
-    return AXIS2_PARAM_CONTAINER_GET_PARAM(transport_out_desc->param_container, 
-        env, param_name);
+    AXIS2_PARAM_CHECK(env->error, param_name, NULL);
+
+    return AXIS2_PARAM_CONTAINER_GET_PARAM(transport_out_desc->param_container,
+            env, param_name);
 }
 
 axis2_bool_t AXIS2_CALL
@@ -530,8 +531,8 @@
     axis2_char_t *param_name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
 
     return AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(transport_out_desc->
-        param_container, env, param_name);
+            param_container, env, param_name);
 }

Modified: webservices/axis2/trunk/c/modules/core/engine/conf.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/conf.c?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/conf.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/conf.c Mon Aug 28 07:59:48 2006
@@ -1230,7 +1230,7 @@
     axis2_transport_in_desc_t *transport)
 {
     axis2_conf_impl_t *config_impl = NULL;
-    axis2_qname_t *qname = NULL;
+    const axis2_qname_t *qname = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE);

Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c?rev=437720&r1=437719&r2=437720&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c Mon Aug 28 07:59:48 2006
@@ -839,8 +839,8 @@
         }
         case AXIS2_FAULT_IN_FLOW:
         {
-            flow = AXIS2_TRANSPORT_IN_DESC_GET_FAULTFLOW(transport, env);
-            phase = AXIS2_TRANSPORT_IN_DESC_GET_FAULTPHASE(transport, env);
+            flow = AXIS2_TRANSPORT_IN_DESC_GET_FAULT_IN_FLOW(transport, env);
+            phase = AXIS2_TRANSPORT_IN_DESC_GET_FAULT_PHASE(transport, env);
             break;
         }
         }



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