You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/03/15 14:16:11 UTC
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...
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