You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by sa...@apache.org on 2006/08/12 17:21:18 UTC
svn commit: r431041 - in /webservices/axis2/trunk/c: include/
modules/core/context/ modules/core/description/ modules/core/engine/
test/unit/core/engine/
Author: samisa
Date: Sat Aug 12 08:21:17 2006
New Revision: 431041
URL: http://svn.apache.org/viewvc?rev=431041&view=rev
Log:
More fixes in the lines of doc comment fixes and parameter list improvements
Modified:
webservices/axis2/trunk/c/include/axis2_callback.h
webservices/axis2/trunk/c/include/axis2_engine.h
webservices/axis2/trunk/c/include/axis2_handler.h
webservices/axis2/trunk/c/include/axis2_handler_desc.h
webservices/axis2/trunk/c/modules/core/context/msg_ctx.c
webservices/axis2/trunk/c/modules/core/description/handler_desc.c
webservices/axis2/trunk/c/modules/core/engine/ctx_handler.c
webservices/axis2/trunk/c/modules/core/engine/engine.c
webservices/axis2/trunk/c/modules/core/engine/handler.c
webservices/axis2/trunk/c/modules/core/engine/phase.c
webservices/axis2/trunk/c/test/unit/core/engine/test_conf.c
Modified: webservices/axis2/trunk/c/include/axis2_callback.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_callback.h?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_callback.h (original)
+++ webservices/axis2/trunk/c/include/axis2_callback.h Sat Aug 12 08:21:17 2006
@@ -264,6 +264,7 @@
/**
* Creates a callback struct.
* @param env pointer to environment struct
+ * @return pointer to newly created callback struct
*/
AXIS2_EXTERN axis2_callback_t *AXIS2_CALL
axis2_callback_create(
Modified: webservices/axis2/trunk/c/include/axis2_engine.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_engine.h?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_engine.h (original)
+++ webservices/axis2/trunk/c/include/axis2_engine.h Sat Aug 12 08:21:17 2006
@@ -20,12 +20,17 @@
/**
* @defgroup axis2_engine engine
* @ingroup axis2_engine
+ * engine has the send and receieve functions that is the heart when providing
+ * and consuming services. In Axis2 SOAP engine architecture, all the others
+ * parts are build around the concept of the engine. There is only one engine
+ * for both the server side and the client side, and the engine is not aware of
+ * if it is invoked as an client or a service. engine supports both synchronous
+ * and asynchronous messageing modes based on send and receive functions.
* @{
*/
/**
* @file axis2_engine.h
- * @brief axis2 Message Context interface
*/
#include <axis2_defines.h>
@@ -47,103 +52,97 @@
/**
- * Message Context ops struct
- * Encapsulator struct for ops of axis2_engine
+ * engine ops struct.
+ * Encapsulator struct for ops of axis2_engine.
*/
struct axis2_engine_ops
{
/**
- * This methods represents the outflow of the Axis, this could be either at the server side or the client side.
- * Here the <code>ExecutionChain</code> is created using the Phases. The Handlers at the each Phases is ordered in
- * deployment time by the deployment module
- * @param engine pointer to engine
- * @param eng pointer to environment struct
+ * 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 inflow of the Axis, this could be either at the server side or the client side.
- * Here the <code>ExecutionChain</code> is created using the Phases. The Handlers at the each Phases is ordered in
- * deployment time by the deployment module
- * @param engine pointer to engine
- * @param eng pointer to environment struct
+ * 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 receieving 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 the SOAP Fault to another SOAP node.
+ * Sends a SOAP fault.
* @param engine pointer to engine
- * @param eng pointer to environment struct
- * @param msg_ctx pointer to message context
+ * @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 from a Other SOAP Node
- * Receives a SOAP fault from another SOAP node.
+ * This is invoked when a SOAP fault is received.
* @param engine pointer to engine
- * @param eng pointer to environment struct
- * @param msg_ctx pointer to message context
+ * @param env pointer to environment struct
+ * @param msg_ctx pointer to message context representing that contains
+ * the details of receieve 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);
+
/**
- * This method is called to handle any error that occurs at inflow or outflow. But if the
- * method is called twice, it implies that sending the error handling has failed, in which case
- * the method logs the error and exists.
+ * Creates a message context that represents the fault state based on
+ * current processing state.
* @param engine pointer to engine
- * @param eng pointer to environment struct
- * @param processing_context pointer to message processing context
+ * @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);
+
/**
- * Information to create the SOAPFault can be extracted from different places.
- * 1. Those info may have been put in to the message context by some handler. When someone
- * is putting like that, he must make sure the SOAPElements he is putting must be from the
- * correct SOAP Version.
- * 2. SOAPProcessingException is flexible enough to carry information about the fault. For example
- * it has an attribute to store the fault code. The fault reason can be extracted from the
- * message of the exception. I opted to put the stacktrace under the detail element.
- * eg : <Detail>
- * <Exception> stack trace goes here </Exception>
- * <Detail>
- * <p/>
- * If those information can not be extracted from any of the above places, I default the soap
- * fault values to following.
- * <Fault>
- * <Code>
- * <Value>env:Receiver</Value>
- * </Code>
- * <Reason>
- * <Text>unknown</Text>
- * </Reason>
- * <Role/>
- * <Node/>
- * <Detail/>
- * </Fault>
- * <p/>
- * -- EC
- *
+ * Extraxts fault information form message context.
* @param engine pointer to engine
- * @param eng pointer to environment struct
- * @param msg_ctx pointer to message context
- * @param fault pointer to fault
+ * @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)(
@@ -153,9 +152,13 @@
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 eng pointer to environment struct
- * @param msg_ctx pointer to message context
+ * @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)(
@@ -164,10 +167,17 @@
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 invokation of handlers the phase
+ * contain.
* @param engine pointer to engine
- * @param eng pointer to environment struct
+ * @param env pointer to environment struct
* @param phases pointer to phases
- * @param msg_ctx pointer to message context
+ * @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)(
@@ -177,10 +187,20 @@
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 continute till it is paused
+ * again or it completes invoking all the remaining handlers in the
+ * remaining phases.
* @param engine pointer to engine
- * @param eng pointer to environment struct
+ * @param env pointer to environment struct
* @param phases pointer to phases
- * @param msg_ctx pointer to message context
+ * @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)(
@@ -190,31 +210,36 @@
axis2_msg_ctx_t *msg_ctx);
/**
+ * Gets sender's SOAP fault code.
* @param engine pointer to engine
- * @param eng pointer to environment struct
- * @param soap_namespace pointer to namespace
+ * @param env pointer to environment struct
+ * @param soap_namespace pointer to SOAP namespace
+ * @return pointer to SOAP fault code string
*/
- axis2_char_t *(AXIS2_CALL *
+ const axis2_char_t *(AXIS2_CALL *
get_sender_fault_code)(
- axis2_engine_t *engine,
+ const axis2_engine_t *engine,
const axis2_env_t *env,
- axis2_char_t *soap_namespace);
+ const axis2_char_t *soap_namespace);
/**
+ * Gets receiver's SOAP fault code.
* @param engine pointer to engine
- * @param eng pointer to environment struct
+ * @param env pointer to environment struct
* @param soap_namespace pointer to soap namespace
*/
const axis2_char_t *(AXIS2_CALL *
get_receiver_fault_code)(
- axis2_engine_t *engine,
+ const axis2_engine_t *engine,
const axis2_env_t *env,
- axis2_char_t *soap_namespace);
+ const axis2_char_t *soap_namespace);
/**
+ * Frees engine struct.
* @param engine pointer to engine
- * @param eng pointer to environment struct
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
free)(
@@ -222,9 +247,13 @@
const axis2_env_t *env);
/**
+ * Resumes receieve 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 receieve operation.
* @param engine pointer to engine
- * @param eng pointer to environment struct
+ * @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)(
@@ -233,9 +262,13 @@
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 eng pointer to environment struct
+ * @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)(
@@ -246,7 +279,7 @@
};
/**
- * Engine struct
+ * engine struct.
*/
struct axis2_engine
{
@@ -255,44 +288,48 @@
axis2_engine_ops_t *ops;
};
+ /**
+ * Creates en engine struct instance.
+ * @param env pointer to environment struct
+ * @param conf_ctx pointer to configuration context struct
+ * @return pointer to newly created engine struct
+ */
AXIS2_EXTERN axis2_engine_t *AXIS2_CALL
axis2_engine_create(
const axis2_env_t *env,
axis2_conf_ctx_t *conf_ctx);
-/************************** Start of function macros **************************/
-
-/** Send.
+/** Sends SOAP message invoking the out flow.
@sa axis2_engine_ops#send */
#define AXIS2_ENGINE_SEND(engine, env, msg_ctx)\
((engine)->ops->send(engine, env, msg_ctx))
-/** Receive.
+/** Receives SOAP message invoking the in flow.
@sa axis2_engine_ops#receive */
#define AXIS2_ENGINE_RECEIVE(engine, env, msg_ctx) \
((engine)->ops->receive(engine, env, msg_ctx))
-/** Send fault.
+/** Sends a SOAP fault.
@sa axis2_engine_ops#send_fault */
#define AXIS2_ENGINE_SEND_FAULT(engine, env, msg_ctx) \
((engine)->ops->send_fault(engine, env, msg_ctx))
-/** Receive fault.
+/** Receive a SOAP fault.
@sa axis2_engine_ops#receive_fault */
#define AXIS2_ENGINE_RECEIVE_FAULT(engine, env, msg_ctx) \
((engine)->ops->receive_fault(engine, env, msg_ctx))
-/** Fault message context.
+/** Creates fault message context.
@sa axis2_engine_ops#create_fault_msg_ctx */
#define AXIS2_ENGINE_CREATE_FAULT_MSG_CTX(engine, env, msg_ctx) \
((engine)->ops->create_fault_msg_ctx(engine, env, msg_ctx))
-/** Extraxts the fault info from messag econtext
+/** Extraxts the fault info from messag econtext,
@sa axis2_engine_ops#extract_fault_info_from_msg_ctx */
#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))
-/** Verify context built.
+/** Verifies that the context hierarchy is built.
@sa axis2_engine_ops#verify_ctx_built */
#define AXIS2_ENGINE_VERIFY_CTX_BUILT(engine, env, msg_ctx) \
((engine)->ops->verify_ctx_built(engine, env, msg_ctx))
@@ -307,27 +344,27 @@
#define AXIS2_ENGINE_RESUME_INVOCATION_PHASES(engine, env, phases, msg_ctx) \
((engine)->ops->resume_invocation_phases(engine, env, phases, msg_ctx))
-/** Gets the sender fault code.
+/** Gets sender fault code.
@sa axis2_engine_ops#get_sender_fault_code */
#define AXIS2_ENGINE_GET_SENDER_FAULT_CODE(engine, env, soap_namespace) \
((engine)->ops->get_sender_fault_code(engine, env, soap_namespace))
-/** Gets the receiver fault code.
+/** Gets receiver fault code.
@sa axis2_engine_ops#get_receiver_fault_code */
#define AXIS2_ENGINE_GET_RECEIVER_FAULT_CODE(engine, env, soap_namespace) \
((engine)->ops->get_receiver_fault_code(engine, env, soap_namespace))
-/** Frees the engine.
+/** Frees engine.
@sa axis2_engine_ops#free */
#define AXIS2_ENGINE_FREE(engine, env) \
((engine)->ops->free(engine, env))
-/** Resume send.
+/** Resumes send operation.
@sa axis2_engine_ops#resume_send */
#define AXIS2_ENGINE_RESUME_SEND(engine, env, msg_ctx)\
((engine)->ops->resume_send(engine, env, msg_ctx))
-/** Resume receive.
+/** Resumes receive operation.
@sa axis2_engine_ops#resume_receive */
#define AXIS2_ENGINE_RESUME_RECEIVE(engine, env, msg_ctx) \
((engine)->ops->resume_receive(engine, env, msg_ctx))
Modified: webservices/axis2/trunk/c/include/axis2_handler.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_handler.h?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_handler.h (original)
+++ webservices/axis2/trunk/c/include/axis2_handler.h Sat Aug 12 08:21:17 2006
@@ -20,13 +20,20 @@
/**
* @defgroup axis2_handler handler
* @ingroup axis2_handler
- * Description.
+ * handler is the smallest unit of execution in the Axis2 engine's execution flow.
+ * The engine could have two flows, the in-flow and out-flow. A flow is a
+ * collection of phases and a phase in turn is a collection of handlers.
+ * handlers are configured in relation to modules. A module is a point of
+ * extension in the Axis2 engine and a module would have one or more handlers
+ * defined in its configuration. The module configuration defines the phases
+ * each handler is attached to. A handler is invoked when the phase within which
+ * it lives is invoked. handler is stateless and it is using the message context
+ * that the state information is captures across invocations.
* @{
*/
/**
* @file axis2_handler.h
- * @brief Axis2 handler interface
*/
#include <axis2_defines.h>
@@ -42,44 +49,48 @@
typedef struct axis2_handler axis2_handler_t;
/** Type name for struct axis2_handler_ops */
typedef struct axis2_handler_ops axis2_handler_ops_t;
+
struct axis2_handler_desc;
struct axis2_msg_ctx;
/**
- * Handler ops struct
+ * handler ops struct.
+ * Encapsulator struct for ops of axis2_handler.
*/
struct axis2_handler_ops
{
/**
- * Free an axis2_handler struct
- * @param env Environment. MUST NOT be NULL, if NULL behaviour is undefined.
- * @param axis2_handler pointer to axis2_handler struct to be freed
- * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
+ * Free handler struct.
+ * @param handler pointer to handler
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
free)(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env);
/**
+ * Initializes the handler with the information form handler description.
* @param handler pointer to handler
* @param env pointer to environment struct
- * @param handler_desc pointer to handler description
+ * @param handler_desc pointer to handler description related to the handler
* @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
init)(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env,
struct axis2_handler_desc *handler_desc);
/**
- * Invoke is called to do the actual work of the Handler object.
- * If there is a fault during the processing of this method it is
- * invoke's job to report the error and undo any partial work
- * that has been completed.
+ * Invoke is called to do the actual work assigned to the handler.
+ * The phase that owns the handler is responsible for calling invoke
+ * on top of the handler. Those structs that implement the interface
+ * of the handler should implement the logic for invoke and assign the
+ * respective function pointer to invoke operation of the ops struct.
* @param handler pointer to handler
* @param env pointer to environment struct
* @param msg_ctx pointer to message context
@@ -87,56 +98,48 @@
*/
axis2_status_t (AXIS2_CALL *
invoke)(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx);
/**
+ * Gets QName.
* @param handler pointer to handler
* @param env pointer to environment struct
+ * @return pointer to QName of the handler
*/
axis2_qname_t *(AXIS2_CALL *
- get_name)(
+ get_qname)(
const axis2_handler_t *handler,
const axis2_env_t *env);
/**
+ * Gets the named parameter.
* @param handler pointer to handler
* @param env pointer to environment struct
- * @param name pointer to name
+ * @param name name of the parameter to be accessed
*/
axis2_param_t *(AXIS2_CALL *
get_param)(
const axis2_handler_t *handler,
const axis2_env_t *env,
- axis2_char_t *name);
+ const axis2_char_t *name);
/**
- * To get the phaseRule of a handler it is required to get the HnadlerDescription of the handler
- * so the argumnet pass when it call return as HnadlerDescription
+ * Gets the handler description related to the handler.
* @param handler pointer to handler
* @param env pointer to environment struct
+ * @return pointer to handler description struct related to handler
*/
struct axis2_handler_desc *(AXIS2_CALL *
get_handler_desc)(
const axis2_handler_t *handler,
const axis2_env_t *env);
- /**
- * derived struct accessor
- */
- /*void* (AXIS2_CALL *get_derived)(struct axis2_handler * handler,
- const axis2_env_t *env);
- */
- /**
- * derived struct mutator
- */
- /*axis2_status_t (AXIS2_CALL *set_derived)(struct axis2_handler *handler,
- const axis2_env_t *env, void *derived);
- */
+
};
/**
- * Handler struct
+ * handler struct.
*/
struct axis2_handler
{
@@ -145,69 +148,67 @@
};
/**
+ * Function pointer defining the creates syntax for a handler struct instance.
* @param env pointer to environment struct
* @param pointer to qname
+ * @return pointer to newly created handler struct
*/
typedef axis2_handler_t *(AXIS2_CALL *
AXIS2_HANDLER_CREATE_FUNC)(
const axis2_env_t *env,
- axis2_qname_t *qname);
+ const axis2_qname_t *qname);
/**
- * creates handler struct
+ * Creates handler struct instance.
* @param env pointer to environment struct
+ * @return pointer to newly created handler struct
*/
AXIS2_EXTERN axis2_handler_t *AXIS2_CALL
axis2_handler_create(
const axis2_env_t *env);
/**
+ * Creates a handler with invoke method implemented to fill in the service
+ * and operation context information.
* @param env pointer to environment struct
- * @param qname pointer to qname
+ * @param qname pointer to qname, this is cloned within create method
+ * @return pointer to newly created handler struct
*/
AXIS2_EXTERN axis2_handler_t *AXIS2_CALL
axis2_ctx_handler_create(
const axis2_env_t *env,
- axis2_qname_t *qname);
+ const axis2_qname_t *qname);
-/** Frees the handler.
+/** Frees handler.
@sa axis2_handler_ops#free */
#define AXIS2_HANDLER_FREE(handler, env) \
((handler)->ops->free(handler, env))
-/** Initialize the handler.
+/** Initializes handler.
@sa axis2_handler_ops#init */
#define AXIS2_HANDLER_INIT(handler, env, handler_desc) \
((handler)->ops->init(handler, env, handler_desc))
-/** Invoke.
+/** Invokes the handler.
@sa axis2_handler_ops#invoke */
#define AXIS2_HANDLER_INVOKE(handler, env, msg_ctx) \
((handler)->ops->invoke(handler, env, msg_ctx))
-/** Set invoke.
- @sa axis2_handler_ops#set_invoke */
-#define AXIS2_HANDLER_SET_INVOKE(handler, env, invoke) \
- ((handler)->ops->set_invoke(handler, env, invoke))
-
-/** Gets the name.
- @sa axis2_handler_ops#get_name */
-#define AXIS2_HANDLER_GET_NAME(handler, env) \
- ((handler)->ops->get_name(handler, env))
+/** Gets handler QName.
+ @sa axis2_handler_ops#get_qname */
+#define AXIS2_HANDLER_GET_QNAME(handler, env) \
+ ((handler)->ops->get_qname(handler, env))
-/** Gets the param.
+/** Gets the named parameter.
@sa axis2_handler_ops#get_param */
#define AXIS2_HANDLER_GET_PARAM(handler, env, name) \
((handler)->ops->get_param(handler, env, name))
-/** Gets the handler description.
+/** Gets handler description related to the handler.
@sa axis2_handler_ops#get_handler_desc */
#define AXIS2_HANDLER_GET_HANDLER_DESC(handler, env) \
((handler)->ops->get_handler_desc(handler, env))
-/*#define AXIS2_HANDLER_GET_DERIVED(handler, env) ((handler)->ops->get_derived(handler, env))
-#define AXIS2_HANDLER_SET_DERIVED(handler, env, derived) ((handler)->ops->set_derived(handler, env, derived))
-*/
/** @} */
#ifdef __cplusplus
Modified: webservices/axis2/trunk/c/include/axis2_handler_desc.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_handler_desc.h?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_handler_desc.h (original)
+++ webservices/axis2/trunk/c/include/axis2_handler_desc.h Sat Aug 12 08:21:17 2006
@@ -102,7 +102,7 @@
get_param)(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
- axis2_char_t *name);
+ const axis2_char_t *name);
/**
* @param axis2_handler_desc_t pointer to handler description
Modified: webservices/axis2/trunk/c/modules/core/context/msg_ctx.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/context/msg_ctx.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/context/msg_ctx.c (original)
+++ webservices/axis2/trunk/c/modules/core/context/msg_ctx.c Sat Aug 12 08:21:17 2006
@@ -2498,7 +2498,7 @@
if (handler)
{
AXIS2_INTF_TO_IMPL(msg_ctx)->paused_handler_name =
- AXIS2_HANDLER_GET_NAME(handler, env);
+ AXIS2_HANDLER_GET_QNAME(handler, env);
}
}
return AXIS2_SUCCESS;
Modified: webservices/axis2/trunk/c/modules/core/description/handler_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/handler_desc.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/handler_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/handler_desc.c Sat Aug 12 08:21:17 2006
@@ -68,7 +68,7 @@
axis2_handler_desc_get_param(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
- axis2_char_t *name);
+ const axis2_char_t *name);
axis2_status_t AXIS2_CALL
axis2_handler_desc_add_param(
@@ -265,7 +265,7 @@
axis2_handler_desc_get_param(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
- axis2_char_t *name)
+ const axis2_char_t *name)
{
axis2_handler_desc_impl_t *handler_desc_impl = NULL;
Modified: webservices/axis2/trunk/c/modules/core/engine/ctx_handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/ctx_handler.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/ctx_handler.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/ctx_handler.c Sat Aug 12 08:21:17 2006
@@ -36,7 +36,7 @@
axis2_handler_t *AXIS2_CALL
axis2_ctx_handler_create(
const axis2_env_t *env,
- axis2_qname_t *qname)
+ const axis2_qname_t *qname)
{
axis2_handler_t *handler = NULL;
axis2_handler_desc_t *handler_desc = NULL;
Modified: webservices/axis2/trunk/c/modules/core/engine/engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/engine.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/engine.c Sat Aug 12 08:21:17 2006
@@ -28,11 +28,6 @@
#include <axis2_addr.h>
#include <axis2_uuid_gen.h>
-/**
- * There is only one engine for the Server and the Client. the send() and receive()
- * Methods are the basic ops the Sync, Async messageing are build on top.
- */
-
typedef struct axis2_engine_impl
{
@@ -103,17 +98,17 @@
axis2_array_list_t *phases,
axis2_msg_ctx_t *msg_ctx);
-axis2_char_t *AXIS2_CALL
+const axis2_char_t *AXIS2_CALL
axis2_engine_get_sender_fault_code(
- axis2_engine_t *engine,
+ const axis2_engine_t *engine,
const axis2_env_t *env,
- axis2_char_t *soap_namespace);
+ const axis2_char_t *soap_namespace);
const axis2_char_t *AXIS2_CALL
axis2_engine_get_receiver_fault_code(
- axis2_engine_t *engine,
+ const axis2_engine_t *engine,
const axis2_env_t *env,
- axis2_char_t *soap_namespace);
+ const axis2_char_t *soap_namespace);
axis2_status_t AXIS2_CALL
axis2_engine_free(
@@ -235,16 +230,6 @@
return AXIS2_SUCCESS;
}
-/**
- * This methods represents the outflow of the Axis, this could be either at the server side or the client side.
- * Here the <code>ExecutionChain</code> is created using the Phases. The Handlers at the each Phases is ordered in
- * deployment time by the deployment module
- *
- * @param *msg_ctx
- * @see axis2_msg_ctx
- * @see Phase
- * @see Handler
- */
axis2_status_t AXIS2_CALL
axis2_engine_send(
axis2_engine_t *engine,
@@ -281,13 +266,11 @@
}
- /*axis2_array_list_t *global_out_phase = NULL;*/
-
if (AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))
{
- /* the message has paused, so rerun them from the position they stoped. The Handler
- //who paused the Message will be the first one to run
- //resume fixed, global precalulated phases
+ /* message has paused, so rerun it from the position it stoped.
+ The handler which paused the message will be the first one to resume
+ invocation
*/
status = axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
if (status != AXIS2_SUCCESS)
@@ -324,7 +307,7 @@
if (!(AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env)))
{
- /* write the message to the wire */
+ /* write the message to wire */
axis2_transport_sender_t *transport_sender = NULL;
axis2_transport_out_desc_t *transport_out = AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(msg_ctx, env);
@@ -348,11 +331,6 @@
return AXIS2_SUCCESS;
}
-/**
- * This methods represents the inflow of the Axis, this could be either at the server side or the client side.
- * Here the <code>ExecutionChain</code> is created using the Phases. The Handlers at the each Phases is ordered in
- * deployment time by the deployment module
- */
axis2_status_t AXIS2_CALL
axis2_engine_receive(
axis2_engine_t *engine,
@@ -382,9 +360,7 @@
if (AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))
{
- /* the message has paused, so re-run them from the position they stoped. The Handler
- who paused the Message will be the first one to run
- resume fixed, global precalulated phases */
+ /* the message has paused, so re-run them from the position they stoped. */
axis2_engine_resume_invocation_phases(engine, env, pre_calculated_phases, msg_ctx);
if (AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))
{
@@ -446,7 +422,7 @@
if (status != AXIS2_SUCCESS)
return status;
- /* invoke the Message Receivers */
+ /* invoke the message receivers */
if (!op)
return AXIS2_FAILURE;
receiver = AXIS2_OP_GET_MSG_RECV(op, env);
@@ -466,11 +442,6 @@
return status;
}
-/**
- * Sends the SOAP Fault to another SOAP node.
- *
- * @param msg_ctx
- */
axis2_status_t AXIS2_CALL
axis2_engine_send_fault(
axis2_engine_t *engine,
@@ -484,24 +455,6 @@
op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
- /* find and execute the Fault Out Flow Handlers */
- /*if (op_ctx)
- {
- axis2_op_t *op = AXIS2_OP_CTX_GET_OP(op_ctx, env);
- axis2_array_list_t *phases = AXIS2_OP_GET_PHASES_OUTFLOW(op, env);
-
- if (AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))
- {
- axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
- }
- else
- {
- axis2_engine_invoke_phases(engine, env, phases, msg_ctx);
- }
- }*/
- /* it is possible that op context is NULL as the error occered before the
- dispatcher. We do not run Handlers in that case */
-
if (!(AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env)))
{
/* send the SOAP Fault*/
@@ -532,10 +485,6 @@
return AXIS2_SUCCESS;
}
-/**
- * This is invoked when a SOAP Fault is received from a Other SOAP Node
- * Receives a SOAP fault from another SOAP node.
- */
axis2_status_t AXIS2_CALL
axis2_engine_receive_fault(
axis2_engine_t *engine,
@@ -594,11 +543,6 @@
return AXIS2_SUCCESS;
}
-/**
- * This method is called to handle any error that occurs at inflow or outflow. But if the
- * method is called twice, it implies that sending the error handling has failed, in which case
- * the method logs the error and exists.
- */
axis2_msg_ctx_t *AXIS2_CALL
axis2_engine_create_fault_msg_ctx(
axis2_engine_t *engine,
@@ -749,34 +693,6 @@
return fault_ctx;
}
-/**
- * Information to create the SOAPFault can be extracted from different places.
- * 1. Those information may have been put in to the message context by some handler. When someone
- * is putting like that, he must make sure the SOAPElements he is putting must be from the
- * correct SOAP Version.
- * 2. SOAPProcessingException is flexible enough to carry information about the fault. For example
- * it has an attribute to store the fault code. The fault reason can be extracted from the
- * message of the exception. I opted to put the stacktrace under the detail element.
- * eg : <Detail>
- * <Exception> stack trace goes here </Exception>
- * <Detail>
- * <p/>
- * If those information can not be extracted from any of the above places, I default the soap
- * fault values to following.
- * <Fault>
- * <Code>
- * <Value>env:Receiver</Value>
- * </Code>
- * <Reason>
- * <Text>unknown</Text>
- * </Reason>
- * <Role/>
- * <Node/>
- * <Detail/>
- * </Fault>
- * <p/>
- * -- EC
- */
axis2_status_t AXIS2_CALL
axis2_engine_extract_fault_info_from_msg_ctx(
axis2_engine_t *engine,
@@ -784,72 +700,10 @@
axis2_msg_ctx_t *msg_ctx,
struct axiom_soap_fault *fault)
{
- /*axis2_char_t *soap_namespace_uri = NULL;*/
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, fault, AXIS2_FAILURE);
-
- /* get the current SOAP version */
- /*if (AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx, env))
- {
- soap_namespace_uri = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI;
- }
- else
- {
- soap_namespace_uri = AXI2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
- }
-
- void *fault_code = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME);
- axis2_char_t *soap_fault_code = "";
- if (fault_code)
- {
- AXIOM_SOAP_FAULT_SET_CODE(fault, env, fault_code);
- }*/
- /* defaulting to fault code Sender, if no message is available */
- /*soap_fault_code = get_sender_fault_code(soap_namespace_uri);
- fault.getCode().getValue().setText(soap_fault_code);
-
- void *fault_Reason = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME);
- axis2_char_t * message = "";
- if (fault_Reason)
- {
- AXIOM_SOAP_FAULT_SET_REASON(fault, env, fault_Reason);
- }
-*/
- /* defaulting to reason, unknown, if no reason is available */
- /* message = "unknown";
- fault.getReason().getSOAPText().setText(message);
-
- void *fault_role = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME);
- if (fault_role)
- {
- fault.getRole().setText((axis2_char_t *) fault_role);
- }
- else
- {
- get the role of this server and assign it here
- fault.getRole().setText("http://myAxisServer/role/default");
- }
-
- void *fault_node = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIOM_SOAP12_SOAP_FAULT_NODE_LOCAL_NAME);
- if (fault_node)
- {
- fault.getNode().setText((axis2_char_t *) fault_node);
- }
- else
- {
- get the node of this server and assign it here
- fault.getNode().setText("http://myAxisServer/role/default");
- }
-
- void *fault_detail = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME);
- if (fault_detail)
- {
- AXIOM_SOAP_FAULT_SET_DETAIL(fault, env, fault_detail);
- }
- */
return AXIS2_SUCCESS;
}
@@ -937,7 +791,7 @@
axis2_char_t *phase_name = AXIS2_PHASE_GET_NAME(phase, env);
axis2_char_t *paused_phase_name = AXIS2_MSG_CTX_GET_PAUSED_PHASE_NAME(
msg_ctx, env);
- /* Skip invoking hanlders until we find the paused phase */
+ /* skip invoking hanlders until we find the paused phase */
if (phase_name && paused_phase_name && 0 == AXIS2_STRCMP(phase_name,
paused_phase_name))
{
@@ -946,13 +800,13 @@
paused_handler_i = AXIS2_MSG_CTX_GET_CURRENT_HANDLER_INDEX(msg_ctx,
env);
- /* Invoke the paused handler and rest of the handlers of the puased
+ /* invoke the paused handler and rest of the handlers of the puased
* phase */
AXIS2_PHASE_INVOKE_START_FROM_HANDLER(phase, env, paused_handler_i,
msg_ctx);
}
- else /* Now we have found the paused phase and invoked the rest of the
- * handlers of that phase.Invoke all the phases after that */
+ else /* now we have found the paused phase and invoked the rest of the
+ * handlers of that phase, invoke all the phases after that */
{
if (found_match)
{
@@ -964,28 +818,23 @@
return AXIS2_SUCCESS;
}
-axis2_char_t *AXIS2_CALL
+const axis2_char_t *AXIS2_CALL
axis2_engine_get_sender_fault_code(
- axis2_engine_t *engine,
+ const axis2_engine_t *engine,
const axis2_env_t *env,
- axis2_char_t *soap_namespace)
+ const axis2_char_t *soap_namespace)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, soap_namespace, AXIS2_FAILURE);
- /*if (AXIS2_STRCMP(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, soap_namespace))
- return AXIOM_SOAP12_FAULT_CODE_SENDER;
- else
- return AXIOM_SOAP11_FAULT_CODE_SENDER;
- */
return NULL;
}
const axis2_char_t *AXIS2_CALL
axis2_engine_get_receiver_fault_code(
- axis2_engine_t *engine,
+ const axis2_engine_t *engine,
const axis2_env_t *env,
- axis2_char_t *soap_namespace)
+ const axis2_char_t *soap_namespace)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, soap_namespace, AXIS2_FAILURE);
@@ -1087,10 +936,6 @@
return AXIS2_SUCCESS;
}
-/**
- * If the msgConetext is puased and try to invoke then
- * first invoke the phase list and after the message receiver
- */
axis2_status_t AXIS2_CALL
axis2_engine_resume_receive(
axis2_engine_t *engine,
@@ -1109,10 +954,10 @@
AXIS2_CONF_GET_IN_PHASES_UPTO_AND_INCLUDING_POST_DISPATCH(conf, env);
axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx);
- /* invoking the MR */
+ /* invoking the message receiver */
if (AXIS2_MSG_CTX_GET_SERVER_SIDE(msg_ctx, env) && !AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))
{
- /* invoke the Message Receivers */
+ /* invoke the message receivers */
axis2_op_ctx_t *op_ctx = NULL;
status = axis2_engine_check_must_understand_headers(env, msg_ctx);
@@ -1140,10 +985,6 @@
return status;
}
-/**
- * To resume the invocation at the send path , this is neened since it is require to call
- * TransportSender at the end
- */
axis2_status_t AXIS2_CALL
axis2_engine_resume_send(
axis2_engine_t *engine,
@@ -1153,6 +994,7 @@
axis2_op_ctx_t *op_ctx = NULL;
axis2_array_list_t *phases = NULL;
axis2_status_t status = AXIS2_FAILURE;
+
/* invoke the phases */
op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
if (op_ctx)
Modified: webservices/axis2/trunk/c/modules/core/engine/handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/handler.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/handler.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/handler.c Sat Aug 12 08:21:17 2006
@@ -19,11 +19,9 @@
typedef struct axis2_handler_impl
{
- /** Handler struct */
+ /** handler struct */
axis2_handler_t handler;
- /** Derived struct */
- /*void* derived;*/
- /** Handler description. This is a referance, hence a shallow copy. */
+ /** handler description. This is a reference, hence a shallow copy. */
axis2_handler_desc_t *handler_desc;
}
axis2_handler_impl_t;
@@ -34,18 +32,17 @@
axis2_status_t AXIS2_CALL
axis2_handler_free(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env);
axis2_qname_t *AXIS2_CALL
-axis2_handler_get_name(
+axis2_handler_get_qname(
const axis2_handler_t *handler,
const axis2_env_t *env) ;
-
axis2_status_t AXIS2_CALL
axis2_handler_invoke(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx);
@@ -53,28 +50,19 @@
axis2_handler_get_param(
const axis2_handler_t *handler,
const axis2_env_t *env,
- axis2_char_t *name);
+ const axis2_char_t *name);
axis2_status_t AXIS2_CALL
axis2_handler_init(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env,
- struct axis2_handler_desc *handler_desc);
+ axis2_handler_desc_t *handler_desc);
axis2_handler_desc_t *AXIS2_CALL
axis2_handler_get_handler_desc(
const axis2_handler_t *handler,
const axis2_env_t *env);
-/*void* AXIS2_CALL axis2_handler_get_derived(
- struct axis2_handler * handler,
- const axis2_env_t *env);
-axis2_status_t AXIS2_CALL axis2_handler_set_derived(
- struct axis2_handler * handler,
- const axis2_env_t *env,
- void* derived);
-*/
-
axis2_handler_t *AXIS2_CALL
axis2_handler_create(
const axis2_env_t *env)
@@ -91,7 +79,6 @@
return NULL;
}
- /*handler_impl->derived = NULL;*/
handler_impl->handler_desc = NULL;
/* initialize ops */
@@ -114,8 +101,8 @@
handler_impl->handler.ops->invoke =
axis2_handler_invoke;
- handler_impl->handler.ops->get_name =
- axis2_handler_get_name;
+ handler_impl->handler.ops->get_qname =
+ axis2_handler_get_qname;
handler_impl->handler.ops->get_param =
axis2_handler_get_param;
@@ -123,15 +110,12 @@
handler_impl->handler.ops->get_handler_desc =
axis2_handler_get_handler_desc;
- /*handler_impl->handler.ops->get_derived= axis2_handler_get_derived;
- handler_impl->handler.ops->set_derived= axis2_handler_set_derived;
- */
return &(handler_impl->handler);
}
axis2_status_t AXIS2_CALL
axis2_handler_free(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env)
{
axis2_handler_impl_t *handler_impl = NULL;
@@ -150,7 +134,7 @@
}
axis2_qname_t *AXIS2_CALL
-axis2_handler_get_name(
+axis2_handler_get_qname(
const axis2_handler_t *handler,
const axis2_env_t *env)
{
@@ -164,11 +148,11 @@
axis2_status_t AXIS2_CALL
axis2_handler_invoke(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
- /**TODO invoke has to be implemented by an implementing handler */
+ /** NOTE invoke has to be implemented by an implementing handler */
return AXIS2_SUCCESS;
}
@@ -176,7 +160,7 @@
axis2_handler_get_param(
const axis2_handler_t *handler,
const axis2_env_t *env,
-axis2_char_t *name)
+ const axis2_char_t *name)
{
AXIS2_ENV_CHECK(env, NULL);
@@ -188,9 +172,9 @@
axis2_status_t AXIS2_CALL
axis2_handler_init(
- struct axis2_handler *handler,
+ axis2_handler_t *handler,
const axis2_env_t *env,
- struct axis2_handler_desc *handler_desc)
+ axis2_handler_desc_t *handler_desc)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_INTF_TO_IMPL(handler)->handler_desc = handler_desc;
@@ -207,22 +191,3 @@
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(handler)->handler_desc;
}
-
-/*void* AXIS2_CALL axis2_handler_get_derived(
- struct axis2_handler * handler,
- const axis2_env_t *env)
-{
- AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(handler)->derived;
-}
-axis2_status_t AXIS2_CALL axis2_handler_set_derived(
- struct axis2_handler * handler,
- const axis2_env_t *env,
- void* derived)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(handler)->derived = derived;
-
- return AXIS2_SUCCESS;
-}
-*/
Modified: webservices/axis2/trunk/c/modules/core/engine/phase.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/phase.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/phase.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/phase.c Sat Aug 12 08:21:17 2006
@@ -270,7 +270,7 @@
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"axis2_handler_t *%s added to the index %d of the phase %s",
- AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(handler, env), env),
+ AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_QNAME(handler, env), env),
index,
phase_impl->name);
@@ -290,7 +290,7 @@
phase_impl = AXIS2_INTF_TO_IMPL(phase);
AXIS2_LOG_INFO(env->log, "Handler %s added to phase %s",
- AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(handler, env), env),
+ AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_QNAME(handler, env), env),
phase_impl->name);
return AXIS2_ARRAY_LIST_ADD(phase_impl->handlers, env, handler);
@@ -322,7 +322,7 @@
AXIS2_LOG_INFO(env->log,
"Invoke the first handler %s within the phase %s",
AXIS2_QNAME_GET_LOCALPART(
- AXIS2_HANDLER_GET_NAME(phase_impl->first_handler, env), env),
+ AXIS2_HANDLER_GET_QNAME(phase_impl->first_handler, env), env),
phase_impl->name);
status = AXIS2_HANDLER_INVOKE(phase_impl->first_handler, env, msg_ctx);
@@ -347,7 +347,7 @@
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Invoke the handler %s within the phase %s",
- AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(handler, env), env),
+ AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_QNAME(handler, env), env),
phase_impl->name);
status = AXIS2_HANDLER_INVOKE(handler, env, msg_ctx);
if (status != AXIS2_SUCCESS)
@@ -370,7 +370,7 @@
else
{
AXIS2_LOG_INFO(env->log, "Invoke the last handler %s within the phase %s",
- AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(phase_impl->last_handler, env), env),
+ AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_QNAME(phase_impl->last_handler, env), env),
phase_impl->name);
status = AXIS2_HANDLER_INVOKE(phase_impl->last_handler, env, msg_ctx);
if (status != AXIS2_SUCCESS)
Modified: webservices/axis2/trunk/c/test/unit/core/engine/test_conf.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/test/unit/core/engine/test_conf.c?rev=431041&r1=431040&r2=431041&view=diff
==============================================================================
--- webservices/axis2/trunk/c/test/unit/core/engine/test_conf.c (original)
+++ webservices/axis2/trunk/c/test/unit/core/engine/test_conf.c Sat Aug 12 08:21:17 2006
@@ -54,7 +54,7 @@
for(j = 0; j < sizej; j++)
{
handler = AXIS2_ARRAY_LIST_GET(handlers, env, j);
- qname = AXIS2_HANDLER_GET_NAME(handler, env);
+ qname = AXIS2_HANDLER_GET_QNAME(handler, env);
handler_name = AXIS2_QNAME_GET_LOCALPART(qname, env);
if(0 == AXIS2_STRCMP(handler_name, "addressing_based_dispatcher"))
{
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org