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/05 05:11:57 UTC
svn commit: r514539 [2/8] - in /webservices/axis2/trunk/c: include/
modules/core/deployment/ modules/core/description/ modules/core/engine/
modules/core/transport/http/receiver/ modules/core/transport/http/sender/
Modified: webservices/axis2/trunk/c/include/axis2_msg.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_msg.h?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_msg.h (original)
+++ webservices/axis2/trunk/c/include/axis2_msg.h Sun Mar 4 20:11:56 2007
@@ -49,229 +49,193 @@
{
#endif
- /** Type name for struct axis2_msg_ops */
- typedef struct axis2_msg_ops axis2_msg_ops_t;
/** Type name for struct axis2_msg */
typedef struct axis2_msg axis2_msg_t;
+ /**
+ * Frees message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_free(axis2_msg_t *msg,
+ const axis2_env_t *env);
+
+ /**
+ * Adds a parameter.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param param pointer to parameter, message assumes ownership of
+ * parameter
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_add_param(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ axis2_param_t *param);
+
/**
- * message ops struct.
- * Encapsulator struct for ops of axis2_msg.
+ * Gets the named parameter.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param name parameter name string
+ * @return pointer to parameter corresponding to the same name, returns
+ * a reference, not a cloned copy
+ */
+ axis2_param_t *AXIS2_CALL
+ axis2_msg_get_param(const axis2_msg_t *msg,
+ const axis2_env_t *env,
+ const axis2_char_t *name);
+
+ /**
+ * Gets all parameters stored in message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return pointer to list of parameters, returns a reference, not a
+ * cloned copy
*/
- struct axis2_msg_ops
- {
- /**
- * Frees message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- free)(
- axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Adds a parameter.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param param pointer to parameter, message assumes ownership of
- * parameter
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- add_param)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- axis2_param_t *param);
-
- /**
- * Gets the named parameter.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param name parameter name string
- * @return pointer to parameter corresponding to the same name, returns
- * a reference, not a cloned copy
- */
- axis2_param_t *(AXIS2_CALL *
- get_param)(
- const axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
- /**
- * Gets all parameters stored in message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return pointer to list of parameters, returns a reference, not a
- * cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_all_params)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Checks if the named parameter is locked.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param param_name parameter name string
- * @return AXIS2_TRUE if the parameter is locked, else AXIS2_FALSE
- */
- axis2_bool_t (AXIS2_CALL *
- is_param_locked)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
- /**
- * Sets parent. Parent of a message is of type operation.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param op pointer to parent operation, message does not assume
- * ownership of parent
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_parent)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- axis2_op_t *op);
-
- /**
- * Gets parent. Parent of a message is of type operation.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return pointer to parent operation, returns a reference, not a
- * cloned copy
- */
- axis2_op_t *(AXIS2_CALL *
- get_parent)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Gets flow of execution associated with the message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return pointer to array list containing the list of phases
- * representing the flow
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_flow)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Sets flow of execution associated with the message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param flow pointer to array list of phases representing the flow,
- * message assumes ownership of flow
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_flow)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- axis2_array_list_t *flow);
-
- /**
- * Gets direction of message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return direction string
- */
- const axis2_char_t *(AXIS2_CALL *
- get_direction)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Sets direction of message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param direction pointer to direction
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_direction)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *direction);
-
- /**
- * Gets QName representing message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return pointer to QName, returns a reference, not a cloned copy
- */
- const axis2_qname_t *(AXIS2_CALL *
- get_element_qname)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Sets QName representing message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param element_qname pointer to QName representing message, this
- * function creates a clone of QName
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_element_qname)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_qname_t *element_qname);
-
- /**
- * Gets message name.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return message name string.
- */
- const axis2_char_t *(AXIS2_CALL *
- get_name)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
- /**
- * Sets message name.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @param message name string
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_name)(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
- /**
- * Gets XML schema element associated with the message.
- * @param msg pointer to message
- * @param env pointer to environment struct
- * @return pointer to XML schema element, returns a reference, not
- * a cloned copy
- */
- /*xml_schema_element_t *(AXIS2_CALL *
- get_schema_element)(
- const axis2_msg_t *msg,
- const axis2_env_t *env);*/
- };
+ axis2_array_list_t *AXIS2_CALL
+ axis2_msg_get_all_params(const axis2_msg_t *msg,
+ const axis2_env_t *env);
+
+ /**
+ * Checks if the named parameter is locked.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param param_name parameter name string
+ * @return AXIS2_TRUE if the parameter is locked, else AXIS2_FALSE
+ */
+ axis2_bool_t AXIS2_CALL
+ axis2_msg_is_param_locked(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ const axis2_char_t *param_name);
+
+ /**
+ * Sets parent. Parent of a message is of type operation.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param op pointer to parent operation, message does not assume
+ * ownership of parent
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_set_parent(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ axis2_op_t *op);
+
+ /**
+ * Gets parent. Parent of a message is of type operation.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return pointer to parent operation, returns a reference, not a
+ * cloned copy
+ */
+ axis2_op_t *AXIS2_CALL
+ axis2_msg_get_parent(const axis2_msg_t *msg,
+ const axis2_env_t *env);
/**
- * message struct.
+ * Gets flow of execution associated with the message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return pointer to array list containing the list of phases
+ * representing the flow
*/
- struct axis2_msg
- {
- /** operations of message struct */
- axis2_msg_ops_t *ops;
- /** parameter container to hold message parameters */
- struct axis2_param_container *param_container;
- };
+ axis2_array_list_t *AXIS2_CALL
+ axis2_msg_get_flow( const axis2_msg_t *msg,
+ const axis2_env_t *env);
+
+ /**
+ * Sets flow of execution associated with the message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param flow pointer to array list of phases representing the flow,
+ * message assumes ownership of flow
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_set_flow(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ axis2_array_list_t *flow);
+
+ /**
+ * Gets direction of message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return direction string
+ */
+ const axis2_char_t *AXIS2_CALL
+ axis2_msg_get_direction(const axis2_msg_t *msg,
+ const axis2_env_t *env);
+
+ /**
+ * Sets direction of message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param direction pointer to direction
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_set_direction(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ const axis2_char_t *direction);
+
+ /**
+ * Gets QName representing message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return pointer to QName, returns a reference, not a cloned copy
+ */
+ const axis2_qname_t *AXIS2_CALL
+ axis2_msg_get_element_qname(const axis2_msg_t *msg,
+ const axis2_env_t *env);
+
+ /**
+ * Sets QName representing message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param element_qname pointer to QName representing message, this
+ * function creates a clone of QName
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_set_element_qname(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ const axis2_qname_t *element_qname);
+
+ /**
+ * Gets message name.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return message name string.
+ */
+ const axis2_char_t *AXIS2_CALL
+ axis2_msg_get_name(const axis2_msg_t *msg,
+ const axis2_env_t *env);
+
+ /**
+ * Sets message name.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @param message name string
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ axis2_status_t AXIS2_CALL
+ axis2_msg_set_name(axis2_msg_t *msg,
+ const axis2_env_t *env,
+ const axis2_char_t *name);
+
+ /**
+ * Gets XML schema element associated with the message.
+ * @param msg pointer to message
+ * @param env pointer to environment struct
+ * @return pointer to XML schema element, returns a reference, not
+ * a cloned copy
+ */
+ /*xml_schema_element_t *AXIS2_CALL
+ axis2_msg_get_schema_element(const axis2_msg_t *msg,
+ const axis2_env_t *env);*/
/**
* Creates message struct instance.
@@ -279,89 +243,72 @@
* @return pointer to newly created message
*/
AXIS2_EXTERN axis2_msg_t *AXIS2_CALL
- axis2_msg_create(
- const axis2_env_t *env);
+ axis2_msg_create(const axis2_env_t *env);
-/** Frees message.
- @sa axis2_msg_ops#get_svc */
+/** Frees message. */
#define AXIS2_MSG_FREE(msg, env) \
- ((msg)->ops->free (msg, env))
+ axis2_msg_free (msg, env)
-/** Adds given parameter.
- @sa axis2_msg_ops#add_param */
+/** Adds given parameter. */
#define AXIS2_MSG_ADD_PARAM(msg, env, param) \
- ((msg)->ops->add_param (msg, env, param))
+ axis2_msg_add_param (msg, env, param)
-/** Gets named parameter.
- @sa axis2_msg_ops#get_param */
+/** Gets named parameter. */
#define AXIS2_MSG_GET_PARAM(msg, env, key) \
- ((msg)->ops->get_param (msg, env, key))
+ axis2_msg_get_param (msg, env, key)
-/** Gets all parameters.
- @sa axis2_msg_ops#get_all_params */
+/** Gets all parameters. */
#define AXIS2_MSG_GET_ALL_PARAMS(msg, env) \
- ((msg)->ops->get_all_params (msg, env))
+ axis2_msg_get_all_params (msg, env)
-/** Checks if named parameter is locked.
- @sa axis2_msg_ops#is_param_locked */
+/** Checks if named parameter is locked. */
#define AXIS2_MSG_IS_PARAM_LOCKED(msg, env, param_name) \
- ((msg)->ops->is_param_locked(msg, env, param_name))
+ axis2_msg_is_param_locked(msg, env, param_name)
-/** Sets parent operation.
- @sa axis2_msg_ops#set_parent */
+/** Sets parent operation. */
#define AXIS2_MSG_SET_PARENT(msg, env, service_desc) \
- ((msg)->ops->set_parent (msg, env, service_desc))
+ axis2_msg_set_parent (msg, env, service_desc)
-/** Gets parent operation.
- @sa axis2_msg_ops#get_parent */
+/** Gets parent operation. */
#define AXIS2_MSG_GET_PARENT(msg, env) \
- ((msg)->ops->get_parent (msg, env))
+ axis2_msg_get_parent (msg, env)
-/** Gets execution flow.
- @sa axis2_msg_ops#get_flow */
+/** Gets execution flow. */
#define AXIS2_MSG_GET_FLOW(msg, env) \
- ((msg)->ops->get_flow (msg, env))
+ axis2_msg_get_flow (msg, env)
-/** Sets execution flow.
- @sa axis2_msg_ops#set_flow */
+/** Sets execution flow. */
#define AXIS2_MSG_SET_FLOW(msg, env, flow) \
- ((msg)->ops->set_flow (msg, env, flow))
+ axis2_msg_set_flow (msg, env, flow)
-/** Gets message direction.
- @sa axis2_msg_ops#get_direction */
+/** Gets message direction. */
#define AXIS2_MSG_GET_DIRECTION(msg, env) \
- ((msg)->ops->get_direction (msg, env))
+ axis2_msg_get_direction (msg, env)
-/** Sets message direction.
- @sa axis2_msg_ops#set_direction */
+/** Sets message direction. */
#define AXIS2_MSG_SET_DIRECTION(msg, env, direction) \
- ((msg)->ops->set_direction (msg, env, direction))
+ axis2_msg_set_direction (msg, env, direction)
-/** Gets element QName.
- @sa axis2_msg_ops#get_element_qname */
+/** Gets element QName. */
#define AXIS2_MSG_GET_ELEMENT_QNAME(msg, env) \
- ((msg)->ops->get_element_qname(msg, env))
+ axis2_msg_get_element_qname(msg, env)
-/** Sets element QName.
- @sa axis2_msg_ops#set_element_qname */
+/** Sets element QName. */
#define AXIS2_MSG_SET_ELEMENT_QNAME(msg, env, element_qname) \
- ((msg)->ops->set_element_qname(msg, env, element_qname))
+ axis2_msg_set_element_qname(msg, env, element_qname)
-/** Gets name.
- @sa axis2_msg_ops#get_name */
+/** Gets name. */
#define AXIS2_MSG_GET_NAME(msg, env) \
- ((msg)->ops->get_name(msg, env))
+ axis2_msg_get_name(msg, env)
-/** Sets name.
- @sa axis2_msg_ops#set_name */
+/** Sets name. */
#define AXIS2_MSG_SET_NAME(msg, env, name) \
- ((msg)->ops->set_name(msg, env, name))
+ axis2_msg_set_name(msg, env, name)
-/** Gets schema element associated with message.
- @sa axis2_msg_ops#get_schema_element */
+/** Gets schema element associated with message. */
/*#define AXIS2_MSG_GET_SCHEMA_ELEMENT(msg, env) \
- ((msg)->ops->get_schema_element(msg, env))*/
+ axis2_msg_get_schema_element(msg, env)*/
/** @} */
#ifdef __cplusplus
Modified: webservices/axis2/trunk/c/include/axis2_op.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_op.h?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_op.h (original)
+++ webservices/axis2/trunk/c/include/axis2_op.h Sun Mar 4 20:11:56 2007
@@ -57,8 +57,6 @@
{
#endif
- /** Type name for struct axis2_op_ops */
- typedef struct axis2_op_ops axis2_op_ops_t;
/** Type name for struct axis2_op */
typedef struct axis2_op axis2_op_t;
@@ -78,536 +76,485 @@
#define AXIS2_SOAP_ACTION "soapAction"
/**
- * operation ops struct.
- * Encapsulator struct for ops of axis2_op.
+ * Frees operation.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_free(axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Frees operation given as a void pointer.
+ * @param op pointer to operation as a void pointer
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_free_void_arg(void *op,
+ const axis2_env_t *env);
+
+
+ /**
+ * Adds a parameter to method.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param param pointer parameter to be added, operation assumes
+ * ownership of parameter
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_add_param(axis2_op_t *op,
+ const axis2_env_t *env,
+ axis2_param_t *param);
+
+ /**
+ * Gets named parameter.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param name name of parameter to be retrieved as a string
+ * @return pointer to named parameter if exists, else NULL. Returns a
+ * reference, not a cloned copy
+ */
+ AXIS2_EXTERN axis2_param_t *AXIS2_CALL
+ axis2_op_get_param(const axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_char_t *name);
+
+ /**
+ * Gets all parameters.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing all parameters, returns
+ * a reference, not a cloned copy
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_all_params(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Checks if the named parameter is locked.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param param_name name of the parameter to be checked
+ * @return AXIS2_TRUE if named parameter is locked, else AXIS2_FALSE
+ */
+ AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+ axis2_op_is_param_locked(axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_char_t *param_name);
+
+ /**
+ * Sets parent. Parent of an operation is of type service.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param svc pointer to parent service, operation does not assume
+ * ownership of service
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_parent(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_svc *svc);
+
+ /**
+ * Gets parent. Parent of an operation is of type service.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to parent service, returns a reference, not a cloned
+ * copy
+ */
+ AXIS2_EXTERN struct axis2_svc *AXIS2_CALL
+ axis2_op_get_parent(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Sets operation QName.
+ * @param op pointer to operation as a void pointer, as this would be
+ * assigned to get_qname() method of base WSDL operation
+ * @param env pointer to environment struct
+ * @param qname pointer to QName, this method creates a clone of the
+ * QName
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_qname(axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_qname_t *qname);
+
+ /**
+ * Gets operation QName.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to QName, returns a reference, not a cloned copy
+ */
+ AXIS2_EXTERN const axis2_qname_t *AXIS2_CALL
+ axis2_op_get_qname(void *op,
+ const axis2_env_t *env);
+
+ /**
+ * Sets operation message exchange pattern (MEP).
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param pattern message exchange pattern string
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_msg_exchange_pattern(axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_char_t *pattern);
+
+ /**
+ * Gets operation message exchange pattern (MEP).
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return MEP string
+ */
+ AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+ axis2_op_get_msg_exchange_pattern(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Sets message receiver. message receiver is responsible for invoking
+ * the business logic associated with the operation.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param msg_recv pointer to message receiver, operation assumes
+ * ownership of message receiver
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_msg_recv(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_msg_recv *msg_recv);
+
+ /**
+ * Gets message receiver. message receiver is responsible for invoking
+ * the business logic associated with the operation.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to message receiver, returns a reference, not a
+ * cloned copy
+ */
+ AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL
+ axis2_op_get_msg_recv(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Gets style of operation. Style is that mentioned in WSDL, either
+ * RPC or document literal.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return string representing style
+ */
+ AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+ axis2_op_get_style(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Sets style of operation. Style is that mentioned in WSDL, either
+ * RPC or document literal.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param style string representing style
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
- struct axis2_op_ops
- {
- /**
- * Frees operation.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- free)(
- axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Frees operation given as a void pointer.
- * @param op pointer to operation as a void pointer
- * @param env pointer to environment struct
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- free_void_arg)(
- void *op,
- const axis2_env_t *env);
-
-
- /**
- * Adds a parameter to method.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param param pointer parameter to be added, operation assumes
- * ownership of parameter
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- add_param)(
- axis2_op_t *op,
- const axis2_env_t *env,
- axis2_param_t *param);
-
- /**
- * Gets named parameter.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param name name of parameter to be retrieved as a string
- * @return pointer to named parameter if exists, else NULL. Returns a
- * reference, not a cloned copy
- */
- axis2_param_t *(AXIS2_CALL *
- get_param)(
- const axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
- /**
- * Gets all parameters.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing all parameters, returns
- * a reference, not a cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_all_params)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Checks if the named parameter is locked.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param param_name name of the parameter to be checked
- * @return AXIS2_TRUE if named parameter is locked, else AXIS2_FALSE
- */
- axis2_bool_t (AXIS2_CALL *
- is_param_locked)(
- axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
- /**
- * Sets parent. Parent of an operation is of type service.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param svc pointer to parent service, operation does not assume
- * ownership of service
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_parent)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_svc *svc);
-
- /**
- * Gets parent. Parent of an operation is of type service.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to parent service, returns a reference, not a cloned
- * copy
- */
- struct axis2_svc *(AXIS2_CALL *
- get_parent)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Sets operation QName.
- * @param op pointer to operation as a void pointer, as this would be
- * assigned to get_qname() method of base WSDL operation
- * @param env pointer to environment struct
- * @param qname pointer to QName, this method creates a clone of the
- * QName
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_qname)(
- axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_qname_t *qname);
-
- /**
- * Gets operation QName.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to QName, returns a reference, not a cloned copy
- */
- const axis2_qname_t *(AXIS2_CALL *
- get_qname)(
- void *op,
- const axis2_env_t *env);
-
- /**
- * Sets operation message exchange pattern (MEP).
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param pattern message exchange pattern string
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_msg_exchange_pattern)(
- axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_char_t *pattern);
-
- /**
- * Gets operation message exchange pattern (MEP).
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return MEP string
- */
- const axis2_char_t *(AXIS2_CALL *
- get_msg_exchange_pattern)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Sets message receiver. message receiver is responsible for invoking
- * the business logic associated with the operation.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param msg_recv pointer to message receiver, operation assumes
- * ownership of message receiver
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_msg_recv)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_msg_recv *msg_recv);
-
- /**
- * Gets message receiver. message receiver is responsible for invoking
- * the business logic associated with the operation.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to message receiver, returns a reference, not a
- * cloned copy
- */
- struct axis2_msg_recv *(AXIS2_CALL *
- get_msg_recv)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Gets style of operation. Style is that mentioned in WSDL, either
- * RPC or document literal.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return string representing style
- */
- const axis2_char_t *(AXIS2_CALL *
- get_style)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Sets style of operation. Style is that mentioned in WSDL, either
- * RPC or document literal.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param style string representing style
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_style)(
- axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_char_t *style);
-
- /**
- * Engages given module to operation.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param module_desc pointer to module description, operation does not
- * assume ownership of struct
- * @param conf pointer to configuration, operation does not assume
- * ownership of configuration
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- engage_module)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_module_desc *module_desc,
- struct axis2_conf *conf);
-
- /**
- * Adds module description to engaged module list.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param module_dec pointer to module description, operation does not
- * assume ownership of struct
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- add_to_engaged_module_list)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_module_desc *module_dec);
-
- /**
- * Gets all modules associated to operation.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing module descriptions
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_all_modules)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Gets Axis specific MEP constant. This method simply maps the string
- * URI of the MEP to an integer.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return integer representing MEP
- */
- int (AXIS2_CALL *
- get_axis_specific_mep_const)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Gets fault in flow. Fault in flow is the list of phases invoked
- * when a fault happens along in path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing phases, returns a reference,
- * not a cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_fault_in_flow)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
-
- /**
- * Gets fault out flow. Fault out flow is the list of phases invoked
- * when a fault happens along out path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing phases, returns a reference,
- * not a cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_fault_out_flow)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Gets out flow. Out flow is the list of phases invoked
- * along out path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing phases, returns a reference,
- * not a cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_out_flow)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Gets in flow. In flow is the list of phases
- * invoked along in path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing phases, returns a reference,
- * not a cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_in_flow)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Sets fault in flow. Fault in flow is the list of phases invoked
- * when a fault happens along in path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param list pointer to array list containing phases, operation takes
- * over the ownership of list
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_fault_in_flow)(
- axis2_op_t *op,
- const axis2_env_t *env,
- axis2_array_list_t *list);
-
- /**
- * Sets fault out flow. Fault out flow is the list of phases invoked
- * when a fault happens along out path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param list pointer to array list containing phases, operation takes
- * over the ownership of list
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_fault_out_flow)(
- axis2_op_t *op,
- const axis2_env_t *env,
- axis2_array_list_t *list);
-
- /**
- * Sets out flow. Out flow is the list of phases invoked
- * along out path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param list pointer to array list containing phases, operation takes
- * over the ownership of list
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_out_flow)(
- axis2_op_t *op,
- const axis2_env_t *env,
- axis2_array_list_t *list);
- /**
- * Sets in flow. In flow is the list of phases
- * invoked along in path.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param list pointer to array list containing phases, operation takes
- * over the ownership of list
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_in_flow)(
- axis2_op_t *op,
- const axis2_env_t *env,
- axis2_array_list_t *list);
-
- /**
- * Adds given QName to module QName list.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param module_name pointer to module QName, QName would be cloned by
- * this method
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- add_module_qname)(
- axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_qname_t *module_qname);
-
- /**
- * Gets all module QNames as a list.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to array list containing module QNames,
- * returns a reference, not a cloned copy
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_all_module_qnames)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Finds operation context related to this operation using given message
- * context and service context. This method would create a new operation
- * context related to the operation, if one could not be found.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param msg_ctx pointer to message context
- * @param svc_ctx pointer to service context
- * @return pointer to operation context, returns
- * a reference, not a cloned copy
- */
- struct axis2_op_ctx *(AXIS2_CALL *
- find_op_ctx)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_msg_ctx *msg_ctx,
- struct axis2_svc_ctx *svc_ctx);
-
- /**
- * Finds operation context related to this operation using given message
- * context. This method will not create a new operation context if
- * an associated operation context could not be found.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param msg_ctx pointer to message context
- * @return pointer to operation context if found, else NULL. Returns
- * a reference, not a cloned copy
-
- */
- struct axis2_op_ctx *(AXIS2_CALL *
- find_existing_op_ctx)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_msg_ctx *msg_ctx);
-
- /**
- * Registers given operation context against this operation. Registration
- * happens within the given message context, as it is the message context
- * that captures the state information of a given invocation.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param msg_ctx pointer to message context
- * @param op_ctx pointer to operation context, operation does not assume
- * ownership of operation context
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- register_op_ctx)(
- axis2_op_t *op,
- const axis2_env_t *env,
- struct axis2_msg_ctx *msg_ctx,
- struct axis2_op_ctx *op_ctx);
-
- /**
- * Gets message with given label.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return pointer to message corresponding to given label, returns
- * a reference, not a cloned copy
- */
- struct axis2_msg *(AXIS2_CALL *
- get_msg)(
- const axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_char_t *label);
-
- /**
- * Adds given message with the given label.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param label label string
- * @param msg pointer to message
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- add_msg)(
- axis2_op_t *op,
- const axis2_env_t *env,
- const axis2_char_t *label,
- const struct axis2_msg *msg);
-
- /**
- * Checks if the operation is from a module.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * AXIS2_TRUE if the operation is from a module, else AXIS2_FALSE
- */
- axis2_bool_t (AXIS2_CALL *
- is_from_module)(
- const axis2_op_t *op,
- const axis2_env_t *env);
-
- /**
- * Set the wsamapping list.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @param mapping_list list of action mappings
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_wsamapping_list)(
- axis2_op_t *op,
- const axis2_env_t *env,
- axis2_array_list_t *mapping_list);
-
- /**
- * Get the wsamapping list.
- * @param op pointer to operation
- * @param env pointer to environment struct
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_array_list_t *(AXIS2_CALL *
- get_wsamapping_list)(
- axis2_op_t *op,
- const axis2_env_t *env);
- };
-
- /**
- * operation struct.
- */
- struct axis2_op
- {
- /** operations of operation struct */
- axis2_op_ops_t *ops;
- /** parameter container to hold operation related parameters */
- struct axis2_param_container *param_container;
- };
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_style(axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_char_t *style);
+
+ /**
+ * Engages given module to operation.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param module_desc pointer to module description, operation does not
+ * assume ownership of struct
+ * @param conf pointer to configuration, operation does not assume
+ * ownership of configuration
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_engage_module(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_module_desc *module_desc,
+ struct axis2_conf *conf);
+
+ /**
+ * Adds module description to engaged module list.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param module_dec pointer to module description, operation does not
+ * assume ownership of struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_add_to_engaged_module_list(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_module_desc *module_dec);
+
+ /**
+ * Gets all modules associated to operation.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing module descriptions
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_all_modules(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Gets Axis specific MEP constant. This method simply maps the string
+ * URI of the MEP to an integer.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return integer representing MEP
+ */
+ AXIS2_EXTERN int AXIS2_CALL
+ axis2_op_get_axis_specific_mep_const(axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Gets fault in flow. Fault in flow is the list of phases invoked
+ * when a fault happens along in path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing phases, returns a reference,
+ * not a cloned copy
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_fault_in_flow(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+
+ /**
+ * Gets fault out flow. Fault out flow is the list of phases invoked
+ * when a fault happens along out path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing phases, returns a reference,
+ * not a cloned copy
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_fault_out_flow(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Gets out flow. Out flow is the list of phases invoked
+ * along out path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing phases, returns a reference,
+ * not a cloned copy
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_out_flow(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Gets in flow. In flow is the list of phases
+ * invoked along in path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing phases, returns a reference,
+ * not a cloned copy
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_in_flow(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Sets fault in flow. Fault in flow is the list of phases invoked
+ * when a fault happens along in path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param list pointer to array list containing phases, operation takes
+ * over the ownership of list
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_fault_in_flow(axis2_op_t *op,
+ const axis2_env_t *env,
+ axis2_array_list_t *list);
+
+ /**
+ * Sets fault out flow. Fault out flow is the list of phases invoked
+ * when a fault happens along out path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param list pointer to array list containing phases, operation takes
+ * over the ownership of list
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_fault_out_flow(axis2_op_t *op,
+ const axis2_env_t *env,
+ axis2_array_list_t *list);
+
+ /**
+ * Sets out flow. Out flow is the list of phases invoked
+ * along out path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param list pointer to array list containing phases, operation takes
+ * over the ownership of list
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_out_flow(axis2_op_t *op,
+ const axis2_env_t *env,
+ axis2_array_list_t *list);
+
+ /**
+ * Sets in flow. In flow is the list of phases
+ * invoked along in path.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param list pointer to array list containing phases, operation takes
+ * over the ownership of list
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_in_flow(axis2_op_t *op,
+ const axis2_env_t *env,
+ axis2_array_list_t *list);
+
+ /**
+ * Adds given QName to module QName list.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param module_name pointer to module QName, QName would be cloned by
+ * this method
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_add_module_qname(axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_qname_t *module_qname);
+
+ /**
+ * Gets all module QNames as a list.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to array list containing module QNames,
+ * returns a reference, not a cloned copy
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_all_module_qnames(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Finds operation context related to this operation using given message
+ * context and service context. This method would create a new operation
+ * context related to the operation, if one could not be found.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param msg_ctx pointer to message context
+ * @param svc_ctx pointer to service context
+ * @return pointer to operation context, returns
+ * a reference, not a cloned copy
+ */
+ AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL
+ axis2_op_find_op_ctx(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_msg_ctx *msg_ctx,
+ struct axis2_svc_ctx *svc_ctx);
+
+ /**
+ * Finds operation context related to this operation using given message
+ * context. This method will not create a new operation context if
+ * an associated operation context could not be found.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param msg_ctx pointer to message context
+ * @return pointer to operation context if found, else NULL. Returns
+ * a reference, not a cloned copy
+
+ */
+ AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL
+ axis2_op_find_existing_op_ctx(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_msg_ctx *msg_ctx);
+
+ /**
+ * Registers given operation context against this operation. Registration
+ * happens within the given message context, as it is the message context
+ * that captures the state information of a given invocation.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param msg_ctx pointer to message context
+ * @param op_ctx pointer to operation context, operation does not assume
+ * ownership of operation context
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_register_op_ctx(axis2_op_t *op,
+ const axis2_env_t *env,
+ struct axis2_msg_ctx *msg_ctx,
+ struct axis2_op_ctx *op_ctx);
+
+ /**
+ * Gets message with given label.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return pointer to message corresponding to given label, returns
+ * a reference, not a cloned copy
+ */
+ AXIS2_EXTERN struct axis2_msg *AXIS2_CALL
+ axis2_op_get_msg(const axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_char_t *label);
+
+ /**
+ * Adds given message with the given label.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param label label string
+ * @param msg pointer to message
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_add_msg(axis2_op_t *op,
+ const axis2_env_t *env,
+ const axis2_char_t *label,
+ const struct axis2_msg *msg);
+
+ /**
+ * Checks if the operation is from a module.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * AXIS2_TRUE if the operation is from a module, else AXIS2_FALSE
+ */
+ AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+ axis2_op_is_from_module(const axis2_op_t *op,
+ const axis2_env_t *env);
+
+ /**
+ * Set the wsamapping list.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @param mapping_list list of action mappings
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_op_set_wsamapping_list(axis2_op_t *op,
+ const axis2_env_t *env,
+ axis2_array_list_t *mapping_list);
+
+ /**
+ * Get the wsamapping list.
+ * @param op pointer to operation
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
+ axis2_op_get_wsamapping_list(axis2_op_t *op,
+ const axis2_env_t *env);
+
+ AXIS2_EXTERN axis2_param_container_t *AXIS2_CALL
+ axis2_op_get_param_container(const axis2_op_t *op,
+ const axis2_env_t *env);
/**
* Creates operation struct.
@@ -615,8 +562,7 @@
* @return pointer to newly created operation
*/
AXIS2_EXTERN axis2_op_t *AXIS2_CALL
- axis2_op_create(
- const axis2_env_t *env);
+ axis2_op_create(const axis2_env_t *env);
/**
* Creates operation struct for an operation defined in a module.
@@ -624,8 +570,7 @@
* @return pointer to newly created operation
*/
AXIS2_EXTERN axis2_op_t *AXIS2_CALL
- axis2_op_create_from_module(
- const axis2_env_t *env);
+ axis2_op_create_from_module(const axis2_env_t *env);
/**
* Creates operation struct with given QName.
@@ -634,8 +579,7 @@
* @return pointer to newly created operation
*/
AXIS2_EXTERN axis2_op_t *AXIS2_CALL
- axis2_op_create_with_qname(
- const axis2_env_t *env,
+ axis2_op_create_with_qname(const axis2_env_t *env,
const axis2_qname_t *name);
/**
@@ -646,216 +590,215 @@
* @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
- axis2_op_free_void_arg(
- void *op,
+ axis2_op_free_void_arg(void *op,
const axis2_env_t *env);
/** Frees operation.
@sa axis2_op_ops#free */
#define AXIS2_OP_FREE(op, env) \
- ((op)->ops->free (op, env))
+ axis2_op_free (op, env)
/** Adds parameter.
@sa axis2_op_ops#add_param */
#define AXIS2_OP_ADD_PARAM(op, env, param) \
- ((op)->ops->add_param (op, env, param))
+ axis2_op_add_param (op, env, param)
/** Gets named parameter.
@sa axis2_op_ops#get_param */
#define AXIS2_OP_GET_PARAM(op, env, key) \
- ((op)->ops->get_param (op, env, key))
+ axis2_op_get_param (op, env, key)
/** Gets all the parameters as a list.
@sa axis2_op_ops#get_all_params */
#define AXIS2_OP_GET_ALL_PARAMS(op, env) \
- ((op)->ops->get_all_params (op, env))
+ axis2_op_get_all_params (op, env)
/** Checks if the named parameter is locked.
@sa axis2_op_ops#is_param_locked */
#define AXIS2_OP_IS_PARAM_LOCKED(op, env, param_name) \
- ((op)->ops->is_param_locked(op, env, param_name))
+ axis2_op_is_param_locked(op, env, param_name)
/** Sets parent service.
@sa axis2_op_ops#set_parent */
#define AXIS2_OP_SET_PARENT(op, env, service_desc) \
- ((op)->ops->set_parent (op, env, service_desc))
+ axis2_op_set_parent (op, env, service_desc)
/** Gets parent service.
@sa axis2_op_ops#get_parent */
#define AXIS2_OP_GET_PARENT(op, env) \
- ((op)->ops->get_parent (op, env))
+ axis2_op_get_parent (op, env)
/** Sets message receiver.
@sa axis2_op_ops#set_msg_recv */
#define AXIS2_OP_SET_MSG_RECV(op, env, msg_recv) \
- ((op)->ops->set_msg_recv (op, env, msg_recv))
+ axis2_op_set_msg_recv (op, env, msg_recv)
/** Gets message receiver.
@sa axis2_op_ops#get_msg_recv */
#define AXIS2_OP_GET_MSG_RECV(op, env) \
- ((op)->ops->get_msg_recv (op, env))
+ axis2_op_get_msg_recv (op, env)
/** Sets QName.
@sa axis2_op_ops#set_qname */
#define AXIS2_OP_SET_QNAME(op, env, qname) \
- ((op)->ops->set_qname (op, env, qname))
+ axis2_op_set_qname (op, env, qname)
/** Gets QName.
@sa axis2_op_ops#get_qname */
#define AXIS2_OP_GET_QNAME(op, env) \
- (((axis2_op_t *) op)->ops->get_qname (op, env))
+ axis2_op_get_qname (op, env)
/** Sets message exchange pattern.
@sa axis2_op_ops#set_msg_exchange_pattern */
#define AXIS2_OP_SET_MSG_EXCHANGE_PATTERN(op , env, \
msg_exchange_pattern) \
- ((op)->ops->set_msg_exchange_pattern (op, env, \
- msg_exchange_pattern))
+ axis2_op_set_msg_exchange_pattern (op, env, \
+ msg_exchange_pattern)
/** Gets message exchange pattern.
@sa axis2_op_ops#get_msg_exchange_pattern */
#define AXIS2_OP_GET_MSG_EXCHANGE_PATTERN(op, env) \
- ((op)->ops->get_msg_exchange_pattern (op, env))
+ axis2_op_get_msg_exchange_pattern (op, env)
/** Gets style of operation.
@sa axis2_op_ops#get_style */
#define AXIS2_OP_GET_STYLE(op, env) \
- ((op)->ops->get_style (op, env))
+ axis2_op_get_style (op, env)
/** Sets style of operation.
@sa axis2_op_ops#set_style */
#define AXIS2_OP_SET_STYLE(op, env, style) \
- ((op)->ops->set_style (op, env, style))
+ axis2_op_set_style (op, env, style)
/** Engages the given module.
@sa axis2_op_ops#engage_module */
#define AXIS2_OP_ENGAGE_MODULE(op, env, moduleref, conf) \
- ((op)->ops->engage_module (op, env, moduleref, conf))
+ axis2_op_engage_module (op, env, moduleref, conf)
/** Adds the named module to engaged module list.
@sa axis2_op_ops#add_to_engaged_module_list */
#define AXIS2_OP_ADD_TO_ENGAGED_MODULE_LIST(op, env, module_name) \
- ((op)->ops->add_to_engaged_module_list (op, env, module_name))
+ axis2_op_add_to_engaged_module_list (op, env, module_name)
/** Gets all modules.
@sa axis2_op_ops#get_all_modules */
#define AXIS2_OP_GET_ALL_MODULES(op, env) \
- ((op)->ops->get_all_modules (op, env))
+ axis2_op_get_all_modules (op, env)
/** Gets Axis specific MEP constant.
@sa axis2_op_ops#get_axis_specific_mep_const */
#define AXIS2_OP_GET_AXIS_SPECIFIC_MEP_CONST(op, env) \
- ((op)->ops->get_axis_specific_mep_const (op, env))
+ axis2_op_get_axis_specific_mep_const (op, env)
/** Gets fault in flow.
@sa axis2_op_ops#get_fault_in_flow */
#define AXIS2_OP_GET_FAULT_IN_FLOW(op, env) \
- ((op)->ops->get_fault_in_flow (op, env))
+ axis2_op_get_fault_in_flow (op, env)
/** Gets fault out flow.
@sa axis2_op_ops#get_fault_out_flow */
#define AXIS2_OP_GET_FAULT_OUT_FLOW(op, env) \
- ((op)->ops->get_fault_out_flow (op, env))
+ axis2_op_get_fault_out_flow (op, env)
/** Gets out flow.
@sa axis2_op_ops#get_out_flow */
#define AXIS2_OP_GET_OUT_FLOW(op, env) \
- ((op)->ops->get_out_flow (op, env))
+ axis2_op_get_out_flow (op, env)
/** Gets in flow.
@sa axis2_op_ops#get_in_flow */
#define AXIS2_OP_GET_IN_FLOW(op, env) \
- ((op)->ops->get_in_flow (op, env))
+ axis2_op_get_in_flow (op, env)
/** Sets fault in flow.
@sa axis2_op_ops#set_fault_in_flow */
#define AXIS2_OP_SET_FAULT_IN_FLOW(op, env, list) \
- ((op)->ops->set_fault_in_flow (op, env, list))
+ axis2_op_set_fault_in_flow (op, env, list)
/** Sets fault out flow.
@sa axis2_op_ops#set_fault_out_flow */
#define AXIS2_OP_SET_FAULT_OUT_FLOW(op, env, list) \
- ((op)->ops->set_fault_out_flow (op, env, list))
+ axis2_op_set_fault_out_flow (op, env, list)
/** Sets out flow.
@sa axis2_op_ops#set_out_flow */
#define AXIS2_OP_SET_OUT_FLOW(op, env, list) \
- ((op)->ops->set_out_flow (op, env, list))
+ axis2_op_set_out_flow (op, env, list)
/** Sets in flow.
@sa axis2_op_ops#set_in_flow */
#define AXIS2_OP_SET_IN_FLOW(op, env, list) \
- ((op)->ops->set_in_flow (op, env, list))
+ axis2_op_set_in_flow (op, env, list)
/** Adds given module QName to module qname list.
@sa axis2_op_ops#add_module_qname */
#define AXIS2_OP_ADD_MODULE_QNAME(op, env, module_name) \
- ((op)->ops->add_module_qname (op, env, module_name))
+ axis2_op_add_module_qname (op, env, module_name)
/** Gets all module descriptions.
@sa axis2_op_ops#get_all_module_qnames */
#define AXIS2_OP_GET_ALL_MODULE_QNAMES(op, env) \
- ((op)->ops->get_all_module_qnames (op, env))
+ axis2_op_get_all_module_qnames (op, env)
/** Adds in fault.
@sa axis2_op_ops#add_in_fault */
#define AXIS2_OP_ADD_IN_FAULT(op, env, in_fault) \
- ((op)->ops->add_in_fault (op, env, in_fault))
+ axis2_op_add_in_fault (op, env, in_fault)
/** Adds out fault.
@sa axis2_op_ops#add_out_fault */
#define AXIS2_OP_ADD_OUT_FAULT(op, env, out_fault) \
- ((op)->ops->add_out_fault (op, env, out_fault))
+ axis2_op_add_out_fault (op, env, out_fault)
/** Adds feature.
@sa axis2_op_ops#add_feature */
#define AXIS2_OP_ADD_FEATURE(op, env, feature) \
- ((op)->ops->add_feature (op, env, feature))
+ axis2_op_add_feature (op, env, feature)
/** Gets all properties.
@sa axis2_op_ops#get_all_properties */
#define AXIS2_OP_GET_ALL_PROPERTIES(op, env) \
- ((op)->ops->get_all_properties (op, env))
+ axis2_op_get_all_properties (op, env)
/** Finds operation context related to this operation.
@sa axis2_op_ops#find_op_ctx */
#define AXIS2_OP_FIND_OP_CTX(op, env, msg_ctx, svc_ctx) \
- ((op)->ops->find_op_ctx (op, env, msg_ctx, svc_ctx))
+ axis2_op_find_op_ctx (op, env, msg_ctx, svc_ctx)
/** Finds existing operation context related to this operation.
@sa axis2_op_ops#find_existing_op_ctx */
#define AXIS2_OP_FIND_FOR_EXISTING_OP_CTX(op, env, wsdl_op) \
- ((op)->ops->find_existing_op_ctx (op, env, wsdl_op))
+ axis2_op_find_existing_op_ctx (op, env, wsdl_op)
/** Registers given operation context against this operation.
@sa axis2_op_ops#_register_op_ctx */
#define AXIS2_OP_REGISTER_OP_CTX(op, env, msg_ctx, wsdl_op) \
- ((op)->ops->register_op_ctx (op, env, msg_ctx, wsdl_op))
+ axis2_op_register_op_ctx (op, env, msg_ctx, wsdl_op)
/** Gets message corresponding to given label.
@sa axis2_op_ops#get_msg */
#define AXIS2_OP_GET_MSG(op, env, label) \
- ((op)->ops->get_msg(op, env, label))
+ axis2_op_get_msg(op, env, label)
/** Adds message with given label.
@sa axis2_op_ops#add_msg */
#define AXIS2_OP_ADD_MSG(op, env, label, msg) \
- ((op)->ops->add_msg(op, env, label, msg))
+ axis2_op_add_msg(op, env, label, msg)
/** Checks is the operation is from a module.
@sa axis2_op_ops#is_from_module */
#define AXIS2_OP_IS_FROM_MODULE(op, env) \
- ((op)->ops->is_from_module(op, env))
+ axis2_op_is_from_module(op, env)
/** Set wsa mapping list.
@sa axis2_op_ops#set_wsamapping_list */
#define AXIS2_OP_SET_WSAMAPPING_LIST(op, env, mapping_list) \
- ((op)->ops->set_wsamapping_list(op, env, mapping_list))
+ axis2_op_set_wsamapping_list(op, env, mapping_list)
/** Get wsa mapping list.
@sa axis2_op_ops#get_wsamapping_list */
#define AXIS2_OP_GET_WSAMAPPING_LIST(op, env) \
- ((op)->ops->get_wsamapping_list(op, env))
+ axis2_op_get_wsamapping_list(op, env)
/** @} */
#ifdef __cplusplus
Modified: webservices/axis2/trunk/c/include/axis2_phase_rule.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phase_rule.h?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_phase_rule.h (original)
+++ webservices/axis2/trunk/c/include/axis2_phase_rule.h Sun Mar 4 20:11:56 2007
@@ -44,177 +44,144 @@
/** Type name for struct axis2_phase_rule */
typedef struct axis2_phase_rule axis2_phase_rule_t;
- /** Type name for struct axis2_phase_rule_ops */
- typedef struct axis2_phase_rule_ops axis2_phase_rule_ops_t;
+ /**
+ * Gets the name of the handler before which the handler associated with
+ * this rule should be placed.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return name of handler before which the handler should be placed
+ */
+ AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+ axis2_phase_rule_get_before(const axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
+
+ /**
+ * Sets the name of the handler before which the handler associated with
+ * this rule should be placed.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @param before name of handler before which the handler should be placed
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_phase_rule_set_before(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ const axis2_char_t *before);
+
+ /**
+ * Gets the name of the handler after which the handler associated with
+ * this rule should be placed.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return name of handler after which the handler should be placed
+ */
+ AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+ axis2_phase_rule_get_after(const axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
+
+ /**
+ * Sets the name of the handler after which the handler associated with
+ * this rule should be placed.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @param after name of handler after which the handler should be placed
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_phase_rule_set_after(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ const axis2_char_t *after);
/**
- * phase rule ops struct.
- * Encapsulator struct for ops of axis2_phase_rule.
+ * Gets name.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return name string
*/
- struct axis2_phase_rule_ops
- {
- /**
- * Gets the name of the handler before which the handler associated with
- * this rule should be placed.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return name of handler before which the handler should be placed
- */
- const axis2_char_t *(AXIS2_CALL *
- get_before)(
- const axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- /**
- * Sets the name of the handler before which the handler associated with
- * this rule should be placed.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @param before name of handler before which the handler should be placed
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_before)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env,
- const axis2_char_t *before);
-
- /**
- * Gets the name of the handler after which the handler associated with
- * this rule should be placed.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return name of handler after which the handler should be placed
- */
- const axis2_char_t *(AXIS2_CALL *
- get_after)(
- const axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- /**
- * Sets the name of the handler after which the handler associated with
- * this rule should be placed.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @param after name of handler after which the handler should be placed
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_after)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env,
- const axis2_char_t *after);
-
- /**
- * Gets name.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return name string
- */
- const axis2_char_t *(AXIS2_CALL *
- get_name)(
- const axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- /**
- * Sets name.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @param name name string
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_name)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
- /**
- * Checks if the handler is the first in phase.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return AXIS2_TRUE if the handler associated with this rule is the
- * first in phase, else AXIS2_FALSE
- */
- axis2_bool_t (AXIS2_CALL *
- is_first)(
- const axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- /**
- * Sets handler to be the first in phase.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @param first AXIS2_TRUE if the handler associated with this rule is the
- * first in phase, else AXIS2_FALSE
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_first)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env,
- axis2_bool_t first);
-
- /**
- * Checks if the handler is the last in phase.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return AXIS2_TRUE if the handler associated with this rule is the
- * last in phase, else AXIS2_FALSE
- */
- axis2_bool_t (AXIS2_CALL *
- is_last)(
- const axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- /**
- * Sets handler to be the last in phase.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @param last AXIS2_TRUE if the handler associated with this rule is the
- * last in phase, else AXIS2_FALSE
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- set_last)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env,
- axis2_bool_t last);
-
- /**
- * Frees phase rule.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
- */
- axis2_status_t (AXIS2_CALL *
- free)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- /**
- * Clones phase rule.
- * @param phase_rule pointer to phase rule
- * @param env pointer to environment struct
- * @return pointer to newly cloned phase rule
- */
- axis2_phase_rule_t *(AXIS2_CALL *
- clone)(
- axis2_phase_rule_t *phase_rule,
- const axis2_env_t *env);
-
- };
-
- /**
- * phase rule struct.
- */
- struct axis2_phase_rule
- {
- /** phase rule related ops */
- axis2_phase_rule_ops_t *ops;
- };
+ AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
+ axis2_phase_rule_get_name(const axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
+ /**
+ * Sets name.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @param name name string
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_phase_rule_set_name(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ const axis2_char_t *name);
+
+ /**
+ * Checks if the handler is the first in phase.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return AXIS2_TRUE if the handler associated with this rule is the
+ * first in phase, else AXIS2_FALSE
+ */
+ AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+ axis2_phase_rule_is_first(const axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
+
+ /**
+ * Sets handler to be the first in phase.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @param first AXIS2_TRUE if the handler associated with this rule is the
+ * first in phase, else AXIS2_FALSE
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_phase_rule_set_first(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ axis2_bool_t first);
+
+ /**
+ * Checks if the handler is the last in phase.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return AXIS2_TRUE if the handler associated with this rule is the
+ * last in phase, else AXIS2_FALSE
+ */
+ AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+ axis2_phase_rule_is_last(const axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
+
+ /**
+ * Sets handler to be the last in phase.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @param last AXIS2_TRUE if the handler associated with this rule is the
+ * last in phase, else AXIS2_FALSE
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_phase_rule_set_last(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ axis2_bool_t last);
+
+ /**
+ * Frees phase rule.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
+ */
+ AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ axis2_phase_rule_free(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
+
+ /**
+ * Clones phase rule.
+ * @param phase_rule pointer to phase rule
+ * @param env pointer to environment struct
+ * @return pointer to newly cloned phase rule
+ */
+ AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
+ axis2_phase_rule_clone(axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env);
/**
* Creates a phase rule struct instance.
@@ -223,73 +190,60 @@
* @return pointer to newly created phase rule
*/
AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
- axis2_phase_rule_create(
- const axis2_env_t *env,
+ axis2_phase_rule_create(const axis2_env_t *env,
const axis2_char_t *name);
/** Gets name of the handler before which the handler associated with this rule
- is to be placed.
- @sa axis2_phase_rule_ops#get_before */
+ is to be placed. */
#define AXIS2_PHASE_RULE_GET_BEFORE(phase_rule, env) \
- ((phase_rule)->ops->get_before(phase_rule, env))
+ axis2_phase_rule_get_before(phase_rule, env)
/** Sets name of the handler before which the handler associated with this rule
- is to be placed.
- @sa axis2_phase_rule_ops#set_before */
+ is to be placed. */
#define AXIS2_PHASE_RULE_SET_BEFORE(phase_rule, env, before) \
- ((phase_rule)->ops->set_before(phase_rule, env, before))
+ axis2_phase_rule_set_before(phase_rule, env, before)
/** Gets name of the handler after which the handler associated with this rule
- is to be placed.
- @sa axis2_phase_rule_ops#get_after */
+ is to be placed. */
#define AXIS2_PHASE_RULE_GET_AFTER(phase_rule, env) \
- ((phase_rule)->ops->get_after(phase_rule, env))
+ axis2_phase_rule_get_after(phase_rule, env)
/** Sets name of the handler after which the handler associated with this rule
- is to be placed.
- @sa axis2_phase_rule_ops#set_after */
+ is to be placed. */
#define AXIS2_PHASE_RULE_SET_AFTER(phase_rule, env, after) \
- ((phase_rule)->ops->set_after(phase_rule, env, after))
+ axis2_phase_rule_set_after(phase_rule, env, after)
-/** Gets name.
- @sa axis2_phase_rule_ops#get_name */
+/** Gets name. */
#define AXIS2_PHASE_RULE_GET_NAME(phase_rule, env) \
- ((phase_rule)->ops->get_name(phase_rule, env))
+ axis2_phase_rule_get_name(phase_rule, env)
-/** Sets name.
- @sa axis2_phase_rule_ops#set_name */
+/** Sets name. */
#define AXIS2_PHASE_RULE_SET_NAME(phase_rule, env, name)\
- ((phase_rule)->ops->set_name(phase_rule, env, name))
+ axis2_phase_rule_set_name(phase_rule, env, name)
-/** Checks if the associated handler is the first in phase.
- @sa axis2_phase_rule_ops#is_first */
+/** Checks if the associated handler is the first in phase. */
#define AXIS2_PHASE_RULE_IS_FIRST(phase_rule, env) \
- ((phase_rule)->ops->is_first(phase_rule, env))
+ axis2_phase_rule_is_first(phase_rule, env)
-/** Sets the associated handler to be the first in phase.
- @sa axis2_phase_rule_ops#set_first */
+/** Sets the associated handler to be the first in phase. */
#define AXIS2_PHASE_RULE_SET_FIRST(phase_rule, env, first) \
- ((phase_rule)->ops->set_first(phase_rule, env, first))
+ axis2_phase_rule_set_first(phase_rule, env, first)
-/** Checks if the associated handler is the last in phase.
- @sa axis2_phase_rule_ops#is_last */
+/** Checks if the associated handler is the last in phase. */
#define AXIS2_PHASE_RULE_IS_LAST(phase_rule, env) \
- ((phase_rule)->ops->is_last(phase_rule, env))
+ axis2_phase_rule_is_last(phase_rule, env)
-/** Sets the associated handler to be the last in phase.
- @sa axis2_phase_rule_ops#set_last */
+/** Sets the associated handler to be the last in phase. */
#define AXIS2_PHASE_RULE_SET_LAST(phase_rule, env, last) \
- ((phase_rule)->ops->set_last(phase_rule, env, last))
+ axis2_phase_rule_set_last(phase_rule, env, last)
-/** Frees phase rule.
- @sa axis2_phase_rule_ops#free */
+/** Frees phase rule. */
#define AXIS2_PHASE_RULE_FREE(phase_rule, env) \
- ((phase_rule)->ops->free(phase_rule, env))
+ axis2_phase_rule_free(phase_rule, env)
-/** Clones given phase rule.
- @sa axis2_phase_rule_ops#clone */
+/** Clones given phase rule. */
#define AXIS2_PHASE_RULE_CLONE(phase_rule, env) \
- ((phase_rule)->ops->clone(phase_rule, env))
+ axis2_phase_rule_clone(phase_rule, env)
/** @} */
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org