axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r518623 [3/17] - in /webservices/axis2/trunk/c: build/win32/ include/ modules/core/clientapi/ modules/core/deployment/ modules/core/engine/ modules/core/phaseresolver/ modules/core/receivers/ modules/core/transport/http/receiver/ modules/co...
Date Thu, 15 Mar 2007 13:16:11 GMT
Modified: webservices/axis2/trunk/c/include/axis2_engine.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_engine.h?view=diff&rev=518623&r1=518622&r2=518623
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_engine.h (original)
+++ webservices/axis2/trunk/c/include/axis2_engine.h Thu Mar 15 06:16:07 2007
@@ -44,8 +44,6 @@
 {
 #endif
 
-    /** Type name for struct axis2_engine_ops */
-    typedef struct axis2_engine_ops axis2_engine_ops_t;
     /** Type name for struct axis2_engine */
     typedef struct axis2_engine axis2_engine_t;
 
@@ -53,241 +51,209 @@
 
 
     /**
-     * engine ops struct.
-     * Encapsulator struct for ops of axis2_engine.
+     * This methods represents the out flow of the Axis engine both at the 
+     * server side as well as the client side. In this function, the 
+     * execution chain is created using the phases of the out flow. 
+     * All handlers at each out flow phase, which are ordered in the
+     * deployment time are invoked in sequence here.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context representing current state
+     * that is used when sending message
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_send(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+    
+    /**
+     * This methods represents the in flow of the Axis engine,  both at the 
+     * server side as well as the client side. In this function, the 
+     * execution chain is created using the phases of the in flow. 
+     * All handlers at each in flow phase, which are ordered in the
+     * deployment time are invoked in sequence here.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context representing current state
+     * that is used in receiving message
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_receive(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+    
+    /**
+     * Sends a SOAP fault.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context that contains details of 
+     * fault state
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_send_fault(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+                
+    /**
+     * This is invoked when a SOAP fault is received.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context representing that contains
+     * the details of receive state
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
      */
-    struct axis2_engine_ops
-    {
-        /**
-         * This methods represents the out flow of the Axis engine both at the 
-         * server side as well as the client side. In this function, the 
-         * execution chain is created using the phases of the out flow. 
-         * All handlers at each out flow phase, which are ordered in the
-         * deployment time are invoked in sequence here.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context representing current state
-         * that is used when sending message
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                send)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-        
-        /**
-         * This methods represents the in flow of the Axis engine,  both at the 
-         * server side as well as the client side. In this function, the 
-         * execution chain is created using the phases of the in flow. 
-         * All handlers at each in flow phase, which are ordered in the
-         * deployment time are invoked in sequence here.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context representing current state
-         * that is used in receiving message
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                receive)(   
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-        
-        /**
-         * Sends a SOAP fault.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context that contains details of 
-         * fault state
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                send_fault)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-                    
-        /**
-         * This is invoked when a SOAP fault is received.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context representing that contains
-         * the details of receive state
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                receive_fault)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-                    
-        /**
-         * Creates a message context that represents the fault state based on 
-         * current processing state.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param processing_context pointer to message context representing 
-         * current processing context
-         * @return pointer to message context representing the fault state
-         */
-        axis2_msg_ctx_t *(AXIS2_CALL *
-                create_fault_msg_ctx)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *processing_context);
-         
-        /**
-         * Extracts fault information form message context.          
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context containing fault state
-         * @param fault pointer to SOAP fault struct
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                extract_fault_info_from_msg_ctx)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx,
-                    struct axiom_soap_fault *fault);
-
-        /**
-         * Verifies that the context hierarchy consisting of service group 
-         * context, service context and operation context is built.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context containing the context 
-         * related information
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                verify_ctx_built)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Invokes the phases in the given array list of phases. The list of 
-         * phases could be representing one of the flows. The two possible 
-         * flows are in flow and out flow. Both of those flows can also have 
-         * fault related representations, in fault flow and out fault flow.
-         * Invoking a phase triggers the invocation of handlers the phase 
-         * contain. 
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param phases pointer to phases
-         * @param msg_ctx pointer to message context containing current state
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                invoke_phases)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_array_list_t *phases,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Resumes phase invocation. While invoking the phases, one of the 
-         * handlers in any phase could determine to pause the invocation. 
-         * Often pausing happens to wait till some state is reached or some
-         * task is complete. Once paused, the invocation has to be resumed 
-         * using this function, which will resume the invocation from the paused 
-         * handler in the paused phase and will continue till it is paused 
-         * again or it completes invoking all the remaining handlers in the
-         * remaining phases.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param phases pointer to phases
-         * @param msg_ctx pointer to message context containing current paused 
-         * state
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                resume_invocation_phases)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_array_list_t *phases,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Gets sender's SOAP fault code.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param soap_namespace pointer to SOAP namespace
-         * @return pointer to SOAP fault code string
-         */
-        const axis2_char_t *(AXIS2_CALL *
-                get_sender_fault_code)(
-                    const axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    const axis2_char_t *soap_namespace);
-
-
-        /**
-         * Gets receiver's SOAP fault code.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param soap_namespace pointer to soap namespace
-         */
-        const axis2_char_t *(AXIS2_CALL *
-                get_receiver_fault_code)(
-                    const axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    const axis2_char_t *soap_namespace);
-
-        /**
-         * Frees engine struct.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                free)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env);
-
-        /**
-         * Resumes receive operation. It could be the case that receive was 
-         * paused by one of the in flow handlers. In such a situation, this 
-         * method could be used to resume the receive operation.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                resume_receive)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Resumes send operation. It could be the case that send was 
-         * paused by one of the out flow handlers. In such a situation, this 
-         * method could be used to resume the send operation.
-         * @param engine pointer to engine
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
-         */
-        axis2_status_t (AXIS2_CALL *
-                resume_send)(
-                    axis2_engine_t *engine,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_receive_fault(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+                
+    /**
+     * Creates a message context that represents the fault state based on 
+     * current processing state.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param processing_context pointer to message context representing 
+     * current processing context
+     * @return pointer to message context representing the fault state
+     */
+    AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
+    axis2_engine_create_fault_msg_ctx(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *processing_context);
+     
+    /**
+     * Extracts fault information form message context.          
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context containing fault state
+     * @param fault pointer to SOAP fault struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_extract_fault_info_from_msg_ctx(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx,
+        struct axiom_soap_fault *fault);
 
-    };
+    /**
+     * Verifies that the context hierarchy consisting of service group 
+     * context, service context and operation context is built.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context containing the context 
+     * related information
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_verify_ctx_built(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
 
     /**
-     * engine struct.
+     * Invokes the phases in the given array list of phases. The list of 
+     * phases could be representing one of the flows. The two possible 
+     * flows are in flow and out flow. Both of those flows can also have 
+     * fault related representations, in fault flow and out fault flow.
+     * Invoking a phase triggers the invocation of handlers the phase 
+     * contain. 
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param phases pointer to phases
+     * @param msg_ctx pointer to message context containing current state
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
      */
-    struct axis2_engine
-    {
-    
-        /** Operations of engine */
-        axis2_engine_ops_t *ops;
-    };
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_invoke_phases(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_array_list_t *phases,
+        axis2_msg_ctx_t *msg_ctx);
+
+    /**
+     * Resumes phase invocation. While invoking the phases, one of the 
+     * handlers in any phase could determine to pause the invocation. 
+     * Often pausing happens to wait till some state is reached or some
+     * task is complete. Once paused, the invocation has to be resumed 
+     * using this function, which will resume the invocation from the paused 
+     * handler in the paused phase and will continue till it is paused 
+     * again or it completes invoking all the remaining handlers in the
+     * remaining phases.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param phases pointer to phases
+     * @param msg_ctx pointer to message context containing current paused 
+     * state
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_resume_invocation_phases(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_array_list_t *phases,
+        axis2_msg_ctx_t *msg_ctx);
+
+    /**
+     * Gets sender's SOAP fault code.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param soap_namespace pointer to SOAP namespace
+     * @return pointer to SOAP fault code string
+     */
+    AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+    axis2_engine_get_sender_fault_code(const axis2_engine_t *engine,
+        const axis2_env_t *env,
+        const axis2_char_t *soap_namespace);
+
+
+    /**
+     * Gets receiver's SOAP fault code.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param soap_namespace pointer to soap namespace
+     */
+    AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+    axis2_engine_get_receiver_fault_code(const axis2_engine_t *engine,
+        const axis2_env_t *env,
+        const axis2_char_t *soap_namespace);
+
+    /**
+     * Frees engine struct.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_free(axis2_engine_t *engine,
+        const axis2_env_t *env);
+
+    /**
+     * Resumes receive operation. It could be the case that receive was 
+     * paused by one of the in flow handlers. In such a situation, this 
+     * method could be used to resume the receive operation.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_resume_receive(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+
+    /**
+     * Resumes send operation. It could be the case that send was 
+     * paused by one of the out flow handlers. In such a situation, this 
+     * method could be used to resume the send operation.
+     * @param engine pointer to engine
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_engine_resume_send(axis2_engine_t *engine,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
 
     /**
      * Creates en engine struct instance.
@@ -296,79 +262,64 @@
      * @return pointer to newly created engine struct
      */
     AXIS2_EXTERN axis2_engine_t *AXIS2_CALL
-    axis2_engine_create(
-        const axis2_env_t *env,
+    axis2_engine_create(const axis2_env_t *env,
         axis2_conf_ctx_t *conf_ctx);
 
-/** Sends SOAP message invoking the out flow.
-    @sa axis2_engine_ops#send */
+/** Sends SOAP message invoking the out flow. */
 #define AXIS2_ENGINE_SEND(engine, env, msg_ctx)\
-        ((engine)->ops->send(engine, env, msg_ctx))
+        axis2_engine_send(engine, env, msg_ctx)
 
-/** Receives SOAP message invoking the in flow.
-    @sa axis2_engine_ops#receive */
+/** Receives SOAP message invoking the in flow. */
 #define AXIS2_ENGINE_RECEIVE(engine, env, msg_ctx) \
-        ((engine)->ops->receive(engine, env, msg_ctx))
+        axis2_engine_receive(engine, env, msg_ctx)
 
-/** Sends a SOAP fault.
-    @sa axis2_engine_ops#send_fault */
+/** Sends a SOAP fault. */
 #define AXIS2_ENGINE_SEND_FAULT(engine, env, msg_ctx) \
-        ((engine)->ops->send_fault(engine, env, msg_ctx))
+        axis2_engine_send_fault(engine, env, msg_ctx)
 
-/** Receive a SOAP fault.
-    @sa axis2_engine_ops#receive_fault */
+/** Receive a SOAP fault. */
 #define AXIS2_ENGINE_RECEIVE_FAULT(engine, env, msg_ctx) \
-        ((engine)->ops->receive_fault(engine, env, msg_ctx))
+        axis2_engine_receive_fault(engine, env, msg_ctx)
 
-/** Creates fault message context.
-    @sa axis2_engine_ops#create_fault_msg_ctx */
+/** Creates fault message context. */
 #define AXIS2_ENGINE_CREATE_FAULT_MSG_CTX(engine, env, msg_ctx) \
-        ((engine)->ops->create_fault_msg_ctx(engine, env, msg_ctx))
+        axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx)
 
-/** Extracts the fault info from message context,
-    @sa axis2_engine_ops#extract_fault_info_from_msg_ctx */
+/** Extracts the fault info from message context, */
 #define AXIS2_ENGINE_EXTRACT_FAULT_INFO_FROM_MSG_CTX(engine, env, msg_ctx, fault) \
-        ((engine)->ops->extract_fault_info_from_msg_ctx(engine, env, msg_ctx, fault))
+        axis2_engine_extract_fault_info_from_msg_ctx(engine, env, msg_ctx, fault)
 
-/** Verifies that the context hierarchy is built.
-    @sa axis2_engine_ops#verify_ctx_built */
+/** Verifies that the context hierarchy is built. */
 #define AXIS2_ENGINE_VERIFY_CTX_BUILT(engine, env, msg_ctx) \
-        ((engine)->ops->verify_ctx_built(engine, env, msg_ctx))
+        axis2_engine_verify_ctx_built(engine, env, msg_ctx)
 
-/** Invokes the phases.
-    @sa axis2_engine_ops#invoke_phases */
+/** Invokes the phases. */
 #define AXIS2_ENGINE_INVOKE_PHASES(engine, env, phases, msg_ctx) \
-        ((engine)->ops->invoke_phases(engine, env, phases, msg_ctx))
+        axis2_engine_invoke_phases(engine, env, phases, msg_ctx)
 
-/** Resumes the invocation phases.
-    @sa axis2_engine_ops#resume_invocation_phases */
+/** Resumes the invocation phases. */
 #define AXIS2_ENGINE_RESUME_INVOCATION_PHASES(engine, env, phases, msg_ctx) \
-        ((engine)->ops->resume_invocation_phases(engine, env, phases, msg_ctx))
+        axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx)
 
-/** Gets sender fault code.
-    @sa axis2_engine_ops#get_sender_fault_code */
+/** Gets sender fault code. */
 #define AXIS2_ENGINE_GET_SENDER_FAULT_CODE(engine, env, soap_namespace) \
-        ((engine)->ops->get_sender_fault_code(engine, env, soap_namespace))
+        axis2_engine_get_sender_fault_code(engine, env, soap_namespace)
 
-/** Gets receiver fault code.
-    @sa axis2_engine_ops#get_receiver_fault_code */
+/** Gets receiver fault code. */
 #define AXIS2_ENGINE_GET_RECEIVER_FAULT_CODE(engine, env, soap_namespace) \
-        ((engine)->ops->get_receiver_fault_code(engine, env, soap_namespace))
+        axis2_engine_get_receiver_fault_code(engine, env, soap_namespace)
 
-/** Frees engine.
-    @sa axis2_engine_ops#free */
+/** Frees engine. */
 #define AXIS2_ENGINE_FREE(engine, env) \
-        ((engine)->ops->free(engine, env))
+        axis2_engine_free(engine, env)
 
-/** Resumes send operation.
-    @sa axis2_engine_ops#resume_send */
+/** Resumes send operation. */
 #define AXIS2_ENGINE_RESUME_SEND(engine, env, msg_ctx)\
-        ((engine)->ops->resume_send(engine, env, msg_ctx))
+        axis2_engine_resume_send(engine, env, msg_ctx)
 
-/** Resumes  receive operation.
-    @sa axis2_engine_ops#resume_receive */
+/** Resumes  receive operation. */
 #define AXIS2_ENGINE_RESUME_RECEIVE(engine, env, msg_ctx) \
-        ((engine)->ops->resume_receive(engine, env, msg_ctx))
+        axis2_engine_resume_receive(engine, env, msg_ctx)
 
 /** @} */
 #ifdef __cplusplus

Modified: webservices/axis2/trunk/c/include/axis2_listener_manager.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_listener_manager.h?view=diff&rev=518623&r1=518622&r2=518623
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_listener_manager.h (original)
+++ webservices/axis2/trunk/c/include/axis2_listener_manager.h Thu Mar 15 06:16:07 2007
@@ -45,96 +45,75 @@
 {
 #endif
 
-    /** Type name for struct axis2_listener_manager_ops */
-    typedef struct axis2_listener_manager_ops axis2_listener_manager_ops_t;
     /** Type name for struct axis2_listener_manager */
     typedef struct axis2_listener_manager axis2_listener_manager_t;
 
 
     /**
-     * listener manager ops struct.
-     * Encapsulator struct for ops of axis2_listener_manager.
+     * Ensures that the named transport's listener is started. Starts a listener 
+     * if it is not already started. Only one listener would be started for a given 
+     * transport.
+     * @param listener_manager pointer to listener manager struct
+     * @param env pointer to environment struct         
+     * @param transport name of the transport
+     * @param conf_ctx configuration context to pick transport info for the 
+     * named transport
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
-    struct axis2_listener_manager_ops
-    {
-        /**
-         * Ensures that the named transport's listener is started. Starts a listener 
-         * if it is not already started. Only one listener would be started for a given 
-         * transport.
-         * @param listener_manager pointer to listener manager struct
-         * @param env pointer to environment struct         
-         * @param transport name of the transport
-         * @param conf_ctx configuration context to pick transport info for the 
-         * named transport
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                make_sure_started)(
-                    axis2_listener_manager_t *listener_manager,
-                    const axis2_env_t *env,
-                    const AXIS2_TRANSPORT_ENUMS transport,
-                    axis2_conf_ctx_t *conf_ctx);
-
-       /**
-         * Stops the named listener transport.
-         * @param listener_manager pointer to listener manager struct
-         * @param env pointer to environment struct         
-         * @param transport name of the transport whose listener is to be stopped
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                stop)(
-                    axis2_listener_manager_t *listener_manager,
-                    const axis2_env_t *env,
-                    const AXIS2_TRANSPORT_ENUMS transport);
-        /**
-         * Gets reply to end point reference. The engine will direct the 
-         * response for the message to this reply to address.
-         * @param listener_manager pointer to listener manager struct
-         * @param env pointer to environment struct         
-         * @param svc_name name of the service for which the epr is to be returned
-         * @param transport name of the transport corresponding to the endpoint
-         * @return a pointer to endpoint reference struct representing the reply 
-         * endpoint
-         */
-        axis2_endpoint_ref_t* (AXIS2_CALL *
-                get_reply_to_epr)(
-                const axis2_listener_manager_t *listener_manager,
-                const axis2_env_t *env,
-                const axis2_char_t *svc_name,
-                const AXIS2_TRANSPORT_ENUMS transport);
-
-        /**
-         * Gets the configuration context that holds information on the transports 
-         * managed by the listener manager.
-         * @param listener_manager pointer to listener manager struct
-         * @param env pointer to environment struct         
-         */
-        axis2_conf_ctx_t *(AXIS2_CALL *
-                get_conf_ctx)(
-                    const axis2_listener_manager_t *listener_manager,
-                    const axis2_env_t *env);
-       /**
-         * Frees listener manager struct.
-         * @param listener_manager pointer to listener manager struct
-         * @param env pointer to environment struct         
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                free)(
-                    axis2_listener_manager_t *listener_manager,
-                    const axis2_env_t *env);
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_listener_manager_make_sure_started(axis2_listener_manager_t *listener_manager,
+        const axis2_env_t *env,
+        const AXIS2_TRANSPORT_ENUMS transport,
+        axis2_conf_ctx_t *conf_ctx);
+
+   /**
+     * Stops the named listener transport.
+     * @param listener_manager pointer to listener manager struct
+     * @param env pointer to environment struct         
+     * @param transport name of the transport whose listener is to be stopped
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_listener_manager_stop(axis2_listener_manager_t *listener_manager,
+        const axis2_env_t *env,
+        const AXIS2_TRANSPORT_ENUMS transport);
 
-    };
+    /**
+     * Gets reply to end point reference. The engine will direct the 
+     * response for the message to this reply to address.
+     * @param listener_manager pointer to listener manager struct
+     * @param env pointer to environment struct         
+     * @param svc_name name of the service for which the epr is to be returned
+     * @param transport name of the transport corresponding to the endpoint
+     * @return a pointer to endpoint reference struct representing the reply 
+     * endpoint
+     */
+    AXIS2_EXTERN axis2_endpoint_ref_t* AXIS2_CALL
+    axis2_listener_manager_get_reply_to_epr(const axis2_listener_manager_t *listener_manager,
+        const axis2_env_t *env,
+        const axis2_char_t *svc_name,
+        const AXIS2_TRANSPORT_ENUMS transport);
 
     /**
-     * listener manager struct.
+     * Gets the configuration context that holds information on the transports 
+     * managed by the listener manager.
+     * @param listener_manager pointer to listener manager struct
+     * @param env pointer to environment struct         
      */
-    struct axis2_listener_manager
-    {
-        /** operations of listener manager */
-        axis2_listener_manager_ops_t *ops;
-    };
+    AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL
+    axis2_listener_manager_get_conf_ctx(const axis2_listener_manager_t *listener_manager,
+        const axis2_env_t *env);
+
+   /**
+     * Frees listener manager struct.
+     * @param listener_manager pointer to listener manager struct
+     * @param env pointer to environment struct         
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_listener_manager_free(axis2_listener_manager_t *listener_manager,
+        const axis2_env_t *env);
+
 
     /**
      * Creates a listener manager struct instance.
@@ -143,33 +122,27 @@
      *         or NULL on error with error code set in environment's error
      */
     AXIS2_EXTERN axis2_listener_manager_t *AXIS2_CALL
-    axis2_listener_manager_create(
-        const axis2_env_t *env);
+    axis2_listener_manager_create(const axis2_env_t *env);
 
-/** Makes sure the named transport is started. 
-    @sa axis2_listener_manager_ops#make_sure_started */
+/** Makes sure the named transport is started. */
 #define AXIS2_LISTNER_MANAGER_MAKE_SURE_STARTED(listener_manager, env, transport, conf_ctx)\
-        ((listener_manager)->ops->make_sure_started(listener_manager, env, transport, conf_ctx))
+        axis2_listener_manager_make_sure_started(listener_manager, env, transport, conf_ctx)
 
-/** Stops the named transport.
-    @sa axis2_listener_manager_ops#stop */
+/** Stops the named transport. */
 #define AXIS2_LISTENER_MANAGER_STOP(listener_manager, env, transport)\
-        ((listener_manager)->ops->stop(listener_manager, env, transport))
+        axis2_listener_manager_stop(listener_manager, env, transport)
 
-/** Gets reply to endpoint reference.
-    @sa axis2_listener_manager_ops#get_reply_to_epr */
+/** Gets reply to endpoint reference. */
 #define AXIS2_LISTNER_MANAGER_GET_REPLY_TO_EPR(listener_manager, env, svc_name, transport) \
-        ((listener_manager)->ops->get_reply_to_epr(listener_manager, env, svc_name, transport))
+        axis2_listener_manager_get_reply_to_epr(listener_manager, env, svc_name, transport)
 
-/** Gets configuration context.
-    @sa axis2_listener_manager_ops#get_conf_ctx */
+/** Gets configuration context. */
 #define AXIS2_LISTNER_MANAGER_GET_CONF_CTX(listener_manager, env) \
-        ((listener_manager)->ops->get_conf_ctx(listener_manager, env))
+        axis2_listener_manager_get_conf_ctx(listener_manager, env)
 
-/** Frees listener manager.
-    @sa axis2_listener_manager_ops#free */
+/** Frees listener manager. */
 #define AXIS2_LISTNER_MANAGER_FREE(listener_manager, env) \
-        ((listener_manager)->ops->free(listener_manager, env))
+        axis2_listener_manager_free(listener_manager, env)
 
     /** @} */
 #ifdef __cplusplus

Modified: webservices/axis2/trunk/c/include/axis2_mep_client.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_mep_client.h?view=diff&rev=518623&r1=518622&r2=518623
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_mep_client.h (original)
+++ webservices/axis2/trunk/c/include/axis2_mep_client.h Thu Mar 15 06:16:07 2007
@@ -41,172 +41,143 @@
 {
 #endif
 
-    /** Type name for struct axis2_mep_client_ops */
-    typedef struct axis2_mep_client_ops axis2_mep_client_ops_t;
     /** Type name for struct axis2_mep_client */
     typedef struct axis2_mep_client axis2_mep_client_t;
 
 
     /**
-     * MEP client ops struct.
-     * Encapsulator struct for ops of axis2_mep_client.
+     * Gets SOAP action.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @return a pointer to SOAP action string
+     */
+    AXIS2_EXTERN axis2_string_t *AXIS2_CALL
+    axis2_mep_client_get_soap_action(const axis2_mep_client_t *mep_client,
+        const axis2_env_t *env);
+    
+    /**
+     * Prepares the message context for invocation. Here the properties kept
+     * in the mep_client are copied to the message context.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param op pointer operation to be invoked
+     * @param msg_ctx pointer to message context to be filled
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_mep_client_prepare_invocation(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        axis2_op_t *op,
+        axis2_msg_ctx_t *msg_ctx);
+
+    /**
+     * Prepares the SOAP envelope using the payload. 
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param to_send payload to be sent in AXIOM node format
+     * @return a pointer to message context struct filled with the SOAP 
+     * envelope to be sent
+     */
+    AXIS2_EXTERN axis2_msg_ctx_t* AXIS2_CALL
+    axis2_mep_client_prepare_soap_envelope(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        axiom_node_t *to_send);
+
+    /**
+     * Tries to infer the transport looking at the URL, the URL can be http://
+     * tcp:// mail:// local://. The method will look for the transport name as the
+     * protocol part of the transport.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param epr endpoint reference struct representing the endpoint URL
+     * @return pointer to the transport description with inferred information
+     */
+    AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL
+    axis2_mep_client_infer_transport(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        axis2_endpoint_ref_t *epr);
+
+    /**
+     * Creates default SOAP envelope.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @return pointer to default SOAP envelope created
+     */
+    AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL
+    axis2_mep_client_create_default_soap_envelope(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env);
+
+    /**
+     * Engage named module. The named module must have been configured in 
+     * the Axis2 configuration. For a module to be detected by the 
+     * deployment engine, the modules has to be placed in the 
+     * AXIS2_REPOSITORY/modules directory.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param qname QName representing the module name 
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
-    struct axis2_mep_client_ops
-    {
-        /**
-         * Gets SOAP action.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @return a pointer to SOAP action string
-         */
-        axis2_string_t *(AXIS2_CALL *
-                get_soap_action)(
-                    const axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env);
-        
-        /**
-         * Prepares the message context for invocation. Here the properties kept
-         * in the mep_client are copied to the message context.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param op pointer operation to be invoked
-         * @param msg_ctx pointer to message context to be filled
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                prepare_invocation)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    axis2_op_t *op,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Prepares the SOAP envelope using the payload. 
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param to_send payload to be sent in AXIOM node format
-         * @return a pointer to message context struct filled with the SOAP 
-         * envelope to be sent
-         */
-        axis2_msg_ctx_t* (AXIS2_CALL *
-                prepare_soap_envelope)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    axiom_node_t *to_send);
-
-        /**
-         * Tries to infer the transport looking at the URL, the URL can be http://
-         * tcp:// mail:// local://. The method will look for the transport name as the
-         * protocol part of the transport.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param epr endpoint reference struct representing the endpoint URL
-         * @return pointer to the transport description with inferred information
-         */
-        axis2_transport_out_desc_t *(AXIS2_CALL *
-                infer_transport)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    axis2_endpoint_ref_t *epr);
-
-        /**
-         * Creates default SOAP envelope.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @return pointer to default SOAP envelope created
-         */
-        axiom_soap_envelope_t *(AXIS2_CALL *
-                create_default_soap_envelope)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env);
-
-        /**
-         * Engage named module. The named module must have been configured in 
-         * the Axis2 configuration. For a module to be detected by the 
-         * deployment engine, the modules has to be placed in the 
-         * AXIS2_REPOSITORY/modules directory.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param qname QName representing the module name 
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                engage_module)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    const axis2_qname_t *qname);
-        
-        /**
-         * Sets SOAP version URI.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param soap_version_uri SOAP version URI
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_soap_version_uri)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    const axis2_char_t *soap_version_uri);
-        
-        /**
-         * Sets SOAP action.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param soap_action SOAP action
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_soap_action)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    axis2_string_t *soap_action);
-        
-        /**
-         * Sets WSA action.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @param wsa_action Web services Addressing action
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_wsa_action)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env,
-                    const axis2_char_t *wsa_action);
-
-        /**
-         * Gets service context.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct         
-         * @return pointer to service context struct if set, else NULL
-         */
-        axis2_svc_ctx_t *(AXIS2_CALL *
-                get_svc_ctx)(
-                    const axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env);
-
-
-        /**
-         * Frees MEP client struct.
-         * @param mep_client pointer to mep client struct
-         * @param env pointer to environment struct
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                free)(
-                    axis2_mep_client_t *mep_client,
-                    const axis2_env_t *env);
-    };
-
-    /**
-     * mep client struct.
-     */
-    struct axis2_mep_client
-    {
-        /** operations of mep client */
-        axis2_mep_client_ops_t *ops;
-    };
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_mep_client_engage_module(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        const axis2_qname_t *qname);
+    
+    /**
+     * Sets SOAP version URI.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param soap_version_uri SOAP version URI
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_mep_client_set_soap_version_uri(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        const axis2_char_t *soap_version_uri);
+    
+    /**
+     * Sets SOAP action.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param soap_action SOAP action
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_mep_client_set_soap_action(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        axis2_string_t *soap_action);
+    
+    /**
+     * Sets WSA action.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @param wsa_action Web services Addressing action
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_mep_client_set_wsa_action(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env,
+        const axis2_char_t *wsa_action);
+
+    /**
+     * Gets service context.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct         
+     * @return pointer to service context struct if set, else NULL
+     */
+    AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL
+    axis2_mep_client_get_svc_ctx(const axis2_mep_client_t *mep_client,
+        const axis2_env_t *env);
+
+
+    /**
+     * Frees MEP client struct.
+     * @param mep_client pointer to mep client struct
+     * @param env pointer to environment struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_mep_client_free(axis2_mep_client_t *mep_client,
+        const axis2_env_t *env);
 
     /**
      * Creates a mep client struct for a specified service context.
@@ -218,8 +189,7 @@
      *         or NULL on error with error code set in environment's error
      */
     AXIS2_EXTERN axis2_mep_client_t *AXIS2_CALL 
-    axis2_mep_client_create(
-        const axis2_env_t *env,
+    axis2_mep_client_create(const axis2_env_t *env,
         axis2_svc_ctx_t *svc_ctx,
         const axis2_char_t *mep);
 
@@ -231,9 +201,8 @@
      * be sent
      * @return message context representing the received response
      */    
-    axis2_msg_ctx_t *AXIS2_CALL
-    axis2_mep_client_two_way_send(
-        const axis2_env_t *env,
+    AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
+    axis2_mep_client_two_way_send(const axis2_env_t *env,
         axis2_msg_ctx_t *msg_ctx);
 
     /**
@@ -244,65 +213,53 @@
      * be received
      * @return message context representing the received response
      */
-    axis2_msg_ctx_t *AXIS2_CALL
-    axis2_mep_client_receive(
-        const axis2_env_t *env,
+    AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
+    axis2_mep_client_receive(const axis2_env_t *env,
         axis2_msg_ctx_t *msg_ctx);
 
-/** Gets SOAP action.
-    @sa axis2_mep_client_ops#get_soap_action */
+/** Gets SOAP action. */
 #define AXIS2_MEP_CLIENT_GET_SOAP_ACTION(mep_client, env) \
-        ((mep_client)->ops->get_soap_action(mep_client, env))
+        axis2_mep_client_get_soap_action(mep_client, env)
 
-/** Prepares mep client for invocation.
-    @sa axis2_mep_client_ops#prepare_invocation */
+/** Prepares mep client for invocation. */
 #define AXIS2_MEP_CLIENT_PREPARE_INVOCATION(mep_client, env, op, msg_ctx) \
-      ((mep_client)->ops->prepare_invocation(mep_client, env, op, msg_ctx))
+      axis2_mep_client_prepare_invocation(mep_client, env, op, msg_ctx)
 
-/** Prepares SOAP envelope.
-    @sa axis2_mep_client_ops#prepare_soap_envelope */
+/** Prepares SOAP envelope. */
 #define AXIS2_MEP_CLIENT_PREPARE_SOAP_ENVELOPE(mep_client, env, to_send) \
-      ((mep_client)->ops->prepare_soap_envelope(mep_client, env, to_send))
+      axis2_mep_client_prepare_soap_envelope(mep_client, env, to_send)
 
-/** Infers transport.
-    @sa axis2_mep_client_ops#infer_transport */
+/** Infers transport. */
 #define AXIS2_MEP_CLIENT_INFER_TRANSPORT(mep_client, env, epr) \
-      ((mep_client)->ops->infer_transport(mep_client, env, epr))
+      axis2_mep_client_infer_transport(mep_client, env, epr)
 
-/** Creates default SOAP envelope.
-    @sa axis2_mep_client_ops#create_default_soap_envelope */
+/** Creates default SOAP envelope. */
 #define AXIS2_MEP_CLIENT_CREATE_DEFAULT_SOAP_ENVELOPE(mep_client, env) \
-      ((mep_client)->ops->create_default_soap_envelope(mep_client, env))
+      axis2_mep_client_create_default_soap_envelope(mep_client, env)
 
-/** Engages named module.
-    @sa axis2_mep_client_ops#engage_module */
+/** Engages named module. */
 #define AXIS2_MEP_CLIENT_ENGAGE_MODULE(mep_client, env, qname) \
-      ((mep_client)->ops->engage_module(mep_client, env, qname))
+      axis2_mep_client_engage_module(mep_client, env, qname)
 
-/** Sets SOAP version URI.
-    @sa axis2_mep_client_ops#set_soap_version_uri */
+/** Sets SOAP version URI. */
 #define AXIS2_MEP_CLIENT_SET_SOAP_VERSION_URI(mep_client, env, soap_version_uri)\
-      ((mep_client)->ops->set_soap_version_uri(mep_client, env, soap_version_uri))
+      axis2_mep_client_set_soap_version_uri(mep_client, env, soap_version_uri)
 
-/** Sets SOAP action.
-    @sa axis2_mep_client_ops#set_soap_action */
+/** Sets SOAP action. */
 #define AXIS2_MEP_CLIENT_SET_SOAP_ACTION(mep_client, env, soap_action) \
-      ((mep_client)->ops->set_soap_action(mep_client, env, soap_action))
+      axis2_mep_client_set_soap_action(mep_client, env, soap_action)
 
-/** Sets WSA action.
-    @sa axis2_mep_client_ops#set_wsa_action */
+/** Sets WSA action. */
 #define AXIS2_MEP_CLIENT_SET_WSA_ACTION(mep_client, env, wsa_action) \
-      ((mep_client)->ops->set_wsa_action(mep_client, env, wsa_action))
+      axis2_mep_client_set_wsa_action(mep_client, env, wsa_action)
 
-/** Gets service context.
-    @sa axis2_mep_client_ops#get_svc_ctx */
+/** Gets service context. */
 #define AXIS2_MEP_CLIENT_GET_SVC_CTX(mep_client, env) \
-      ((mep_client)->ops->get_svc_ctx(mep_client, env))
+      axis2_mep_client_get_svc_ctx(mep_client, env)
 
-/** Frees mep client.
-    @sa axis2_mep_client_ops#free */
+/** Frees mep client. */
 #define AXIS2_MEP_CLIENT_FREE(mep_client, env) \
-      ((mep_client)->ops->free (mep_client, env))
+      axis2_mep_client_free (mep_client, env)
 
 
     /** @} */

Modified: webservices/axis2/trunk/c/include/axis2_msg_recv.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_msg_recv.h?view=diff&rev=518623&r1=518622&r2=518623
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_msg_recv.h (original)
+++ webservices/axis2/trunk/c/include/axis2_msg_recv.h Thu Mar 15 06:16:07 2007
@@ -55,210 +55,129 @@
 #define AXIS2_FAILURE 0
 
     struct axis2_msg_ctx;
-    /** Type name for struct axis2_msg_recv ops */
-    typedef struct axis2_msg_recv_ops axis2_msg_recv_ops_t;
     /** Type name for struct axis2_msg_recv*/
     typedef struct axis2_msg_recv axis2_msg_recv_t;
 
     /**
-     * Message Receiver ops struct.
-     * Encapsulator struct for ops of axis2_msg_recv
+     * Deallocate memory
+     * @param msg_recv pinter to message receiver
+     * @param env pointer to environment struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_msg_recv_free(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env);
+
+    /**
+     * This method is called from axis2_engine_receive method. This method's
+     * actual implementation is decided from the create method of the 
+     * extended message receiver object. There depending on the synchronous or
+     * asynchronous type, receive metho is assigned with the synchronous or
+     * asynchronous implementation of receive.
+     * @see raw_xml_in_out_msg_recv_create method where receive is assigned
+     * to receive_sync
+     * @param msg_recv pointer to message receiver
+     * @param env pointer to environment struct
+     * @param in_msg_ctx pointer to in message context
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_msg_recv_receive(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        struct axis2_msg_ctx *in_msg_ctx,
+        void *callback_recv_param);
+
+    /**
+     * This contain in out synchronous business invoke logic
+     * @param msg_recv pointer to message receiver
+     * @param env pointer to environment struct
+     * @param in_msg_ctx pointer to in message context
+     * @param out_msg_ctx pointer to out message context
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_msg_recv_invoke_business_logic(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        struct axis2_msg_ctx *in_msg_ctx,
+        struct axis2_msg_ctx *out_msg_ctx);
+
+    /**
+     * this will create a new service skeleton object
+     * @param msg_recv pointer to message receiver
+     * @param env pointer to enviornment struct
+     * @param msg_ctx pointer to message context
+     * @return service skeleton object
+     */
+    AXIS2_EXTERN axis2_svc_skeleton_t *AXIS2_CALL
+    axis2_msg_recv_make_new_svc_obj(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        struct axis2_msg_ctx *msg_ctx);
+
+    /**
+     * This will return the service skeleton object
+     * @param msg_recv pointer to message receiver
+     * @param env pointer to environment struct
+     * @param msg_ctx pointer to message context
+     * @return service skeleton object
      */
-    struct axis2_msg_recv_ops
-    {
-        /**
-         * Deallocate memory
-         * @param msg_recv pinter to message receiver
-         * @param env pointer to environment struct
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                free_fn)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env);
-
-        /**
-         * This method is called from axis2_engine_receive method. This method's
-         * actual implementation is decided from the create method of the 
-         * extended message receiver object. There depending on the synchronous or
-         * asynchronous type, receive metho is assigned with the synchronous or
-         * asynchronous implementation of receive.
-         * @see raw_xml_in_out_msg_recv_create method where receive is assigned
-         * to receive_sync
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pointer to in message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                receive)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx,
-                    void *callback_recv_param);
-        /**
-         * This contain synchronous receiving logic.
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pointer to in message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                receive_sync)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx,
-                    void *callback_recv_param);
-
-        /**
-         * This contain asynchronous receiving logic.
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pointer to in message 
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                receive_async)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx,
-                    void *callback_recv_param);
-
-        /**
-         * This contain in only synchronous business invoke logic
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pointer to in message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                invoke_in_business_logic_sync)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx);
-
-        /**
-         * This contain in only asynchronous business invoke logic
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pointer to in message context
-         * @param svr_callback pointer to server callback
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                invoke_in_business_logic_async)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx,
-                    struct axis2_svr_callback *svr_callback);
-
-        /**
-         * This contain in out synchronous business invoke logic
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pointer to in message context
-         * @param out_msg_ctx pointer to out message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                invoke_in_out_business_logic_sync)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx,
-                    struct axis2_msg_ctx *out_msg_ctx);
-
-        /**
-         * This contain in out asynchronous business invoke logic
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param in_msg_ctx pinter to in message context
-         * @param out_msg_ctx pointer to out message context
-         * @param callback pointer to callback
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                invoke_in_out_business_logic_async)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *in_msg_ctx,
-                    struct axis2_msg_ctx *out_msg_ctx,
-                    struct axis2_svr_callback *callback);
-
-
-        /**
-         * this will create a new service skeleton object
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to enviornment struct
-         * @param msg_ctx pointer to message context
-         * @return service skeleton object
-         */
-        axis2_svc_skeleton_t *(AXIS2_CALL *
-                make_new_svc_obj)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *msg_ctx);
-
-        /**
-         * This will return the service skeleton object
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param msg_ctx pointer to message context
-         * @return service skeleton object
-         */
-        axis2_svc_skeleton_t *(AXIS2_CALL *
-                get_impl_obj)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    struct axis2_msg_ctx *msg_ctx);
-
-        /**
-         * Set the application scope
-         * @param msg_recv pointer to message receiver
-         * @param env pointer to environment struct
-         * @param scope ointer to scope
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_scope)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    const axis2_char_t *scope);
-
-
-        /**
-         * Get the application scope
-         * @param msg_recv pointer to message receiver
-         * @env pointer to enviornment struct
-         * @return scope
-         */
-        axis2_char_t *(AXIS2_CALL *
-                get_scope)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env);
-
-        /**
-         * Delete the service skeleton object created by make_new_svc_obj
-         * @param msg_recv pointer to message receiver
-         * @env pointer to environment struct
-         * @param msg_ctx pointer to message context
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                delete_svc_obj)(
-                    axis2_msg_recv_t *msg_recv,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-    };
+    AXIS2_EXTERN axis2_svc_skeleton_t *AXIS2_CALL
+    axis2_msg_recv_get_impl_obj(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        struct axis2_msg_ctx *msg_ctx);
 
     /**
-     * message receiver struct
+     * Set the application scope
+     * @param msg_recv pointer to message receiver
+     * @param env pointer to environment struct
+     * @param scope ointer to scope
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
-    struct axis2_msg_recv
-    {
-        /** operations of message receiver */
-        axis2_msg_recv_ops_t *ops;
-        void* derived;
-    };
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_msg_recv_set_scope(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        const axis2_char_t *scope);
+
+
+    /**
+     * Get the application scope
+     * @param msg_recv pointer to message receiver
+     * @env pointer to enviornment struct
+     * @return scope
+     */
+    AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+    axis2_msg_recv_get_scope(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env);
+
+    /**
+     * Delete the service skeleton object created by make_new_svc_obj
+     * @param msg_recv pointer to message receiver
+     * @env pointer to environment struct
+     * @param msg_ctx pointer to message context
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_msg_recv_delete_svc_obj(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+
+    AXIS2_EXPORT axis2_status_t AXIS2_CALL
+    axis2_msg_recv_set_invoke_business_logic(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        void *func);
+
+    AXIS2_EXPORT axis2_status_t AXIS2_CALL
+    axis2_msg_recv_set_derived(axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env,
+        void *derived);
+
+    AXIS2_EXPORT void *AXIS2_CALL
+    axis2_msg_recv_get_derived(const axis2_msg_recv_t *msg_recv,
+        const axis2_env_t *env);
+
+	AXIS2_EXPORT axis2_status_t AXIS2_CALL
+	axis2_msg_recv_set_receive(axis2_msg_recv_t *msg_recv,
+		const axis2_env_t *env,
+		void *func);
 
     /**
      * Create new message receiver object. usually this will be called from the
@@ -268,82 +187,40 @@
      * @return newly created message receiver object
      **/
     AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL
-    axis2_msg_recv_create (
-        const axis2_env_t *env);
+    axis2_msg_recv_create (const axis2_env_t *env);
 
-/************************** Start of function macros **************************/
+/** Frees the message receiver. */
+#define AXIS2_MSG_RECV_FREE(msg_recv, env) axis2_msg_recv_free (msg_recv, env)
 
-/** Frees the message receiver.
-    @sa axis2_msg_recv_ops#free */
-#define AXIS2_MSG_RECV_FREE(msg_recv, env) ((msg_recv)->ops->free_fn (msg_recv, env))
-
-/** Receive.
-    @sa axis2_msg_recv_ops#receive */
+/** Receive. */
 #define AXIS2_MSG_RECV_RECEIVE(msg_recv, env, msg_ctx, callback_recv_param) \
-      ((msg_recv)->ops->receive (msg_recv, env, msg_ctx, callback_recv_param))
-
-/** Receive sync.
-    @sa axis2_msg_recv_ops#sync */
-#define AXIS2_MSG_RECV_RECEIVE_SYNC(msg_recv, env, msg_ctx, callback_recv_param) \
-      ((msg_recv)->ops->receive_sync (msg_recv, env, msg_ctx, callback_recv_param))
-
-/** Receive async.
-    @sa axis2_msg_recv_ops#receive_async */
-#define AXIS2_MSG_RECV_RECEIVE_ASYNC(msg_recv, env, msg_ctx, callback_recv_param) \
-      ((msg_recv)->ops->receive_async (msg_recv, env, msg_ctx, callback_recv_param))
-
-/** Invoke in business logic sync.
-    @sa axis2_msg_recv_ops#invoke_in_business_logic_sync */
-#define AXIS2_MSG_RECV_INVOKE_IN_BUSINESS_LOGIC_SYNC(msg_recv, env, in_msg_ctx) \
-        ((msg_recv)->ops->invoke_in_business_logic_sync(msg_recv, env, in_msg_ctx))
-
-/** Invoke in business logic async.
-    @sa axis2_msg_recv_ops#invoke_in_business_logic_async */
-#define AXIS2_MSG_RECV_INVOKE_IN_BUSINESS_LOGIC_ASYNC(msg_recv, env, \
-            in_msg_ctx, callback) \
-        ((msg_recv)->ops->invoke_in_business_logic_async(msg_recv, env, \
-            in_msg_ctx, callback))
+      axis2_msg_recv_receive (msg_recv, env, msg_ctx, callback_recv_param)
 
-/** Invoke in out business logic sync.
-    @sa axis2_msg_recv_ops#invoke_in_out_business_logic_sync */
+/** Invoke in out business logic sync. */
 #define AXIS2_MSG_RECV_INVOKE_IN_OUT_BUSINESS_LOGIC_SYNC(msg_recv, env, \
             in_msg_ctx, out_msg_ctx) \
-        ((msg_recv)->ops->invoke_in_out_business_logic_sync (msg_recv, env, \
-            in_msg_ctx, out_msg_ctx))
+        axis2_msg_recv_invoke_business_logic (msg_recv, env, \
+            in_msg_ctx, out_msg_ctx)
 
-/** Invoke in out business logic async.
-    @sa axis2_msg_recv_ops#invoke_in_out_business_logic_async */
-#define AXIS2_MSG_RECV_INVOKE_IN_OUT_BUSINESS_LOGIC_ASYNC(msg_recv, env, \
-            in_msg_ctx, out_msg_ctx, callback) \
-        ((msg_recv)->ops->invoke_in_out_business_logic_async(msg_recv, env, \
-            in_msg_ctx, out_msg_ctx, callback))
-
-/** Make new svc obj.
-    @sa axis2_msg_recv_ops#make_new_svc_obj */
+/** Make new svc obj. */
 #define AXIS2_MSG_RECV_MAKE_NEW_SVC_OBJ(msg_recv, env, msg_ctx) \
-        ((msg_recv)->ops->make_new_svc_obj(msg_recv, env, msg_ctx))
+        axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx)
 
-/** Get impl obj.
-    @sa axis2_msg_recv_ops#get_impl_obj */
+/** Get impl obj. */
 #define AXIS2_MSG_RECV_GET_IMPL_OBJ(msg_recv, env, msg_ctx) \
-      ((msg_recv)->ops->get_impl_obj(msg_recv, env, msg_ctx))
+      axis2_msg_recv_get_impl_obj(msg_recv, env, msg_ctx)
 
-/** Set scope.
-    @sa axis2_msg_recv_ops#set_scope */
+/** Set scope. */
 #define AXIS2_MSG_RECV_SET_SCOPE(msg_recv, env, scope) \
-      ((msg_recv)->ops->set_scope(msg_recv, env, scope))
+      axis2_msg_recv_set_scope(msg_recv, env, scope)
 
-/** Get scope.
-    @sa axis2_msg_recv_ops#get_scope */
+/** Get scope. */
 #define AXIS2_MSG_RECV_GET_SCOPE(msg_recv, env) \
-        ((msg_recv)->ops->get_scope(msg_recv, env))
+        axis2_msg_recv_get_scope(msg_recv, env)
 
-/** Delete svc obj.
-    @sa axis2_msg_recv_ops#delete_svc_obj */
+/** Delete svc obj. */
 #define AXIS2_MSG_RECV_DELETE_SVC_OBJ(msg_recv, env, msg_ctx) \
-        ((msg_recv)->ops->delete_svc_obj(msg_recv, env, msg_ctx))
-
-/************************** End of function macros ****************************/
+        axis2_msg_recv_delete_svc_obj(msg_recv, env, msg_ctx)
 
 /** @} */
 #ifdef __cplusplus

Modified: webservices/axis2/trunk/c/include/axis2_op_client.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_op_client.h?view=diff&rev=518623&r1=518622&r2=518623
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_op_client.h (original)
+++ webservices/axis2/trunk/c/include/axis2_op_client.h Thu Mar 15 06:16:07 2007
@@ -58,203 +58,172 @@
 {
 #endif
 
-    /** Type name for struct axis2_op_client_ops */
-    typedef struct axis2_op_client_ops axis2_op_client_ops_t;
     /** Type name for struct axis2_op_client */
     typedef struct axis2_op_client axis2_op_client_t;
         
     struct axis2_callback_recv;
 
+
+    /**
+     * Sets the options that is to be used by this operation client. 
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param options pointer to options struct to be set
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_set_options(axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        const axis2_options_t *options);
+
+    /**
+     * Gets options used by operation client. 
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @return a pointer to the options struct if options set, else NULL.
+     * Returns a reference, not a cloned copy.         
+     */
+    AXIS2_EXTERN const axis2_options_t* AXIS2_CALL
+    axis2_op_client_get_options(const axis2_op_client_t *op_client,
+        const axis2_env_t *env);
+
+    /**
+     * Adds a message context to the client for processing. 
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param msg_ctx message context to be added. operation client takes 
+     * over the ownership of the message context struct.
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_add_msg_ctx(
+        axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+
+    /**
+     * Adds out message context to the client for processing. 
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param msg_ctx message context to be added. operation client takes 
+     * over the ownership of the message context struct.
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_add_out_msg_ctx(axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+
+
+    /**
+     * Gets a message corresponding to the given label.
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param message_label the message label of the desired message context
+     * @return the desired message context or NULL if its not available.
+     * Returns a reference, not a cloned copy.
+     */
+    AXIS2_EXTERN const axis2_msg_ctx_t* AXIS2_CALL
+    axis2_op_client_get_msg_ctx(const axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        const axis2_wsdl_msg_labels_t message_label);
+
+    /**
+     * Sets the callback to be executed when a response message is received. 
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param callback the callback to be used. operation client takes 
+     * over the ownership of the message context struct.
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_set_callback(axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        axis2_callback_t *callback);
+    /**
+     * Gets the callback. 
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @return callback
+     */
+    AXIS2_EXTERN axis2_callback_t *AXIS2_CALL
+    axis2_op_client_get_callback(axis2_op_client_t *op_client,
+        const axis2_env_t *env);
+
     /**
-     * operation client ops struct.
-     * Encapsulator struct for ops of axis2_op_client.
+     * Execute the MEP. What this does depends on the specific operation client.
+     * The basic idea is to have the operation client execute and do something
+     * with the messages that have been added to it so far. For example, if its
+     * an Out-In MEP, and if the Out message has been set, then executing the
+     * client asks it to send the out message and get the in message
+     * @param op_client pointer to operation client
+     * @param env pointer to environment struct
+     * @param block indicates whether execution should block or return ASAP
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
      */
-    struct axis2_op_client_ops
-    {
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_execute(axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        const axis2_bool_t block);
 
-        /**
-         * Sets the options that is to be used by this operation client. 
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param options pointer to options struct to be set
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_options)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    const axis2_options_t *options);
-
-        /**
-         * Gets options used by operation client. 
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @return a pointer to the options struct if options set, else NULL.
-         * Returns a reference, not a cloned copy.         
-         */
-        const axis2_options_t* (AXIS2_CALL *
-                get_options)(
-                    const axis2_op_client_t *op_client,
-                    const axis2_env_t *env);
-
-        /**
-         * Adds a message context to the client for processing. 
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param msg_ctx message context to be added. operation client takes 
-         * over the ownership of the message context struct.
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                add_msg_ctx)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Adds out message context to the client for processing. 
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param msg_ctx message context to be added. operation client takes 
-         * over the ownership of the message context struct.
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                add_out_msg_ctx)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-
-
-        /**
-         * Gets a message corresponding to the given label.
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param message_label the message label of the desired message context
-         * @return the desired message context or NULL if its not available.
-         * Returns a reference, not a cloned copy.
-         */
-        const axis2_msg_ctx_t* (AXIS2_CALL *
-                get_msg_ctx)(
-                    const axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    const axis2_wsdl_msg_labels_t message_label);
-
-        /**
-         * Sets the callback to be executed when a response message is received. 
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param callback the callback to be used. operation client takes 
-         * over the ownership of the message context struct.
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_callback)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    axis2_callback_t *callback);
-        /**
-         * Gets the callback. 
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @return callback
-         */
-        axis2_callback_t *(AXIS2_CALL *
-                get_callback)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env);
-
-
-        /**
-         * Execute the MEP. What this does depends on the specific operation client.
-         * The basic idea is to have the operation client execute and do something
-         * with the messages that have been added to it so far. For example, if its
-         * an Out-In MEP, and if the Out message has been set, then executing the
-         * client asks it to send the out message and get the in message
-         * @param op_client pointer to operation client
-         * @param env pointer to environment struct
-         * @param block indicates whether execution should block or return ASAP
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                execute)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    const axis2_bool_t block);
-
-        /**
-         * Resets the operation client to a clean status after the MEP has completed.
-         * This is how you can reuse an operation client. Note that this does not reset
-         * the options; only the internal state so the client can be used again.
-         * @param op_client pointer to operation client
-         * @param env pointer to environment struct
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                reset)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env);
-
-        /**
-         * Completes the execution by closing the transports if necessary.
-         * This method is useful when client uses two transports for sending and 
-         * receiving.
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param msg_ctx message context which contains the transport information
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                complete)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    axis2_msg_ctx_t *msg_ctx);
-
-        /**
-         * Gets the operation context of the operation client.
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct                
-         * @return operation context related to operation client
-         */
-        axis2_op_ctx_t* (AXIS2_CALL *
-                get_operation_context)(
-                    const axis2_op_client_t *op_client,
-                    const axis2_env_t *env);
-
-        /**
-         * Sets callback receiver.
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @param callback_recv pointer to callback receiver struct.
-         * operation client assumes ownership of the callback struct.
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                set_callback_recv)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env,
-                    struct axis2_callback_recv *callback_recv);
-
-        /**
-         * Frees the operation client
-         * @param op_client pointer to operation client struct
-         * @param env pointer to environment struct
-         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
-         */
-        axis2_status_t (AXIS2_CALL *
-                free)(
-                    axis2_op_client_t *op_client,
-                    const axis2_env_t *env);
-    };
-
-    /**
-     * operation client struct.
-     */
-    struct axis2_op_client
-    {
-        /** operations of operation client */
-        axis2_op_client_ops_t *ops;
-    };
+    /**
+     * Resets the operation client to a clean status after the MEP has completed.
+     * This is how you can reuse an operation client. Note that this does not reset
+     * the options; only the internal state so the client can be used again.
+     * @param op_client pointer to operation client
+     * @param env pointer to environment struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_reset(axis2_op_client_t *op_client,
+        const axis2_env_t *env);
+
+    /**
+     * Completes the execution by closing the transports if necessary.
+     * This method is useful when client uses two transports for sending and 
+     * receiving.
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param msg_ctx message context which contains the transport information
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_complete(axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        axis2_msg_ctx_t *msg_ctx);
+
+    /**
+     * Gets the operation context of the operation client.
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct                
+     * @return operation context related to operation client
+     */
+    AXIS2_EXTERN axis2_op_ctx_t* AXIS2_CALL
+    axis2_op_client_get_operation_context(const axis2_op_client_t *op_client,
+        const axis2_env_t *env);
+
+    /**
+     * Sets callback receiver.
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @param callback_recv pointer to callback receiver struct.
+     * operation client assumes ownership of the callback struct.
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_set_callback_recv(axis2_op_client_t *op_client,
+        const axis2_env_t *env,
+        struct axis2_callback_recv *callback_recv);
+
+    /**
+     * Frees the operation client
+     * @param op_client pointer to operation client struct
+     * @param env pointer to environment struct
+     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axis2_op_client_free(axis2_op_client_t *op_client,
+        const axis2_env_t *env);
 
     /**
      * Creates an operation client struct for the specified operation, service 
@@ -271,78 +240,64 @@
      * @return a pointer to newly created operation client struct,
      * or NULL on error with error code set in environment's error
      */
-    AXIS2_EXTERN axis2_op_client_t* AXIS2_CALL axis2_op_client_create(
-        const axis2_env_t *env,
+    AXIS2_EXTERN axis2_op_client_t* AXIS2_CALL 
+    axis2_op_client_create(const axis2_env_t *env,
         axis2_op_t *op,
         axis2_svc_ctx_t *svc_ctx,
         axis2_options_t *options);
 
      
-/** Sets the options to be used by operation client. 
-    @sa axis2_op_client_ops#set_options */
+/** Sets the options to be used by operation client. */
 #define AXIS2_OP_CLIENT_SET_OPTIONS(op_client, env, options) \
-      ((op_client)->ops->set_options(op_client, env, options))
+      axis2_op_client_set_options(op_client, env, options)
 
-/** Gets the options used by operation client. 
-    @sa axis2_op_client_ops#get_options */
+/** Gets the options used by operation client.  */
 #define AXIS2_OP_CLIENT_GET_OPTIONS(op_client, env) \
-      ((op_client)->ops->get_options(op_client, env))
+      axis2_op_client_get_options(op_client, env)
 
-/** Adds a message context. 
-    @sa axis2_op_client_ops#add_msg_ctx*/
+/** Adds a message context. */
 #define AXIS2_OP_CLIENT_ADD_MSG_CTX(op_client, env, msg_ctx) \
-      ((op_client)->ops->add_msg_ctx(op_client, env, msg_ctx))
+      axis2_op_client_add_msg_ctx(op_client, env, msg_ctx)
 
-/** Adds out message context. 
-    @sa axis2_op_client_ops#add_out_msg_ctx*/
+/** Adds out message context.  */
 #define AXIS2_OP_CLIENT_ADD_OUT_MSG_CTX(op_client, env, msg_ctx) \
-      ((op_client)->ops->add_out_msg_ctx(op_client, env, msg_ctx))
+      axis2_op_client_add_out_msg_ctx(op_client, env, msg_ctx)
 
-/** Gets the message context corresponding to given label. 
-    @sa axis2_op_client_ops#get_msg_ctx*/
+/** Gets the message context corresponding to given label. */
 #define AXIS2_OP_CLIENT_GET_MSG_CTX(op_client, env, message_label) \
-      ((op_client)->ops->get_msg_ctx(op_client, env, message_label))
+      axis2_op_client_get_msg_ctx(op_client, env, message_label)
 
-/** Sets operation client callback. 
-    @sa axis2_op_client_ops#set_callback*/
+/** Sets operation client callback. */
 #define AXIS2_OP_CLIENT_SET_CALLBACK(op_client, env, callback) \
-      ((op_client)->ops->set_callback(op_client, env, callback))
+      axis2_op_client_set_callback(op_client, env, callback)
 
-/** gets operation callback. 
-    @sa axis2_op_client_ops#get_callback*/
+/** gets operation callback. */
 #define AXIS2_OP_CLIENT_GET_CALLBACK(op_client, env) \
-      ((op_client)->ops->get_callback(op_client, env))
-
+      axis2_op_client_get_callback(op_client, env)
 
-/** Executes operation client. 
-    @sa axis2_op_client_ops#execute*/
+/** Executes operation client. */
 #define AXIS2_OP_CLIENT_EXECUTE(op_client, env, block) \
-      ((op_client)->ops->execute(op_client, env, block))
+      axis2_op_client_execute(op_client, env, block)
 
-/** Resets operation client. 
-    @sa axis2_op_client_ops#reset*/
+/** Resets operation client. */
 #define AXIS2_OP_CLIENT_RESET(op_client, env) \
-      ((op_client)->ops->reset(op_client, env))
+      axis2_op_client_reset(op_client, env)
 
-/** Completes operation client, closing open transports. 
-    @sa axis2_op_client_ops#complete*/
+/** Completes operation client, closing open transports. */
 #define AXIS2_OP_CLIENT_COMPLETE(op_client, env, msg_ctx) \
-      ((op_client)->ops->complete(op_client, env, msg_ctx))
+      axis2_op_client_complete(op_client, env, msg_ctx)
 
-/** Gets the operation context. 
-    @sa axis2_op_client_ops#get_operation_context*/
+/** Gets the operation context. */
 #define AXIS2_OP_CLIENT_GET_OPERATION_CONTEXT(op_client, env) \
-      ((op_client)->ops->get_operation_context(op_client, env))
+      axis2_op_client_get_operation_context(op_client, env)
 
-/** Frees the operation client. 
-    @sa axis2_op_client_ops#free*/
+/** Frees the operation client. */
 #define AXIS2_OP_CLIENT_FREE(op_client, env) \
-      ((op_client)->ops->free(op_client, env))
+      axis2_op_client_free(op_client, env)
 
-/** Sets the callback receiver. 
-    @sa axis2_op_client_ops#set_callback_recv*/
+/** Sets the callback receiver. */
 #define AXIS2_OP_CLIENT_SET_CALLBACK_RECV(op_client, env, callback_recv) \
-      ((op_client)->ops->set_callback_recv(op_client, env, callback_recv))
+      axis2_op_client_set_callback_recv(op_client, env, callback_recv)
 
 /** @} */
 #ifdef __cplusplus



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