Return-Path: Delivered-To: apmail-ws-axis-dev-archive@www.apache.org Received: (qmail 31601 invoked from network); 4 Jun 2006 03:12:17 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 4 Jun 2006 03:12:17 -0000 Received: (qmail 2986 invoked by uid 500); 4 Jun 2006 03:12:14 -0000 Delivered-To: apmail-ws-axis-dev-archive@ws.apache.org Received: (qmail 1958 invoked by uid 500); 4 Jun 2006 03:12:09 -0000 Mailing-List: contact axis-cvs-help@ws.apache.org; run by ezmlm Precedence: bulk list-help: list-unsubscribe: List-Post: List-Id: Delivered-To: mailing list axis-cvs@ws.apache.org Received: (qmail 1846 invoked by uid 500); 4 Jun 2006 03:12:08 -0000 Delivered-To: apmail-ws-axis2-cvs@ws.apache.org Received: (qmail 1830 invoked by uid 99); 4 Jun 2006 03:12:08 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 03 Jun 2006 20:12:08 -0700 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [140.211.166.113] (HELO eris.apache.org) (140.211.166.113) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 03 Jun 2006 20:12:02 -0700 Received: by eris.apache.org (Postfix, from userid 65534) id BE8701A984E; Sat, 3 Jun 2006 20:11:41 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r411506 [5/27] - in /webservices/axis2/trunk/c: axiom/include/ axiom/src/attachments/ axiom/src/om/ axiom/src/parser/guththila/ axiom/src/parser/libxml2/ axiom/src/soap/ axiom/test/om/ axiom/test/soap/ guththila/src/ include/ modules/core/c... Date: Sun, 04 Jun 2006 03:09:41 -0000 To: axis2-cvs@ws.apache.org From: samisa@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20060604031141.BE8701A984E@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Modified: webservices/axis2/trunk/c/include/axis2_op.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_op.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_op.h (original) +++ webservices/axis2/trunk/c/include/axis2_op.h Sat Jun 3 20:09:08 2006 @@ -72,18 +72,18 @@ { /** * De-allocate memory - * @return status code - */ - axis2_status_t (AXIS2_CALL * + * @return status code + */ + axis2_status_t (AXIS2_CALL * free) (axis2_op_t *op, const axis2_env_t *env); /** * De-allocate memory * @param void op to be freed - * @return status code - */ - axis2_status_t (AXIS2_CALL * + * @return status code + */ + axis2_status_t (AXIS2_CALL * free_void_arg) (void *op, const axis2_env_t *env); @@ -93,7 +93,7 @@ * * @param param Parameter that will be added */ - axis2_status_t (AXIS2_CALL * + axis2_status_t (AXIS2_CALL * add_param)(axis2_op_t *op, const axis2_env_t *env, axis2_param_t *param); @@ -103,30 +103,30 @@ * * @param name Name of the parameter */ - axis2_param_t *(AXIS2_CALL * + axis2_param_t *(AXIS2_CALL * get_param)(axis2_op_t *op, const axis2_env_t *env, axis2_char_t *name); - axis2_array_list_t *(AXIS2_CALL * + axis2_array_list_t *(AXIS2_CALL * get_params) (axis2_op_t *op, const axis2_env_t *env); /** * To check whether a given paramter is locked */ - axis2_bool_t (AXIS2_CALL * + axis2_bool_t (AXIS2_CALL * is_param_locked) (axis2_op_t *op, const axis2_env_t *env, axis2_char_t *param_name); - - axis2_status_t (AXIS2_CALL * + + axis2_status_t (AXIS2_CALL * set_parent) (axis2_op_t *op, const axis2_env_t *env, struct axis2_svc *service_desc); - struct axis2_svc *(AXIS2_CALL * + struct axis2_svc *(AXIS2_CALL * get_parent) (axis2_op_t *op, const axis2_env_t *env); @@ -135,25 +135,25 @@ const axis2_env_t *env, axis2_qname_t *qname); - axis2_qname_t *(AXIS2_CALL * + axis2_qname_t *(AXIS2_CALL * get_qname) (void *op, const axis2_env_t *env); - axis2_status_t (AXIS2_CALL * + axis2_status_t (AXIS2_CALL * set_msg_exchange_pattern) (axis2_op_t *op, const axis2_env_t *env, axis2_char_t *pattern); - axis2_char_t *(AXIS2_CALL * + axis2_char_t *(AXIS2_CALL * get_msg_exchange_pattern) (axis2_op_t *op, const axis2_env_t *env); - axis2_status_t (AXIS2_CALL * + axis2_status_t (AXIS2_CALL * set_msg_recv) (axis2_op_t *op, const axis2_env_t *env, struct axis2_msg_recv *msg_recv); - struct axis2_msg_recv *(AXIS2_CALL * + struct axis2_msg_recv *(AXIS2_CALL * get_msg_recv) (axis2_op_t *op, const axis2_env_t *env); @@ -224,37 +224,37 @@ */ axis2_status_t (AXIS2_CALL * set_phases_in_fault_flow) (axis2_op_t *op, - const axis2_env_t *env, - axis2_array_list_t *list); + const axis2_env_t *env, + axis2_array_list_t *list); /** * @param list */ axis2_status_t (AXIS2_CALL * set_phases_out_fault_flow) (axis2_op_t *op, - const axis2_env_t *env, - axis2_array_list_t *list); + const axis2_env_t *env, + axis2_array_list_t *list); /** * @param list */ axis2_status_t (AXIS2_CALL * set_phases_outflow) (axis2_op_t *op, - const axis2_env_t *env, - axis2_array_list_t *list); + const axis2_env_t *env, + axis2_array_list_t *list); /** * @param list */ axis2_status_t (AXIS2_CALL * set_remaining_phases_inflow) (axis2_op_t *op, - const axis2_env_t *env, - axis2_array_list_t *list); + const axis2_env_t *env, + axis2_array_list_t *list); axis2_status_t (AXIS2_CALL * add_module) (axis2_op_t *op, - const axis2_env_t *env, - axis2_qname_t *module_name); + const axis2_env_t *env, + axis2_qname_t *module_name); axis2_array_list_t *(AXIS2_CALL * get_module_refs) (axis2_op_t *op, @@ -365,9 +365,9 @@ */ 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); + const axis2_env_t *env, + struct axis2_msg_ctx *msg_ctx, + struct axis2_svc_ctx *svc_ctx); /** * This will not create a new op context if there is no one already. @@ -377,24 +377,24 @@ */ struct axis2_op_ctx *(AXIS2_CALL * find_for_existing_op_ctx) (axis2_op_t *op, - const axis2_env_t *env, - struct axis2_msg_ctx *msg_ctx); + const axis2_env_t *env, + struct axis2_msg_ctx *msg_ctx); 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); + const axis2_env_t *env, + struct axis2_msg_ctx *msg_ctx, + struct axis2_op_ctx *op_ctx); }; /** * @brief Operaton struct - * Axis2 Operation + * Axis2 Operation */ AXIS2_DECLARE_DATA struct axis2_op { axis2_wsdl_op_t base; - axis2_op_ops_t *ops; + axis2_op_ops_t *ops; struct axis2_param_container *param_container; }; @@ -433,13 +433,13 @@ ((op)->ops->free (op, env)) #define AXIS2_OP_ADD_PARAM(op, env, param) \ - ((op)->ops->add_param (op, env, param)) + ((op)->ops->add_param (op, env, param)) #define AXIS2_OP_GET_PARAM(op, env, key) \ - ((op)->ops->get_param (op, env, key)) + ((op)->ops->get_param (op, env, key)) #define AXIS2_OP_GET_PARAMS(op, env) \ - ((op)->ops->get_params (op, env)) + ((op)->ops->get_params (op, env)) #define AXIS2_OP_IS_PARAM_LOCKED(op, env, param_name) \ ((op)->ops->is_param_locked(op, env, param_name)) @@ -448,139 +448,139 @@ ((op)->ops->set_parent (op, env, service_desc)) #define AXIS2_OP_GET_PARENT(op, env) \ - ((op)->ops->get_parent (op, env)) + ((op)->ops->get_parent (op, env)) #define AXIS2_OP_SET_MSG_RECEIVER(op, env, msg_recv) \ ((op)->ops->set_msg_recv (op, env, msg_recv)) #define AXIS2_OP_GET_MSG_RECEIVER(op, env) \ - ((op)->ops->get_msg_recv (op, env)) + ((op)->ops->get_msg_recv (op, env)) #define AXIS2_OP_SET_QNAME(op, env, qname) \ - ((op)->ops->set_qname (op, env, qname)) + ((op)->ops->set_qname (op, env, qname)) #define AXIS2_OP_GET_QNAME(op, env) \ - (((axis2_op_t *) op)->ops->get_qname (op, env)) + (((axis2_op_t *) op)->ops->get_qname (op, env)) #define AXIS2_OP_SET_MSG_EXCHANGE_PATTERN(op , env, \ msg_exchange_pattern) \ - ((op)->ops->set_msg_exchange_pattern (op, env, \ + ((op)->ops->set_msg_exchange_pattern (op, env, \ msg_exchange_pattern)) #define AXIS2_OP_GET_MSG_EXCHANGE_PATTERN(op, env) \ - ((op)->ops->get_msg_exchange_pattern (op, env)) + ((op)->ops->get_msg_exchange_pattern (op, env)) #define AXIS2_OP_GET_STYLE(op, env) \ - ((op)->ops->get_style (op, env)) + ((op)->ops->get_style (op, env)) #define AXIS2_OP_SET_STYLE(op, env, style) \ - ((op)->ops->set_style (op, env, style)) + ((op)->ops->set_style (op, env, style)) #define AXIS2_OP_ENGAGE_MODULE(op, env, moduleref) \ - ((op)->ops->engage_module (op, env, moduleref)) + ((op)->ops->engage_module (op, env, moduleref)) #define AXIS2_OP_ADD_TO_ENGAGE_MODULE_LIST(op, env, module_name) \ - ((op)->ops->add_to_engage_module_list (op, env, module_name)) + ((op)->ops->add_to_engage_module_list (op, env, module_name)) #define AXIS2_OP_GET_MODULES(op, env) \ - ((op)->ops->get_modules (op, env)) + ((op)->ops->get_modules (op, env)) #define AXIS2_OP_GET_AXIS_SPECIFIC_MEP_CONST(op, env) \ - ((op)->ops->get_axis_specific_mep_const (op, env)) + ((op)->ops->get_axis_specific_mep_const (op, env)) #define AXIS2_OP_GET_PHASES_IN_FAULT_FLOW(op, env) \ - ((op)->ops->get_phases_in_fault_flow (op, env)) + ((op)->ops->get_phases_in_fault_flow (op, env)) #define AXIS2_OP_GET_PHASES_OUT_FAULT_FLOW(op, env) \ - ((op)->ops->get_phases_out_fault_flow (op, env)) + ((op)->ops->get_phases_out_fault_flow (op, env)) #define AXIS2_OP_GET_PHASES_OUTFLOW(op, env) \ - ((op)->ops->get_phases_outflow (op, env)) + ((op)->ops->get_phases_outflow (op, env)) #define AXIS2_OP_GET_REMAINING_PHASES_INFLOW(op, env) \ - ((op)->ops->get_remaining_phases_inflow (op, env)) + ((op)->ops->get_remaining_phases_inflow (op, env)) #define AXIS2_OP_SET_PHASES_IN_FAULT_FLOW(op, env, list) \ - ((op)->ops->set_phases_in_fault_flow (op, env, list)) + ((op)->ops->set_phases_in_fault_flow (op, env, list)) #define AXIS2_OP_SET_PHASES_OUT_FAULT_FLOW(op, env, list) \ - ((op)->ops->set_phases_out_fault_flow (op, env, list)) + ((op)->ops->set_phases_out_fault_flow (op, env, list)) #define AXIS2_OP_SET_PHASES_OUTFLOW(op, env, list) \ - ((op)->ops->set_phases_outflow (op, env, list)) + ((op)->ops->set_phases_outflow (op, env, list)) #define AXIS2_OP_SET_REMAINING_PHASES_INFLOW(op, env, list) \ - ((op)->ops->set_remaining_phases_inflow (op, env, list)) + ((op)->ops->set_remaining_phases_inflow (op, env, list)) #define AXIS2_OP_ADD_MODULE(op, env, module_name) \ - ((op)->ops->add_module (op, env, module_name)) + ((op)->ops->add_module (op, env, module_name)) #define AXIS2_OP_GET_MODULE_REFS(op, env) \ - ((op)->ops->get_module_refs (op, env)) + ((op)->ops->get_module_refs (op, env)) #define AXIS2_OP_GET_IN_FAULTS(op, env) \ - ((op)->ops->get_in_faults (op, env)) + ((op)->ops->get_in_faults (op, env)) #define AXIS2_OP_SET_IN_FAULTS(op, env) \ - ((op)->ops->set_in_faults (op, env, in_faults)) + ((op)->ops->set_in_faults (op, env, in_faults)) #define AXIS2_OP_GET_INPUT_MSG(op, env) \ - ((op)->ops->get_input_msg (op, env)) + ((op)->ops->get_input_msg (op, env)) #define AXIS2_OP_SET_INPUT_MSG(op, env) \ - ((op)->ops->set_input_msg (op, env, input_msg)) + ((op)->ops->set_input_msg (op, env, input_msg)) #define AXIS2_OP_GET_OUT_FAULTS(op, env) \ - ((op)->ops->get_out_faults (op, env)) + ((op)->ops->get_out_faults (op, env)) #define AXIS2_OP_SET_OUT_FAULTS(op, env) \ - ((op)->ops->set_out_faults (op, env, out_faults)) + ((op)->ops->set_out_faults (op, env, out_faults)) #define AXIS2_OP_GET_OUTPUT_MSG(op, env) \ - ((op)->ops->get_output_msg (op, env)) + ((op)->ops->get_output_msg (op, env)) #define AXIS2_OP_SET_OUTPUT_MSG(op, env) \ - ((op)->ops->set_output_msg (op, env, output_msg)) + ((op)->ops->set_output_msg (op, env, output_msg)) #define AXIS2_OP_IS_SAFE(op, env) \ - ((op)->ops->is_safe (op, env)) + ((op)->ops->is_safe (op, env)) #define AXIS2_OP_SET_SAFETY(op, env, safe) \ - ((op)->ops->set_safety (op, env, safe)) + ((op)->ops->set_safety (op, env, safe)) #define AXIS2_OP_GET_TARGET_NAMESPACE(op, env) \ - ((op)->ops->get_target_namespace (op, env)) + ((op)->ops->get_target_namespace (op, env)) #define AXIS2_OP_ADD_IN_FAULT(op, env, in_fault) \ - ((op)->ops->add_in_fault (op, env, in_fault)) + ((op)->ops->add_in_fault (op, env, in_fault)) #define AXIS2_OP_ADD_OUT_FAULT(op, env, out_fault) \ - ((op)->ops->add_out_fault (op, env, out_fault)) + ((op)->ops->add_out_fault (op, env, out_fault)) #define AXIS2_OP_ADD_FEATURE(op, env, feature) \ - ((op)->ops->add_feature (op, env, feature)) + ((op)->ops->add_feature (op, env, feature)) #define AXIS2_OP_GET_FEATURES(op, env) \ - ((op)->ops->get_features(op, env)) + ((op)->ops->get_features(op, env)) #define AXIS2_OP_ADD_PROPERTY(op, env, wsdl_property) \ - ((op)->ops->add_property (op, env, wsdl_property)) + ((op)->ops->add_property (op, env, wsdl_property)) #define AXIS2_OP_GET_PROPERTIES(op, env) \ - ((op)->ops->get_properties (op, env, properties)) + ((op)->ops->get_properties (op, env, properties)) #define AXIS2_OP_SET_WSDL_OP(op, env, wsdl_op) \ - ((op)->ops->set_wsdl_op (op, env, wsdl_op)) + ((op)->ops->set_wsdl_op (op, env, wsdl_op)) #define AXIS2_OP_FIND_OP_CTX(op, env, msg_ctx, svc_ctx) \ - ((op)->ops->find_op_ctx (op, env, msg_ctx, svc_ctx)) + ((op)->ops->find_op_ctx (op, env, msg_ctx, svc_ctx)) #define AXIS2_OP_FIND_FOR_EXISTING_OP_CTX(op, env, wsdl_op) \ - ((op)->ops->find_for_existing_op_ctx (op, env, wsdl_op)) + ((op)->ops->find_for_existing_op_ctx (op, env, wsdl_op)) #define AXIS2_OP_REGISTER_OP_CTX(op, env, msg_ctx, wsdl_op) \ - ((op)->ops->register_op_ctx (op, env, msg_ctx, wsdl_op)) + ((op)->ops->register_op_ctx (op, env, msg_ctx, wsdl_op)) /************************** End of function macros ****************************/ Modified: webservices/axis2/trunk/c/include/axis2_op_client.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_op_client.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_op_client.h (original) +++ webservices/axis2/trunk/c/include/axis2_op_client.h Sat Jun 3 20:09:08 2006 @@ -60,17 +60,17 @@ struct axis2_op_client_ops { - /** + /** * Sets the options that should be used for this particular client. This * resets the entire set of options to use the new options - so you'd lose * any option cascading that may have been set up. * * @param options the options */ - axis2_status_t (AXIS2_CALL * - set_options)(struct axis2_op_client *op_client, - const axis2_env_t *env, - axis2_options_t *options); + axis2_status_t (AXIS2_CALL * + set_options)(struct axis2_op_client *op_client, + const axis2_env_t *env, + axis2_options_t *options); /** @@ -80,9 +80,9 @@ * * @return the options, which will never be null. */ - axis2_options_t* (AXIS2_CALL * - get_options)(struct axis2_op_client *op_client, - const axis2_env_t *env); + axis2_options_t* (AXIS2_CALL * + get_options)(struct axis2_op_client *op_client, + const axis2_env_t *env); /** * Add a message context to the client for processing. This method must not @@ -91,22 +91,22 @@ * * @param mc the message context */ - axis2_status_t (AXIS2_CALL * - add_msg_ctx)(struct axis2_op_client *op_client, - const axis2_env_t *env, - axis2_msg_ctx_t *mc); + axis2_status_t (AXIS2_CALL * + add_msg_ctx)(struct axis2_op_client *op_client, + const axis2_env_t *env, + axis2_msg_ctx_t *mc); - /** + /** * Return a message from the client - will return null if the requested * message is not available. * * @param message_label the message label of the desired message context * @return the desired message context or null if its not available. */ - axis2_msg_ctx_t* (AXIS2_CALL * - get_msg_ctx)(struct axis2_op_client *op_client, - const axis2_env_t *env, - axis2_char_t *message_label); + axis2_msg_ctx_t* (AXIS2_CALL * + get_msg_ctx)(struct axis2_op_client *op_client, + const axis2_env_t *env, + axis2_char_t *message_label); /** * Set the callback to be executed when a message comes into the MEP and the @@ -118,12 +118,12 @@ * @param callback the callback to be used when the client decides its time to * use it */ - axis2_status_t (AXIS2_CALL * - set_callback)(struct axis2_op_client *op_client, - const axis2_env_t *env, - axis2_callback_t *callback); + axis2_status_t (AXIS2_CALL * + set_callback)(struct axis2_op_client *op_client, + const axis2_env_t *env, + axis2_callback_t *callback); - /** + /** * Execute the MEP. What this does depends on the specific operation client. * The basic idea is to have the operation client execute and do something * with the messages that have been added to it so far. For example, if its @@ -135,10 +135,10 @@ * block means is of course a function of the specific operation * client. */ - axis2_status_t (AXIS2_CALL * - execute)(struct axis2_op_client *op_client, - const axis2_env_t *env, - axis2_bool_t block); + axis2_status_t (AXIS2_CALL * + execute)(struct axis2_op_client *op_client, + const axis2_env_t *env, + axis2_bool_t block); /** * Reset the operation client to a clean status after the MEP has completed. @@ -146,9 +146,9 @@ * the options; only the internal state so the client can be used again. * */ - axis2_status_t (AXIS2_CALL * - reset)(struct axis2_op_client *op_client, - const axis2_env_t *env); + axis2_status_t (AXIS2_CALL * + reset)(struct axis2_op_client *op_client, + const axis2_env_t *env); /** * To close the tranport if necessary , can call this method. The most usage of thie method @@ -158,17 +158,17 @@ * * @param mc : axis2_msg_ctx_t# which have all the trnport information */ - axis2_status_t (AXIS2_CALL * - compelete)(struct axis2_op_client *op_client, - const axis2_env_t *env, - axis2_msg_ctx_t *mc); + axis2_status_t (AXIS2_CALL * + compelete)(struct axis2_op_client *op_client, + const axis2_env_t *env, + axis2_msg_ctx_t *mc); - /** + /** * To get the operation context of the operation cleint * @return Operation Context */ - axis2_op_ctx_t* (AXIS2_CALL * - get_operation_context)(struct axis2_op_client *op_client); + axis2_op_ctx_t* (AXIS2_CALL * + get_operation_context)(struct axis2_op_client *op_client); axis2_status_t (AXIS2_CALL * set_callback_recv)( @@ -176,14 +176,14 @@ const axis2_env_t *env, struct axis2_callback_recv *callback_recv); - axis2_status_t (AXIS2_CALL * - free)(struct axis2_op_client *op_client, - const axis2_env_t *env); + axis2_status_t (AXIS2_CALL * + free)(struct axis2_op_client *op_client, + const axis2_env_t *env); }; /** * @brief Operation Client struct - * Axis2 Operation Client + * Axis2 Operation Client */ struct axis2_op_client { @@ -191,44 +191,44 @@ }; AXIS2_EXTERN axis2_op_client_t* AXIS2_CALL axis2_op_client_create(const axis2_env_t *env, - axis2_op_t *op, - axis2_svc_ctx_t *svc_ctx, - axis2_options_t *options); + axis2_op_t *op, + axis2_svc_ctx_t *svc_ctx, + axis2_options_t *options); /************************** Start of function macros **************************/ #define AXIS2_OP_CLIENT_SET_OPTIONS(op_client, env, options) \ - ((op_client)->ops->set_options(op_client, env, options)) + ((op_client)->ops->set_options(op_client, env, options)) #define AXIS2_OP_CLIENT_GET_OPTIONS(op_client, env) \ - ((op_client)->ops->get_options(op_client, env)) + ((op_client)->ops->get_options(op_client, env)) #define AXIS2_OP_CLIENT_ADD_MSG_CTX(op_client, env, mc) \ - ((op_client)->ops->add_msg_ctx(op_client, env, mc)) + ((op_client)->ops->add_msg_ctx(op_client, env, mc)) #define AXIS2_OP_CLIENT_GET_MSG_CTX(op_client, env, message_label) \ - ((op_client)->ops->get_msg_ctx(op_client, env, message_label)) + ((op_client)->ops->get_msg_ctx(op_client, env, message_label)) #define AXIS2_OP_CLIENT_SET_CALLBACK(op_client, env, callback) \ - ((op_client)->ops->set_callback(op_client, env, callback)) + ((op_client)->ops->set_callback(op_client, env, callback)) #define AXIS2_OP_CLIENT_EXECUTE(op_client, env, block) \ - ((op_client)->ops->execute(op_client, env, block)) + ((op_client)->ops->execute(op_client, env, block)) #define AXIS2_OP_CLIENT_RESET(op_client, env) \ - ((op_client)->ops->reset(op_client, env)) + ((op_client)->ops->reset(op_client, env)) #define AXIS2_OP_CLIENT_COMPLETE(op_client, env, mc) \ - ((op_client)->ops->compelete(op_client, env, mc)) + ((op_client)->ops->compelete(op_client, env, mc)) #define AXIS2_OP_CLIENT_GET_OPERATION_CONTEXT(op_client, env) \ - ((op_client)->ops->get_operation_context(op_client, env)) + ((op_client)->ops->get_operation_context(op_client, env)) #define AXIS2_OP_CLIENT_FREE(op_client, env) \ - ((op_client)->ops->free(op_client, env)) + ((op_client)->ops->free(op_client, env)) #define AXIS2_OP_CLIENT_SET_CALLBACK_RECV(op_client, env, callback_recv) \ - ((op_client)->ops->set_callback_recv(op_client, env, callback_recv)) + ((op_client)->ops->set_callback_recv(op_client, env, callback_recv)) /************************** End of function macros ****************************/ Modified: webservices/axis2/trunk/c/include/axis2_op_ctx.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_op_ctx.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_op_ctx.h (original) +++ webservices/axis2/trunk/c/include/axis2_op_ctx.h Sat Jun 3 20:09:08 2006 @@ -62,27 +62,27 @@ struct axis2_op_ctx_ops { axis2_ctx_t* (AXIS2_CALL * - get_base)(struct axis2_op_ctx *op_ctx, + get_base)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env); axis2_status_t (AXIS2_CALL * - free)(struct axis2_op_ctx *op_ctx, + free)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env); /** * The method is used to do the intialization of the axis2_op_ctx */ axis2_status_t (AXIS2_CALL * - init)(struct axis2_op_ctx *op_ctx, - const axis2_env_t *env, - struct axis2_conf *conf); + init)(struct axis2_op_ctx *op_ctx, + const axis2_env_t *env, + struct axis2_conf *conf); /** * @return Returns the op. */ struct axis2_op* (AXIS2_CALL * get_op)(struct axis2_op_ctx *op_ctx, - const axis2_env_t *env); + const axis2_env_t *env); /** * Return the struct axis2_svc_ctx * in which this op_ctx lives. @@ -90,8 +90,8 @@ * @return parent struct axis2_svc_ctx * */ struct axis2_svc_ctx* (AXIS2_CALL * - get_parent)(struct axis2_op_ctx *op_ctx, - const axis2_env_t *env); + get_parent)(struct axis2_op_ctx *op_ctx, + const axis2_env_t *env); /** * When a new message is added to the MEPContext the logic @@ -102,9 +102,9 @@ * @param msgContext */ axis2_status_t (AXIS2_CALL * - add_msg_ctx)(struct axis2_op_ctx *op_ctx, - const axis2_env_t *env, - axis2_msg_ctx_t *msg_ctx); + add_msg_ctx)(struct axis2_op_ctx *op_ctx, + const axis2_env_t *env, + axis2_msg_ctx_t *msg_ctx); /** * @param message_id @@ -112,9 +112,9 @@ * @throws AxisFault */ axis2_msg_ctx_t* (AXIS2_CALL * - get_msg_ctx)(struct axis2_op_ctx *op_ctx, + get_msg_ctx)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env, - axis2_char_t *message_id); + axis2_char_t *message_id); /** * Checks to see if the MEP is complete. i.e. whether all the messages that @@ -122,11 +122,11 @@ * */ axis2_bool_t (AXIS2_CALL * - get_is_complete)(struct axis2_op_ctx *op_ctx, + get_is_complete)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env); axis2_status_t (AXIS2_CALL * - set_complete)(struct axis2_op_ctx *op_ctx, + set_complete)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env, axis2_bool_t is_complete); @@ -141,23 +141,23 @@ * being complete due to the optional nature of the MEP. */ axis2_status_t (AXIS2_CALL * - cleanup)(struct axis2_op_ctx *op_ctx, + cleanup)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env); axis2_status_t (AXIS2_CALL * - set_parent)(struct axis2_op_ctx *op_ctx, + set_parent)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env, struct axis2_svc_ctx *svc_ctx); axis2_hash_t* (AXIS2_CALL * - get_msg_ctx_map)(struct axis2_op_ctx *op_ctx, + get_msg_ctx_map)(struct axis2_op_ctx *op_ctx, const axis2_env_t *env); }; /** * @brief Message Context struct - * Axis2 Message Context + * Axis2 Message Context */ struct axis2_op_ctx { @@ -171,39 +171,39 @@ /************************** Start of function macros **************************/ #define AXIS2_OP_CTX_GET_BASE(op_ctx, env) \ - ((op_ctx)->ops->get_base(op_ctx, env)) - + ((op_ctx)->ops->get_base(op_ctx, env)) + #define AXIS2_OP_CTX_FREE(op_ctx, env)\ - ((op_ctx)->ops->free(op_ctx, env)) - + ((op_ctx)->ops->free(op_ctx, env)) + #define AXIS2_OP_CTX_INIT(op_ctx, env, conf) \ - ((op_ctx)->ops->init(op_ctx, env, conf)) - + ((op_ctx)->ops->init(op_ctx, env, conf)) + #define AXIS2_OP_CTX_GET_OP(op_ctx, env)\ - ((op_ctx)->ops->get_op(op_ctx, env)) + ((op_ctx)->ops->get_op(op_ctx, env)) #define AXIS2_OP_CTX_GET_PARENT(op_ctx, env) \ - ((op_ctx)->ops->get_parent(op_ctx, env)) - + ((op_ctx)->ops->get_parent(op_ctx, env)) + #define AXIS2_OP_CTX_ADD_MSG_CTX(op_ctx, env, msg_ctx) \ - ((op_ctx)->ops->add_msg_ctx(op_ctx, env, msg_ctx)) - + ((op_ctx)->ops->add_msg_ctx(op_ctx, env, msg_ctx)) + #define AXIS2_OP_CTX_GET_MSG_CTX(op_ctx, env, message_id) \ - ((op_ctx)->ops->get_msg_ctx(op_ctx, env, message_id)) - + ((op_ctx)->ops->get_msg_ctx(op_ctx, env, message_id)) + #define AXIS2_OP_CTX_GET_IS_COMPLETE(op_ctx, env) \ - ((op_ctx)->ops->get_is_complete(op_ctx, env)) - + ((op_ctx)->ops->get_is_complete(op_ctx, env)) + #define AXIS2_OP_CTX_SET_IS_COMPLETE(op_ctx, env, is_complete) \ - ((op_ctx)->ops->set_complete(op_ctx, env, is_complete)) - + ((op_ctx)->ops->set_complete(op_ctx, env, is_complete)) + #define AXIS2_OP_CTX_CLEANUP(op_ctx, env) \ - ((op_ctx)->ops->cleanup(op_ctx, env)) - + ((op_ctx)->ops->cleanup(op_ctx, env)) + #define AXIS2_OP_CTX_SET_PARENT(op_ctx, env, svc_ctx) \ - ((op_ctx)->ops->set_parent(op_ctx, env, svc_ctx)) - + ((op_ctx)->ops->set_parent(op_ctx, env, svc_ctx)) + #define AXIS2_OP_CTX_GET_MSG_CTX_MAP(op_ctx, env) \ - ((op_ctx)->ops->get_msg_ctx_map(op_ctx, env)) + ((op_ctx)->ops->get_msg_ctx_map(op_ctx, env)) /************************** End of function macros ****************************/ Modified: webservices/axis2/trunk/c/include/axis2_options.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_options.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_options.h (original) +++ webservices/axis2/trunk/c/include/axis2_options.h Sat Jun 3 20:09:08 2006 @@ -35,7 +35,7 @@ #include #define AXIS2_DEFAULT_TIMEOUT_MILLISECONDS 30000 -#define AXIS2_COPY_PROPERTIES "copy_properties" +#define AXIS2_COPY_PROPERTIES "copy_properties" #ifdef __cplusplus extern "C" @@ -56,143 +56,143 @@ */ struct axis2_options_ops { - axis2_char_t* (AXIS2_CALL * - get_action)(struct axis2_options *options, - const axis2_env_t *env); - - - axis2_endpoint_ref_t* (AXIS2_CALL * - get_fault_to)(struct axis2_options *options, - const axis2_env_t *env); - - - axis2_endpoint_ref_t* (AXIS2_CALL * - get_from)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_transport_receiver_t* (AXIS2_CALL * - get_transport_receiver)(struct axis2_options *options, - const axis2_env_t *env); - - - axis2_transport_in_desc_t* (AXIS2_CALL * - get_transport_in)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_char_t* (AXIS2_CALL * - get_transport_in_protocol)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_char_t* (AXIS2_CALL * - get_message_id)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_hash_t* (AXIS2_CALL * - get_properties)(struct axis2_options *options, - const axis2_env_t *env); + axis2_char_t* (AXIS2_CALL * + get_action)(struct axis2_options *options, + const axis2_env_t *env); + + + axis2_endpoint_ref_t* (AXIS2_CALL * + get_fault_to)(struct axis2_options *options, + const axis2_env_t *env); + + + axis2_endpoint_ref_t* (AXIS2_CALL * + get_from)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_transport_receiver_t* (AXIS2_CALL * + get_transport_receiver)(struct axis2_options *options, + const axis2_env_t *env); + + + axis2_transport_in_desc_t* (AXIS2_CALL * + get_transport_in)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_char_t* (AXIS2_CALL * + get_transport_in_protocol)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_char_t* (AXIS2_CALL * + get_message_id)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_hash_t* (AXIS2_CALL * + get_properties)(struct axis2_options *options, + const axis2_env_t *env); /** * @param key * @return the value realeted to this key. Null, if not found. */ - void* (AXIS2_CALL * - get_property)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *key); - - axis2_relates_to_t* (AXIS2_CALL * - get_relates_to)(struct axis2_options *options, - const axis2_env_t *env); - - - axis2_endpoint_ref_t* (AXIS2_CALL * - get_reply_to)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_transport_out_desc_t* (AXIS2_CALL * - get_transport_out)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_char_t* (AXIS2_CALL * - get_sender_transport_protocol)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_char_t* (AXIS2_CALL * - get_soap_version_uri)(struct axis2_options *options, - const axis2_env_t *env); + void* (AXIS2_CALL * + get_property)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *key); + + axis2_relates_to_t* (AXIS2_CALL * + get_relates_to)(struct axis2_options *options, + const axis2_env_t *env); + + + axis2_endpoint_ref_t* (AXIS2_CALL * + get_reply_to)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_transport_out_desc_t* (AXIS2_CALL * + get_transport_out)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_char_t* (AXIS2_CALL * + get_sender_transport_protocol)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_char_t* (AXIS2_CALL * + get_soap_version_uri)(struct axis2_options *options, + const axis2_env_t *env); - /** + /** * Gets the wait time after which a client times out in a blocking scenario. * The default is AXIS2_DEFAULT_TIMEOUT_MILLISECONDS * * @return timeOutInMilliSeconds */ - long (AXIS2_CALL * - get_timeout_in_milli_seconds)(struct axis2_options *options, - const axis2_env_t *env); - - axis2_endpoint_ref_t* (AXIS2_CALL * - get_to)(struct axis2_options *options, - const axis2_env_t *env); - - /**not added - is_exception_to_be_thrown_on_soap_fault*/ - - axis2_bool_t (AXIS2_CALL * - is_use_seperate_listener)(struct axis2_options *options, - const axis2_env_t *env); - - struct axis2_options * (AXIS2_CALL * - get_parent)(struct axis2_options *options, - const axis2_env_t *env); - - void (AXIS2_CALL * - set_parent)(struct axis2_options *options, - const axis2_env_t *env, - struct axis2_options *parent); - - void (AXIS2_CALL * - set_action)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *action); - - void (AXIS2_CALL * - set_fault_to)(struct axis2_options *options, - const axis2_env_t *env, - axis2_endpoint_ref_t *fault_to); - - void (AXIS2_CALL * - set_from)(struct axis2_options *options, - const axis2_env_t *env, - axis2_endpoint_ref_t *from); - - void (AXIS2_CALL * - set_to)(struct axis2_options *options, - const axis2_env_t *env, - axis2_endpoint_ref_t *to); - - void (AXIS2_CALL * - set_transport_receiver)(struct axis2_options *options, - const axis2_env_t *env, - axis2_transport_receiver_t *receiver); - - void (AXIS2_CALL * - set_transport_in)(struct axis2_options *options, - const axis2_env_t *env, - axis2_transport_in_desc_t *transport_in); - - void (AXIS2_CALL * - set_transport_in_protocol)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *transport_in_protocol); - - - void (AXIS2_CALL * - set_message_id)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *message_id); + long (AXIS2_CALL * + get_timeout_in_milli_seconds)(struct axis2_options *options, + const axis2_env_t *env); + + axis2_endpoint_ref_t* (AXIS2_CALL * + get_to)(struct axis2_options *options, + const axis2_env_t *env); + + /**not added - is_exception_to_be_thrown_on_soap_fault*/ + + axis2_bool_t (AXIS2_CALL * + is_use_seperate_listener)(struct axis2_options *options, + const axis2_env_t *env); + + struct axis2_options * (AXIS2_CALL * + get_parent)(struct axis2_options *options, + const axis2_env_t *env); + + void (AXIS2_CALL * + set_parent)(struct axis2_options *options, + const axis2_env_t *env, + struct axis2_options *parent); + + void (AXIS2_CALL * + set_action)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *action); + + void (AXIS2_CALL * + set_fault_to)(struct axis2_options *options, + const axis2_env_t *env, + axis2_endpoint_ref_t *fault_to); + + void (AXIS2_CALL * + set_from)(struct axis2_options *options, + const axis2_env_t *env, + axis2_endpoint_ref_t *from); + + void (AXIS2_CALL * + set_to)(struct axis2_options *options, + const axis2_env_t *env, + axis2_endpoint_ref_t *to); + + void (AXIS2_CALL * + set_transport_receiver)(struct axis2_options *options, + const axis2_env_t *env, + axis2_transport_receiver_t *receiver); + + void (AXIS2_CALL * + set_transport_in)(struct axis2_options *options, + const axis2_env_t *env, + axis2_transport_in_desc_t *transport_in); + + void (AXIS2_CALL * + set_transport_in_protocol)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *transport_in_protocol); + + + void (AXIS2_CALL * + set_message_id)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *message_id); - + /** * This will set the properties to the context. But in setting that one may * need to "copy" all the properties from the source properties to the @@ -203,12 +203,12 @@ * * @param properties */ - axis2_status_t (AXIS2_CALL * - set_properties)(struct axis2_options *options, - const axis2_env_t *env, - axis2_hash_t *properties); + axis2_status_t (AXIS2_CALL * + set_properties)(struct axis2_options *options, + const axis2_env_t *env, + axis2_hash_t *properties); - /** + /** * Properties you need to pass in to the message context must be set via * this. If there is a method to the set this property, within this class, * its encouraged to use that method, without duplicating stuff or making @@ -216,80 +216,80 @@ * * @param property_key * @param property - */ - void (AXIS2_CALL * - set_property)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *property_key, - void *property); - - - void (AXIS2_CALL * - set_relates_to)(struct axis2_options *options, - const axis2_env_t *env, - axis2_relates_to_t *relates_to); - - void (AXIS2_CALL * - set_reply_to)(struct axis2_options *options, - const axis2_env_t *env, - axis2_endpoint_ref_t *reply_to); - - void (AXIS2_CALL * - set_transport_out)(struct axis2_options *options, - const axis2_env_t *env, - axis2_transport_out_desc_t *transport_out); - - axis2_status_t (AXIS2_CALL * - set_sender_transport)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *sender_transport, - axis2_conf_t *conf); - - void (AXIS2_CALL * - set_soap_version_uri)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *soap_version_uri); - - void (AXIS2_CALL * - set_timeout_in_milli_seconds)(struct axis2_options *options, - const axis2_env_t *env, - long timeout_in_milli_seconds); - - - axis2_status_t (AXIS2_CALL * - set_transport_info)(struct axis2_options *options, - const axis2_env_t *env, - axis2_char_t *sender_transport, - axis2_char_t *receiver_transport, - axis2_bool_t use_seperate_listener); - - void (AXIS2_CALL * - set_use_seperate_listener)(struct axis2_options *options, - const axis2_env_t *env, - axis2_bool_t use_seperate_listener); - - void (AXIS2_CALL * - add_reference_parameter)(struct axis2_options *options, - const axis2_env_t *env, - axis2_om_node_t *reference_parameter); - - axis2_bool_t (AXIS2_CALL * - is_manage_session)(struct axis2_options *options, - const axis2_env_t *env); - - - void (AXIS2_CALL * - set_manage_session)(struct axis2_options *options, - const axis2_env_t *env, - axis2_bool_t manage_session); - - /** - * this method is used to set the msg info headers to msg ctx. not - * intended to be used from outside - */ - axis2_msg_info_headers_t* (AXIS2_CALL * - get_msg_info_headers)(struct axis2_options *options, - const axis2_env_t *env); + */ + void (AXIS2_CALL * + set_property)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *property_key, + void *property); + + + void (AXIS2_CALL * + set_relates_to)(struct axis2_options *options, + const axis2_env_t *env, + axis2_relates_to_t *relates_to); + + void (AXIS2_CALL * + set_reply_to)(struct axis2_options *options, + const axis2_env_t *env, + axis2_endpoint_ref_t *reply_to); + + void (AXIS2_CALL * + set_transport_out)(struct axis2_options *options, + const axis2_env_t *env, + axis2_transport_out_desc_t *transport_out); + + axis2_status_t (AXIS2_CALL * + set_sender_transport)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *sender_transport, + axis2_conf_t *conf); + + void (AXIS2_CALL * + set_soap_version_uri)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *soap_version_uri); + + void (AXIS2_CALL * + set_timeout_in_milli_seconds)(struct axis2_options *options, + const axis2_env_t *env, + long timeout_in_milli_seconds); + + + axis2_status_t (AXIS2_CALL * + set_transport_info)(struct axis2_options *options, + const axis2_env_t *env, + axis2_char_t *sender_transport, + axis2_char_t *receiver_transport, + axis2_bool_t use_seperate_listener); + + void (AXIS2_CALL * + set_use_seperate_listener)(struct axis2_options *options, + const axis2_env_t *env, + axis2_bool_t use_seperate_listener); + + void (AXIS2_CALL * + add_reference_parameter)(struct axis2_options *options, + const axis2_env_t *env, + axis2_om_node_t *reference_parameter); + + axis2_bool_t (AXIS2_CALL * + is_manage_session)(struct axis2_options *options, + const axis2_env_t *env); + + + void (AXIS2_CALL * + set_manage_session)(struct axis2_options *options, + const axis2_env_t *env, + axis2_bool_t manage_session); + + /** + * this method is used to set the msg info headers to msg ctx. not + * intended to be used from outside + */ + axis2_msg_info_headers_t* (AXIS2_CALL * + get_msg_info_headers)(struct axis2_options *options, + const axis2_env_t *env); int (AXIS2_CALL * get_soap_version)( @@ -313,14 +313,14 @@ struct axis2_options *options, const axis2_env_t *env); - axis2_status_t (AXIS2_CALL * - free)(struct axis2_options *options, - const axis2_env_t *env); + axis2_status_t (AXIS2_CALL * + free)(struct axis2_options *options, + const axis2_env_t *env); }; /** * @brief Options struct - * Axis2 Options + * Axis2 Options */ struct axis2_options { @@ -330,147 +330,147 @@ AXIS2_EXTERN axis2_options_t* AXIS2_CALL axis2_options_create(const axis2_env_t *env); AXIS2_EXTERN axis2_options_t* AXIS2_CALL axis2_options_create_with_parent(const axis2_env_t *env, - axis2_options_t *parent); + axis2_options_t *parent); /************************** Start of function macros **************************/ #define AXIS2_OPTIONS_GET_ACTION(options, env) \ - ((options)->ops->get_action(options, env)) - + ((options)->ops->get_action(options, env)) + #define AXIS2_OPTIONS_GET_FAULT_TO(options, env) \ - ((options)->ops->get_fault_to(options, env)) + ((options)->ops->get_fault_to(options, env)) #define AXIS2_OPTIONS_GET_FROM(options, env) \ - ((options)->ops->get_from(options, env)) + ((options)->ops->get_from(options, env)) #define AXIS2_OPTIONS_GET_TRANSPORT_RECEIVER(options, env) \ - ((options)->ops->get_transport_receiver(options, env)) + ((options)->ops->get_transport_receiver(options, env)) #define AXIS2_OPTIONS_GET_TRANSPORT_IN(options, env) \ - ((options)->ops->get_transport_in(options, env)) + ((options)->ops->get_transport_in(options, env)) #define AXIS2_OPTIONS_GET_TRANSPORT_IN_PROTOCOL(options, env) \ - ((options)->ops->get_transport_in_protocol(options, env)) + ((options)->ops->get_transport_in_protocol(options, env)) #define AXIS2_OPTIONS_GET_MESSAGE_ID(options, env) \ - ((options)->ops->get_message_id(options, env)) + ((options)->ops->get_message_id(options, env)) #define AXIS2_OPTIONS_GET_PROPERTIES(options, env) \ - ((options)->ops->get_properties(options, env)) + ((options)->ops->get_properties(options, env)) #define AXIS2_OPTIONS_GET_PROPERTY(options, env, key) \ - ((options)->ops->get_property(options, env, key)) + ((options)->ops->get_property(options, env, key)) #define AXIS2_OPTIONS_GET_RELATES_TO(options, env) \ - ((options)->ops->get_relates_to(options, env)) + ((options)->ops->get_relates_to(options, env)) #define AXIS2_OPTIONS_GET_REPLY_TO(options, env) \ - ((options)->ops->get_reply_to(options, env)) + ((options)->ops->get_reply_to(options, env)) #define AXIS2_OPTIONS_GET_TRANSPORT_OUT(options, env) \ - ((options)->ops->get_transport_out(options, env)) + ((options)->ops->get_transport_out(options, env)) #define AXIS2_OPTIONS_GET_SENDER_PROTOCOL(options, env) \ - ((options)->ops->get_sender_transport_protocol(options, env)) + ((options)->ops->get_sender_transport_protocol(options, env)) #define AXIS2_OPTIONS_GET_SOAP_VERSION_URI(options, env) \ - ((options)->ops->get_soap_version_uri(options, env)) + ((options)->ops->get_soap_version_uri(options, env)) #define AXIS2_OPTIONS_GET_TIMEOUT_IN_MILLI_SECONDS(options, env) \ - ((options)->ops->get_timeout_in_milli_seconds(options, env)) + ((options)->ops->get_timeout_in_milli_seconds(options, env)) #define AXIS2_OPTIONS_GET_TO(options, env) \ - ((options)->ops->get_to(options, env)) + ((options)->ops->get_to(options, env)) #define AXIS2_OPTIONS_IS_USE_SEPERATE_LISTENER(options, env) \ - ((options)->ops->is_use_seperate_listener(options, env)) + ((options)->ops->is_use_seperate_listener(options, env)) #define AXIS2_OPTIONS_GET_PARENT(options, env) \ - ((options)->ops->get_parent(options, env)) + ((options)->ops->get_parent(options, env)) #define AXIS2_OPTIONS_SET_PARENT(options, env, parent) \ - ((options)->ops->set_parent(options, env, parent)) + ((options)->ops->set_parent(options, env, parent)) #define AXIS2_OPTIONS_SET_ACTION(options, env, action) \ - ((options)->ops->set_action(options, env, action)) + ((options)->ops->set_action(options, env, action)) #define AXIS2_OPTIONS_SET_FAULT_TO(options, env, fault_to) \ - ((options)->ops->set_fault_to(options, env, fault_to)) + ((options)->ops->set_fault_to(options, env, fault_to)) #define AXIS2_OPTIONS_SET_FROM(options, env, from) \ - ((options)->ops->set_from(options, env, from)) + ((options)->ops->set_from(options, env, from)) #define AXIS2_OPTIONS_SET_TO(options, env, to) \ - ((options)->ops->set_to(options, env, to)) + ((options)->ops->set_to(options, env, to)) #define AXIS2_OPTIONS_SET_TRANSPORT_RECEIVER(options, env, receiver) \ - ((options)->ops->set_transport_receiver(options, env, receiver)) + ((options)->ops->set_transport_receiver(options, env, receiver)) #define AXIS2_OPTIONS_SET_TRANSPORT_IN(options, env, transport_in) \ - ((options)->ops->set_transport_in(options, env, transport_in)) + ((options)->ops->set_transport_in(options, env, transport_in)) #define AXIS2_OPTIONS_SET_TRANSPORT_IN_PROTOCOL(options, env, transport_in_protocol) \ - ((options)->ops->set_transport_in_protocol(options, env, transport_in_protocol)) + ((options)->ops->set_transport_in_protocol(options, env, transport_in_protocol)) #define AXIS2_OPTIONS_SET_MESSAGE_ID(options, env, message_id) \ - ((options)->ops->set_message_id(options, env, message_id)) + ((options)->ops->set_message_id(options, env, message_id)) #define AXIS2_OPTIONS_SET_PROPERTIES(options, env, properties) \ - ((options)->ops->set_properties(options, env, properties)) + ((options)->ops->set_properties(options, env, properties)) #define AXIS2_OPTIONS_SET_PROPERTY(options, env, key, property) \ - ((options)->ops->set_property(options, env, key, property)) + ((options)->ops->set_property(options, env, key, property)) #define AXIS2_OPTIONS_SET_RELATES_TO(options, env, relates_to) \ - ((options)->ops->set_relates_to(options, env, relates_to)) + ((options)->ops->set_relates_to(options, env, relates_to)) #define AXIS2_OPTIONS_SET_REPLY_TO(options, env, reply_to) \ - ((options)->ops->set_reply_to(options, env, reply_to)) - + ((options)->ops->set_reply_to(options, env, reply_to)) + #define AXIS2_OPTIONS_SET_TRANSPORT_OUT(options, env, transport_out) \ - ((options)->ops->set_transport_out(options, env, transport_out)) + ((options)->ops->set_transport_out(options, env, transport_out)) #define AXIS2_OPTIONS_SET_SENDER_TRANSPORT(options, env, sender_transport, conf) \ - ((options)->ops->set_sender_transport(options, env, sender_transport, conf)) + ((options)->ops->set_sender_transport(options, env, sender_transport, conf)) #define AXIS2_OPTIONS_SET_SOAP_VERSION_URI(options, env, soap_version_uri) \ - ((options)->ops->set_soap_version_uri(options, env, soap_version_uri)) + ((options)->ops->set_soap_version_uri(options, env, soap_version_uri)) #define AXIS2_OPTIONS_SET_TIMEOUT_IN_MILLI_SECONDS(options, env, timeout_in_milli_seconds) \ - ((options)->ops->set_timeout_in_milli_seconds(options, env, timeout_in_milli_seconds)) + ((options)->ops->set_timeout_in_milli_seconds(options, env, timeout_in_milli_seconds)) #define AXIS2_OPTIONS_SET_TRANSPORT_INFO(options, env, sender_transport, receiver_transport, user_seperate_listener) \ - ((options)->ops->set_tranport_info(options, env, sender_transport, receiver_transport, user_seperate_listener)) + ((options)->ops->set_tranport_info(options, env, sender_transport, receiver_transport, user_seperate_listener)) #define AXIS2_OPTIONS_SET_USE_SEPERATE_LISTENER(options, env, use_seperate_listener) \ - ((options)->ops->set_use_seperate_listener(options, env, use_seperate_listener)) + ((options)->ops->set_use_seperate_listener(options, env, use_seperate_listener)) #define AXIS2_OPTIONS_ADD_REFERENCE_PARAMETER(options, env, reference_parameter) \ - ((options)->ops->add_reference_parameter(options, env, reference_parameter)) + ((options)->ops->add_reference_parameter(options, env, reference_parameter)) #define AXIS2_OPTIONS_IS_MANAGE_SESSION(options, env) \ - ((options)->ops->is_manage_session(options, env)) + ((options)->ops->is_manage_session(options, env)) #define AXIS2_OPTIONS_SET_MANAGE_SESSION(options, env, manage_session) \ - ((options)->ops->set_manage_session(options, env, manage_session)) + ((options)->ops->set_manage_session(options, env, manage_session)) #define AXIS2_OPTIONS_GET_MSG_INFO_HEADERS(options, env) \ - ((options)->ops->get_msg_info_headers(options, env)) + ((options)->ops->get_msg_info_headers(options, env)) #define AXIS2_OPTIONS_SET_SOAP_VERSION(options, env, soap_version) \ - ((options)->ops->set_soap_version(options, env, soap_version)) + ((options)->ops->set_soap_version(options, env, soap_version)) #define AXIS2_OPTIONS_GET_SOAP_VERSION(options, env) \ - ((options)->ops->get_soap_version(options, env)) + ((options)->ops->get_soap_version(options, env)) #define AXIS2_OPTIONS_SET_ENABLE_MTOM(options, env, enable_mtom) \ - ((options)->ops->set_enable_mtom(options, env, enable_mtom)) + ((options)->ops->set_enable_mtom(options, env, enable_mtom)) #define AXIS2_OPTIONS_GET_ENABLE_MTOM(options, env) \ - ((options)->ops->get_enable_mtom(options, env)) + ((options)->ops->get_enable_mtom(options, env)) #define AXIS2_OPTIONS_FREE(options, env) \ - ((options)->ops->free(options, env)) + ((options)->ops->free(options, env)) /************************** End of function macros ****************************/ Modified: webservices/axis2/trunk/c/include/axis2_phase.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phase.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_phase.h (original) +++ webservices/axis2/trunk/c/include/axis2_phase.h Sat Jun 3 20:09:08 2006 @@ -64,38 +64,38 @@ * @param index */ axis2_status_t (AXIS2_CALL * - add_handler_at)(struct axis2_phase *phase, - const axis2_env_t *env, - int index, - axis2_handler_t *hander); + add_handler_at)(struct axis2_phase *phase, + const axis2_env_t *env, + int index, + axis2_handler_t *hander); /** * add to next empty phase * * @param phase */ axis2_status_t (AXIS2_CALL * - add_handler)(struct axis2_phase *phase, - const axis2_env_t *env, - axis2_handler_t *handler); - /** + add_handler)(struct axis2_phase *phase, + const axis2_env_t *env, + axis2_handler_t *handler); + /** * If need to see how this works look at the stack! * * @param msg_ctx */ axis2_status_t (AXIS2_CALL * - invoke)(struct axis2_phase *phase, - const axis2_env_t *env, - struct axis2_msg_ctx *msg_ctx); + invoke)(struct axis2_phase *phase, + const axis2_env_t *env, + struct axis2_msg_ctx *msg_ctx); /** * phase name accessor * @return returns the phase name. */ axis2_char_t* (AXIS2_CALL * - get_name)(struct axis2_phase *phase, + get_name)(struct axis2_phase *phase, const axis2_env_t *env); int (AXIS2_CALL * - get_handler_count)(struct axis2_phase *phase, + get_handler_count)(struct axis2_phase *phase, const axis2_env_t *env); /** @@ -104,36 +104,36 @@ * @param first_handler */ axis2_status_t (AXIS2_CALL * - set_first_handler)(struct axis2_phase *phase, + set_first_handler)(struct axis2_phase *phase, const axis2_env_t *env, - axis2_handler_t * handler); + axis2_handler_t * handler); /** * Method setPhaseLast * * @param last_handler */ axis2_status_t (AXIS2_CALL * - set_last_handler)(struct axis2_phase *phase, + set_last_handler)(struct axis2_phase *phase, const axis2_env_t *env, - axis2_handler_t * handler); + axis2_handler_t * handler); /** * Method add_handler * * @param handler */ axis2_status_t (AXIS2_CALL * - add_handler_desc)(struct axis2_phase *phase, + add_handler_desc)(struct axis2_phase *phase, const axis2_env_t *env, - axis2_handler_desc_t * handler_desc); + axis2_handler_desc_t * handler_desc); /** * Method axis2_phase_insert_before * * @param handler */ axis2_status_t (AXIS2_CALL * - insert_before)(struct axis2_phase *phase, - const axis2_env_t *env, - axis2_handler_t * handler); + insert_before)(struct axis2_phase *phase, + const axis2_env_t *env, + axis2_handler_t * handler); /** * Method axis2_phase_insert_after @@ -141,25 +141,25 @@ * @param handler */ axis2_status_t (AXIS2_CALL * - insert_after)(struct axis2_phase *phase, - const axis2_env_t *env, - axis2_handler_t * handler); + insert_after)(struct axis2_phase *phase, + const axis2_env_t *env, + axis2_handler_t * handler); /** * This method assume that both the before and after can't be a same - * handler . That condition is not checked by this function. - * It should be checked befor calling this function + * handler . That condition is not checked by this function. + * It should be checked befor calling this function * @param handler */ axis2_status_t (AXIS2_CALL * - insert_before_and_after)(struct axis2_phase *phase, - const axis2_env_t *env, - axis2_handler_t * handler); + insert_before_and_after)(struct axis2_phase *phase, + const axis2_env_t *env, + axis2_handler_t * handler); axis2_status_t (AXIS2_CALL * - insert_handler_desc)(struct axis2_phase *phase, - const axis2_env_t *env, - axis2_handler_desc_t * handler_desc); + insert_handler_desc)(struct axis2_phase *phase, + const axis2_env_t *env, + axis2_handler_desc_t * handler_desc); /** * To get the all the handlers in the phase @@ -167,22 +167,22 @@ * @return */ axis2_array_list_t* (AXIS2_CALL * - get_handlers)(struct axis2_phase *phase, - const axis2_env_t *env); - - axis2_status_t (AXIS2_CALL * - invoke_start_from_handler)(struct axis2_phase *phase, - const axis2_env_t *env, - axis2_qname_t *qname, - struct axis2_msg_ctx *msg_ctx); - - - axis2_status_t (AXIS2_CALL * - free)(struct axis2_phase *phase, - const axis2_env_t *env); - + get_handlers)(struct axis2_phase *phase, + const axis2_env_t *env); + + axis2_status_t (AXIS2_CALL * + invoke_start_from_handler)(struct axis2_phase *phase, + const axis2_env_t *env, + axis2_qname_t *qname, + struct axis2_msg_ctx *msg_ctx); + + + axis2_status_t (AXIS2_CALL * + free)(struct axis2_phase *phase, + const axis2_env_t *env); + } axis2_phase_ops_t; - + /** * \brief Phase struct */ @@ -198,52 +198,52 @@ */ AXIS2_EXTERN axis2_phase_t* AXIS2_CALL axis2_phase_create(const axis2_env_t *env, - const axis2_char_t *phase_name); + const axis2_char_t *phase_name); #define AXIS2_PHASE_ADD_HANDLER_AT(phase, env, index, handler) \ - ((phase)->ops->add_handler_at(phase, env, index, handler)) - + ((phase)->ops->add_handler_at(phase, env, index, handler)) + #define AXIS2_PHASE_ADD_HANDLER(phase, env, handler) \ - ((phase)->ops->add_handler(phase, env, handler)) - + ((phase)->ops->add_handler(phase, env, handler)) + #define AXIS2_PHASE_ADD_HANDLER_DESC(phase, env, handler_desc) \ - ((phase)->ops->add_handler_desc(phase, env, handler_desc)) - + ((phase)->ops->add_handler_desc(phase, env, handler_desc)) + #define AXIS2_PHASE_INVOKE(phase, env, msg_ctx) \ - ((phase)->ops->invoke(phase, env, msg_ctx)) - + ((phase)->ops->invoke(phase, env, msg_ctx)) + #define AXIS2_PHASE_GET_NAME(phase, env) \ - ((phase)->ops->get_name(phase, env)) - + ((phase)->ops->get_name(phase, env)) + #define AXIS2_PHASE_GET_HANDLER_COUNT(phase, env) \ - ((phase)->ops->get_handler_count(phase, env)) - + ((phase)->ops->get_handler_count(phase, env)) + #define AXIS2_PHASE_SET_FIRST_HANDLER(phase, env, handler) \ - ((phase)->ops->set_first_handler(phase, env, handler)) - + ((phase)->ops->set_first_handler(phase, env, handler)) + #define AXIS2_PHASE_SET_LAST_HANDLER(phase, env, handler) \ - ((phase)->ops->set_last_handler(phase, env, handler)) - + ((phase)->ops->set_last_handler(phase, env, handler)) + #define AXIS2_PHASE_INSERT_BEFORE(phase, env, handler) \ - ((phase)->ops->insert_before(phase, env, handler)) - + ((phase)->ops->insert_before(phase, env, handler)) + #define AXIS2_PHASE_INSERT_AFTER(phase, env, handler) \ - ((phase)->ops->insert_after(phase, env, handler)) - + ((phase)->ops->insert_after(phase, env, handler)) + #define AXIS2_PHASE_INSERT_BEFORE_AND_AFTER(phase, env, handler) \ - ((phase)->ops->insert_before_and_after(phase, env, handler)) - + ((phase)->ops->insert_before_and_after(phase, env, handler)) + #define AXIS2_PHASE_INSERT_HANDLER_DESC(phase, env, handler_desc) \ - ((phase)->ops->insert_handler_desc(phase, env, handler_desc)) - + ((phase)->ops->insert_handler_desc(phase, env, handler_desc)) + #define AXIS2_PHASE_GET_HANDLERS(phase, env) \ - ((phase)->ops->get_handlers(phase, env)) - + ((phase)->ops->get_handlers(phase, env)) + #define AXIS2_PHASE_INVOKE_START_FROM_HANDLER(phase, env, qname, msg_ctx) \ - ((phase)->ops->invoke_start_from_handler(phase, env, qname, msg_ctx)) - + ((phase)->ops->invoke_start_from_handler(phase, env, qname, msg_ctx)) + #define AXIS2_PHASE_FREE(phase, env) \ - ((phase)->ops->free(phase, env)) + ((phase)->ops->free(phase, env)) /** @} */ Modified: webservices/axis2/trunk/c/include/axis2_phase_holder.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phase_holder.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_phase_holder.h (original) +++ webservices/axis2/trunk/c/include/axis2_phase_holder.h Sat Jun 3 20:09:08 2006 @@ -57,12 +57,12 @@ */ AXIS2_DECLARE_DATA struct axis2_phase_holder_ops { - /** De-allocate memory - * @return status code - */ - axis2_status_t (AXIS2_CALL * - free)(axis2_phase_holder_t *phase_holder, - const axis2_env_t *env); + /** De-allocate memory + * @return status code + */ + axis2_status_t (AXIS2_CALL * + free)(axis2_phase_holder_t *phase_holder, + const axis2_env_t *env); /** * Method isPhaseExist @@ -87,14 +87,14 @@ /** * this method is used to get the actual phase object given in the phase - * array list + * array list * @param phaseName * @return */ struct axis2_phase * (AXIS2_CALL * get_phase) (axis2_phase_holder_t *phase_holder, - const axis2_env_t *env, - axis2_char_t *phase_name); + const axis2_env_t *env, + axis2_char_t *phase_name); /** * This method is to build the transport phase , here load the corresponding @@ -106,9 +106,9 @@ */ axis2_status_t (AXIS2_CALL * build_transport_handler_chain) (axis2_phase_holder_t *phase_holder, - const axis2_env_t *env, - struct axis2_phase *phase, - axis2_array_list_t *handlers); + const axis2_env_t *env, + struct axis2_phase *phase, + axis2_array_list_t *handlers); @@ -119,7 +119,7 @@ */ AXIS2_DECLARE_DATA struct axis2_phase_holder { - axis2_phase_holder_ops_t *ops; + axis2_phase_holder_ops_t *ops; }; /** @@ -136,24 +136,24 @@ */ AXIS2_EXTERN axis2_phase_holder_t * AXIS2_CALL axis2_phase_holder_create_with_phases (const axis2_env_t *env, - axis2_array_list_t *phases); + axis2_array_list_t *phases); /*************************** Function macros **********************************/ #define AXIS2_PHASE_HOLDER_FREE(phase_holder, env) \ - ((phase_holder)->ops->free (phase_holder, env)) + ((phase_holder)->ops->free (phase_holder, env)) #define AXIS2_PHASE_HOLDER_IS_PHASE_EXIST(phase_holder, env, phase_name) \ - ((phase_holder)->ops->is_phase_exist (phase_holder, env, phase_name)) + ((phase_holder)->ops->is_phase_exist (phase_holder, env, phase_name)) #define AXIS2_PHASE_HOLDER_ADD_HANDLER(phase_holder, env, handler) \ - ((phase_holder)->ops->add_handler (phase_holder, env, handler)) + ((phase_holder)->ops->add_handler (phase_holder, env, handler)) #define AXIS2_PHASE_HOLDER_GET_PHASE(phase_holder, env, phase_name) \ - ((phase_holder)->ops->get_phase (phase_holder, env, phase_name)) + ((phase_holder)->ops->get_phase (phase_holder, env, phase_name)) #define AXIS2_PHASE_HOLDER_BUILD_TRANSPORT_HANDLER_CHAIN(phase_holder, env, phase, handlers) \ - ((phase_holder)->ops->build_transport_handler_chain (phase_holder, env, phase, handlers)) + ((phase_holder)->ops->build_transport_handler_chain (phase_holder, env, phase, handlers)) /*************************** End of function macros ***************************/ Modified: webservices/axis2/trunk/c/include/axis2_phase_resolver.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phase_resolver.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_phase_resolver.h (original) +++ webservices/axis2/trunk/c/include/axis2_phase_resolver.h Sat Jun 3 20:09:08 2006 @@ -67,12 +67,12 @@ */ AXIS2_DECLARE_DATA struct axis2_phase_resolver_ops { - /** De-allocate memory - * @return status code - */ - axis2_status_t (AXIS2_CALL *free)( + /** De-allocate memory + * @return status code + */ + axis2_status_t (AXIS2_CALL *free)( axis2_phase_resolver_t *phase_resolver, - const axis2_env_t *env); + const axis2_env_t *env); /** * Method buildchains @@ -141,7 +141,7 @@ */ AXIS2_DECLARE_DATA struct axis2_phase_resolver { - axis2_phase_resolver_ops_t *ops; + axis2_phase_resolver_ops_t *ops; }; /** @@ -174,28 +174,28 @@ /*************************** Function macros **********************************/ #define AXIS2_PHASE_RESOLVER_FREE(phase_resolver, env) \ - ((phase_resolver)->ops->free (phase_resolver, env)) + ((phase_resolver)->ops->free (phase_resolver, env)) #define AXIS2_PHASE_RESOLVER_BUILD_CHAINS(phase_resolver, env) \ - ((phase_resolver)->ops->build_chains (phase_resolver, env)) + ((phase_resolver)->ops->build_chains (phase_resolver, env)) #define AXIS2_PHASE_RESOLVER_BUILD_MODULE_OP(phase_resolver, env, op) \ - ((phase_resolver)->ops->build_module_op (phase_resolver, env, op)) + ((phase_resolver)->ops->build_module_op (phase_resolver, env, op)) #define AXIS2_PHASE_RESOLVER_BUILD_TRANSPORT_CHAINS(phase_resolver, env) \ - ((phase_resolver)->ops->build_transport_chains (phase_resolver, env)) + ((phase_resolver)->ops->build_transport_chains (phase_resolver, env)) #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_GLOBALLY(phase_resolver, env, module) \ - ((phase_resolver)->ops->engage_module_globally (phase_resolver, env, module)) + ((phase_resolver)->ops->engage_module_globally (phase_resolver, env, module)) #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_TO_SVC_FROM_GLOBAL(phase_resolver, env, svc, module_desc) \ - ((phase_resolver)->ops->engage_module_to_svc_from_global (phase_resolver, env, svc, module_desc)) + ((phase_resolver)->ops->engage_module_to_svc_from_global (phase_resolver, env, svc, module_desc)) #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_TO_SVC(phase_resolver, env, svc, module_desc) \ - ((phase_resolver)->ops->engage_module_to_svc (phase_resolver, env, svc, module_desc)) + ((phase_resolver)->ops->engage_module_to_svc (phase_resolver, env, svc, module_desc)) #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_TO_OP(phase_resolver, env, axis_op, module_desc) \ - ((phase_resolver)->ops->engage_module_to_op (phase_resolver, env, axis_op, module_desc)) + ((phase_resolver)->ops->engage_module_to_op (phase_resolver, env, axis_op, module_desc)) /*************************** End of function macros ***************************/ 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?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_phase_rule.h (original) +++ webservices/axis2/trunk/c/include/axis2_phase_rule.h Sat Jun 3 20:09:08 2006 @@ -46,60 +46,60 @@ AXIS2_DECLARE_DATA typedef struct axis2_phase_rule_ops { axis2_char_t* (AXIS2_CALL * - get_before) (struct axis2_phase_rule *phase_rule, + get_before) (struct axis2_phase_rule *phase_rule, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - set_before) (struct axis2_phase_rule *phase_rule, + set_before) (struct axis2_phase_rule *phase_rule, const axis2_env_t *env, - axis2_char_t *before); - + axis2_char_t *before); + axis2_char_t* (AXIS2_CALL * - get_after) (struct axis2_phase_rule * phase_rule, + get_after) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - set_after) (struct axis2_phase_rule * phase_rule, + set_after) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env, - axis2_char_t *after); - + axis2_char_t *after); + axis2_char_t* (AXIS2_CALL * - get_name) (struct axis2_phase_rule * phase_rule, + get_name) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - set_name) (struct axis2_phase_rule * phase_rule, + set_name) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env, - const axis2_char_t *name); - + const axis2_char_t *name); + axis2_bool_t (AXIS2_CALL * - is_phase_first) (struct axis2_phase_rule * phase_rule, + is_phase_first) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - set_phase_first) (struct axis2_phase_rule * phase_rule, + set_phase_first) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env, - axis2_bool_t phae_first); - + axis2_bool_t phae_first); + axis2_bool_t (AXIS2_CALL * - is_phase_last) (struct axis2_phase_rule * phase_rule, + is_phase_last) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - set_phase_last) (struct axis2_phase_rule * phase_rule, + set_phase_last) (struct axis2_phase_rule * phase_rule, const axis2_env_t *env, - axis2_bool_t phae_last); + axis2_bool_t phae_last); axis2_status_t (AXIS2_CALL * - free) (struct axis2_phase_rule *phase_rule, + free) (struct axis2_phase_rule *phase_rule, const axis2_env_t *env); - + struct axis2_phase_rule* (AXIS2_CALL * - clone) (struct axis2_phase_rule *phase_rule, + clone) (struct axis2_phase_rule *phase_rule, const axis2_env_t *env); - + } axis2_phase_rule_ops_t; - + /** * \brief Phase Rule struct */ @@ -115,43 +115,43 @@ */ AXIS2_EXTERN axis2_phase_rule_t* AXIS2_CALL axis2_phase_rule_create(const axis2_env_t *env, - axis2_char_t *phase_name); + axis2_char_t *phase_name); #define AXIS2_PHASE_RULE_GET_BEFORE(phase_rule, env) \ - ((phase_rule)->ops->get_before(phase_rule, env)) - + ((phase_rule)->ops->get_before(phase_rule, env)) + #define AXIS2_PHASE_RULE_SET_BEFORE(phase_rule, env, before) \ - ((phase_rule)->ops->set_before(phase_rule, env, before)) - + ((phase_rule)->ops->set_before(phase_rule, env, before)) + #define AXIS2_PHASE_RULE_GET_AFTER(phase_rule, env) \ - ((phase_rule)->ops->get_after(phase_rule, env)) - + ((phase_rule)->ops->get_after(phase_rule, env)) + #define AXIS2_PHASE_RULE_SET_AFTER(phase_rule, env, after) \ - ((phase_rule)->ops->set_after(phase_rule, env, after)) - + ((phase_rule)->ops->set_after(phase_rule, env, after)) + #define AXIS2_PHASE_RULE_GET_NAME(phase_rule, env) \ - ((phase_rule)->ops->get_name(phase_rule, env)) - + ((phase_rule)->ops->get_name(phase_rule, env)) + #define AXIS2_PHASE_RULE_SET_NAME(phase_rule, env, name)\ - ((phase_rule)->ops->set_name(phase_rule, env, name)) - + ((phase_rule)->ops->set_name(phase_rule, env, name)) + #define AXIS2_PHASE_RULE_IS_PHASE_FIRST(phase_rule, env) \ - ((phase_rule)->ops->is_phase_first(phase_rule, env)) - + ((phase_rule)->ops->is_phase_first(phase_rule, env)) + #define AXIS2_PHASE_RULE_SET_PHASE_FIRST(phase_rule, env, phase_first) \ - ((phase_rule)->ops->set_phase_first(phase_rule, env, phase_first)) - + ((phase_rule)->ops->set_phase_first(phase_rule, env, phase_first)) + #define AXIS2_PHASE_RULE_IS_PHASE_LAST(phase_rule, env) \ - ((phase_rule)->ops->is_phase_last(phase_rule, env)) - + ((phase_rule)->ops->is_phase_last(phase_rule, env)) + #define AXIS2_PHASE_RULE_SET_PHASE_LAST(phase_rule, env, phase_last) \ - ((phase_rule)->ops->set_phase_last(phase_rule, env, phase_last)) - + ((phase_rule)->ops->set_phase_last(phase_rule, env, phase_last)) + #define AXIS2_PHASE_RULE_FREE(phase_rule, env) \ - ((phase_rule)->ops->free(phase_rule, env)) - + ((phase_rule)->ops->free(phase_rule, env)) + #define AXIS2_PHASE_RULE_CLONE(phase_rule, env) \ - ((phase_rule)->ops->clone(phase_rule, env)) + ((phase_rule)->ops->clone(phase_rule, env)) /** @} */ Modified: webservices/axis2/trunk/c/include/axis2_phases_info.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phases_info.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_phases_info.h (original) +++ webservices/axis2/trunk/c/include/axis2_phases_info.h Sat Jun 3 20:09:08 2006 @@ -23,7 +23,7 @@ typedef struct axis2_phases_info_ops axis2_phases_info_ops_t; typedef struct axis2_phases_info axis2_phases_info_t; - + /** @defgroup axis2_phases_info Phases Info * @ingroup axis2_deployment * @{ @@ -35,7 +35,7 @@ */ struct axis2_phases_info_ops { - /** Deallocate memory + /** Deallocate memory * @return status code */ axis2_status_t (AXIS2_CALL *free) (axis2_phases_info_t *phases_info, @@ -107,7 +107,7 @@ */ struct axis2_phases_info { - axis2_phases_info_ops_t *ops; + axis2_phases_info_ops_t *ops; }; /** create Phases Info struct @@ -119,46 +119,46 @@ /**************************** Start of function macros ************************/ #define AXIS2_PHASES_INFO_FREE(phases_info, env) \ - ((phases_info)->ops->free (phases_info, env)) + ((phases_info)->ops->free (phases_info, env)) #define AXIS2_PHASES_INFO_SET_IN_PHASES(phases_info, env, in_phases) \ - ((phases_info)->ops->set_in_phases(phases_info, env, in_phases)) - + ((phases_info)->ops->set_in_phases(phases_info, env, in_phases)) + #define AXIS2_PHASES_INFO_SET_OUT_PHASES(phases_info, env, out_phases) \ - ((phases_info)->ops->set_out_phases(phases_info, env, out_phases)) + ((phases_info)->ops->set_out_phases(phases_info, env, out_phases)) #define AXIS2_PHASES_INFO_SET_IN_FAULTPHASES(phases_info, env, in_faultphases) \ - ((phases_info)->ops->set_in_faultphases(phases_info, env, in_faultphases)) + ((phases_info)->ops->set_in_faultphases(phases_info, env, in_faultphases)) #define AXIS2_PHASES_INFO_SET_OUT_FAULTPHASES(phases_info, env, out_faultphases) \ - ((phases_info)->ops->set_out_faultphases(phases_info, env, out_faultphases)) + ((phases_info)->ops->set_out_faultphases(phases_info, env, out_faultphases)) #define AXIS2_PHASES_INFO_GET_IN_PHASES(phases_info, env) \ - ((phases_info)->ops->get_in_phases(phases_info, env)) + ((phases_info)->ops->get_in_phases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_OUT_PHASES(phases_info, env) \ - ((phases_info)->ops->get_out_phases(phases_info, env)) + ((phases_info)->ops->get_out_phases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_IN_FAULTPHASES(phases_info, env) \ - ((phases_info)->ops->get_in_faultphases(phases_info, env)) + ((phases_info)->ops->get_in_faultphases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_OUT_FAULTPHASES(phases_info, env) \ - ((phases_info)->ops->get_out_faultphases(phases_info, env)) + ((phases_info)->ops->get_out_faultphases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_OP_IN_PHASES(phases_info, env) \ - ((phases_info)->ops->get_op_in_phases(phases_info, env)) + ((phases_info)->ops->get_op_in_phases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_OP_OUT_PHASES(phases_info, env) \ - ((phases_info)->ops->get_op_out_phases(phases_info, env)) + ((phases_info)->ops->get_op_out_phases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_OP_IN_FAULTPHASES(phases_info, env) \ - ((phases_info)->ops->get_op_in_faultphases(phases_info, env)) + ((phases_info)->ops->get_op_in_faultphases(phases_info, env)) #define AXIS2_PHASES_INFO_GET_OP_OUT_FAULTPHASES(phases_info, env) \ - ((phases_info)->ops->get_op_out_faultphases(phases_info, env)) + ((phases_info)->ops->get_op_out_faultphases(phases_info, env)) #define AXIS2_PHASES_INFO_SET_OP_PHASES(phases_info, env, axis2_opt) \ - ((phases_info)->ops->set_op_phases(phases_info, env, axis2_opt)) + ((phases_info)->ops->set_op_phases(phases_info, env, axis2_opt)) /**************************** End of function macros **************************/ Modified: webservices/axis2/trunk/c/include/axis2_relates_to.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_relates_to.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_relates_to.h (original) +++ webservices/axis2/trunk/c/include/axis2_relates_to.h Sat Jun 3 20:09:08 2006 @@ -51,8 +51,8 @@ * @return */ axis2_char_t* (AXIS2_CALL * - get_value)(struct axis2_relates_to *relates_to, - const axis2_env_t *env); + get_value)(struct axis2_relates_to *relates_to, + const axis2_env_t *env); /** * Method set_value @@ -60,8 +60,8 @@ * @param value */ axis2_status_t (AXIS2_CALL * - set_value)(struct axis2_relates_to *relates_to, - const axis2_env_t *env, + set_value)(struct axis2_relates_to *relates_to, + const axis2_env_t *env, axis2_char_t * value); /** @@ -70,8 +70,8 @@ * @return */ axis2_char_t* (AXIS2_CALL * - get_relationship_type)(struct axis2_relates_to *relates_to, - const axis2_env_t *env); + get_relationship_type)(struct axis2_relates_to *relates_to, + const axis2_env_t *env); /** * Method set_relationship_type @@ -79,8 +79,8 @@ * @param relationship_type */ axis2_status_t (AXIS2_CALL * - set_relationship_type)(struct axis2_relates_to *relates_to, - const axis2_env_t *env, + set_relationship_type)(struct axis2_relates_to *relates_to, + const axis2_env_t *env, axis2_char_t *relationship_type); /** @@ -88,11 +88,11 @@ */ axis2_status_t (AXIS2_CALL * - free) (struct axis2_relates_to *relates_to, + free) (struct axis2_relates_to *relates_to, const axis2_env_t *env); } axis2_relates_to_ops_t; - + /** * \brief Dispatcher struct */ @@ -111,23 +111,23 @@ */ AXIS2_EXTERN axis2_relates_to_t* AXIS2_CALL axis2_relates_to_create(const axis2_env_t *env, - axis2_char_t *value, - axis2_char_t *relationship_type); + axis2_char_t *value, + axis2_char_t *relationship_type); #define AXIS2_RELATES_TO_GET_VALUE(relates_to, env) \ - ((relates_to)->ops->get_value(relates_to, env)) - + ((relates_to)->ops->get_value(relates_to, env)) + #define AXIS2_RELATES_TO_SET_VALUE(relates_to, env, vlaue) \ - ((relates_to)->ops->set_value(relates_to, env, vlaue)) - + ((relates_to)->ops->set_value(relates_to, env, vlaue)) + #define AXIS2_RELATES_TO_GET_RELATIONSHIP_TYPE(relates_to, env) \ - ((relates_to)->ops->get_relationship_type(relates_to, env)) - + ((relates_to)->ops->get_relationship_type(relates_to, env)) + #define AXIS2_RELATES_TO_SET_RELATIONSHIP_TYPE(relates_to, env, relationship_type) \ - ((relates_to)->ops->set_relationship_type(relates_to, env, relationship_type)) - + ((relates_to)->ops->set_relationship_type(relates_to, env, relationship_type)) + #define AXIS2_RELATES_TO_FREE(relates_to, env) \ - ((relates_to)->ops->free(relates_to, env)) + ((relates_to)->ops->free(relates_to, env)) /** @} */ Modified: webservices/axis2/trunk/c/include/axis2_rest_sender.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_rest_sender.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_rest_sender.h (original) +++ webservices/axis2/trunk/c/include/axis2_rest_sender.h Sat Jun 3 20:09:08 2006 @@ -50,25 +50,25 @@ */ AXIS2_DECLARE_DATA struct axis2_rest_sender_ops { - axis2_status_t (AXIS2_CALL *send) + axis2_status_t (AXIS2_CALL *send) (axis2_rest_sender_t *sender, const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx, - axis2_om_node_t *out, - axis2_char_t *str_url); - - axis2_status_t (AXIS2_CALL *set_chunked) + axis2_om_node_t *out, + axis2_char_t *str_url); + + axis2_status_t (AXIS2_CALL *set_chunked) (axis2_rest_sender_t *sender, const axis2_env_t *env, axis2_bool_t chunked); - - axis2_status_t (AXIS2_CALL *set_om_output) + + axis2_status_t (AXIS2_CALL *set_om_output) (axis2_rest_sender_t *sender, const axis2_env_t *env, axis2_om_output_t *om_output); - - axis2_status_t (AXIS2_CALL *set_http_version) - (axis2_rest_sender_t *sender, - const axis2_env_t *env, axis2_char_t *version); - - axis2_status_t (AXIS2_CALL *free) + + axis2_status_t (AXIS2_CALL *set_http_version) + (axis2_rest_sender_t *sender, + const axis2_env_t *env, axis2_char_t *version); + + axis2_status_t (AXIS2_CALL *free) (axis2_rest_sender_t *sender, const axis2_env_t *env); }; @@ -76,19 +76,19 @@ axis2_status_t AXIS2_CALL axis2_rest_sender_get_header_info - (axis2_rest_sender_t *sender, + (axis2_rest_sender_t *sender, const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx, - axis2_http_simple_response_t *response); + axis2_http_simple_response_t *response); axis2_status_t AXIS2_CALL axis2_rest_sender_process_response - (axis2_rest_sender_t *sender, + (axis2_rest_sender_t *sender, const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx, - axis2_http_simple_response_t *response); + axis2_http_simple_response_t *response); axis2_status_t AXIS2_CALL axis2_rest_sender_get_timeout_values - (axis2_rest_sender_t *sender, + (axis2_rest_sender_t *sender, const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx); /** @@ -97,14 +97,14 @@ */ AXIS2_DECLARE_DATA struct axis2_rest_sender { - axis2_rest_sender_ops_t *ops; + axis2_rest_sender_ops_t *ops; }; AXIS2_EXTERN axis2_rest_sender_t * AXIS2_CALL axis2_rest_sender_create(const axis2_env_t *env); -/********************* Start of function macros ***************************/ +/********************* Start of function macros ***************************/ #define AXIS2_REST_SENDER_SEND(sender, env, msg_ctx, output, url)\ ((sender)->ops->send (sender, env, msg_ctx,output, url)) Modified: webservices/axis2/trunk/c/include/axis2_simple_http_svr_conn.h URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_simple_http_svr_conn.h?rev=411506&r1=411505&r2=411506&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_simple_http_svr_conn.h (original) +++ webservices/axis2/trunk/c/include/axis2_simple_http_svr_conn.h Sat Jun 3 20:09:08 2006 @@ -37,7 +37,7 @@ typedef struct axis2_simple_http_svr_conn_ops axis2_simple_http_svr_conn_ops_t; typedef struct axis2_simple_http_svr_conn axis2_simple_http_svr_conn_t; - + /** * @ingroup axis2_core_transport_http * @{ @@ -49,56 +49,56 @@ AXIS2_DECLARE_DATA struct axis2_simple_http_svr_conn_ops { axis2_status_t (AXIS2_CALL * - close) (axis2_simple_http_svr_conn_t *svr_conn, + close) (axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - + axis2_bool_t (AXIS2_CALL * - is_open) (axis2_simple_http_svr_conn_t *svr_conn, + is_open) (axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - set_keep_alive) (axis2_simple_http_svr_conn_t *svr_conn, + set_keep_alive) (axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env, - axis2_bool_t keep_alive); - + axis2_bool_t keep_alive); + axis2_bool_t (AXIS2_CALL * - is_keep_alive) (axis2_simple_http_svr_conn_t *svr_conn, + is_keep_alive) (axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - + axis2_stream_t* (AXIS2_CALL * - get_stream) (axis2_simple_http_svr_conn_t *svr_conn, + get_stream) (axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - - + + axis2_http_response_writer_t* (AXIS2_CALL * - get_writer)(axis2_simple_http_svr_conn_t *svr_conn, + get_writer)(axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - + axis2_http_simple_request_t* (AXIS2_CALL * - read_request)(axis2_simple_http_svr_conn_t *svr_conn, + read_request)(axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - write_response)(axis2_simple_http_svr_conn_t *svr_conn, + write_response)(axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env, axis2_http_simple_response_t *response); - + axis2_status_t (AXIS2_CALL * - set_rcv_timeout)(axis2_simple_http_svr_conn_t *svr_conn, + set_rcv_timeout)(axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env, - int timeout); - + int timeout); + axis2_status_t (AXIS2_CALL * - set_snd_timeout)(axis2_simple_http_svr_conn_t *svr_conn, + set_snd_timeout)(axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env, - int timeout); - + int timeout); + axis2_char_t* (AXIS2_CALL * - get_svr_ip) (axis2_simple_http_svr_conn_t *svr_conn, + get_svr_ip) (axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); - + axis2_status_t (AXIS2_CALL * - free)(axis2_simple_http_svr_conn_t *svr_conn, + free)(axis2_simple_http_svr_conn_t *svr_conn, const axis2_env_t *env); }; --------------------------------------------------------------------- To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org For additional commands, e-mail: axis-cvs-help@ws.apache.org