| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef AXIS2_MSG_CTX_H |
| #define AXIS2_MSG_CTX_H |
| |
| /** |
| * @defgroup axis2_msg_ctx message context |
| * @ingroup axis2_context |
| * message context captures all state information related to a message |
| * invocation. It holds information on the service and operation to be invoked |
| * as well as context hierarchy information related to the service and operation. |
| * It also has information on transports, that are to be used in invocation. The |
| * phase information is kept, along with the phase at which message invocation was |
| * paused as well as the handler in the phase from which the invocation is to be |
| * resumed. message context would hold the request SOAP message along the out |
| * path and would capture response along the in path. |
| * message context also has information on various engine specific information, |
| * such as if it should be doing MTOM, REST. |
| * As message context is inherited form context, it has the capability of |
| * storing user defined properties. |
| * @{ |
| */ |
| |
| /** |
| * @file axis2_msg_ctx.h |
| */ |
| |
| #include <axis2_defines.h> |
| #include <axis2_env.h> |
| #include <axis2_ctx.h> |
| #include <axis2_relates_to.h> |
| #include <axis2_param.h> |
| #include <axis2_handler_desc.h> |
| #include <axis2_qname.h> |
| #include <axis2_msg_info_headers.h> |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| /** transport headers */ |
| #define AXIS2_TRANSPORT_HEADERS "AXIS2_TRANSPORT_HEADERS" |
| |
| /** transport in */ |
| #define AXIS2_TRANSPORT_OUT "AXIS2_TRANSPORT_OUT" |
| |
| /** transport out */ |
| #define AXIS2_TRANSPORT_IN "AXIS2_TRANSPORT_IN" |
| |
| /** character set encoding */ |
| #define AXIS2_CHARACTER_SET_ENCODING "AXIS2_CHARACTER_SET_ENCODING" |
| |
| /** UTF_8; This is the 'utf-8' value for AXIS2_CHARACTER_SET_ENCODING property */ |
| #define AXIS2_UTF_8 "UTF-8" |
| |
| /** UTF_16; This is the 'utf-16' value for AXIS2_CHARACTER_SET_ENCODING property */ |
| #define AXIS2_UTF_16 "utf-16" |
| |
| /** default char set encoding; This is the default value for AXIS2_CHARACTER_SET_ENCODING property */ |
| #define AXIS2_DEFAULT_CHAR_SET_ENCODING "UTF-8" |
| |
| /** transport succeeded */ |
| #define AXIS2_TRANSPORT_SUCCEED "AXIS2_TRANSPORT_SUCCEED" |
| |
| /** HTTP Client */ |
| #define AXIS2_HTTP_CLIENT "AXIS2_HTTP_CLIENT" |
| |
| /** Transport URL */ |
| #define AXIS2_TRANSPORT_URL "TransportURL" |
| |
| /* Message flows */ |
| /** In flow */ |
| /*#define AXIS2_IN_FLOW 1*/ |
| |
| /** In fault flow */ |
| /*#define AXIS2_IN_FAULT_FLOW 2*/ |
| |
| /** Out flow */ |
| /*#define AXIS2_OUT_FLOW 3*/ |
| |
| /** Out fault flow */ |
| /*#define AXIS2_OUT_FAULT_FLOW 4*/ |
| |
| /** Type name for struct axis2_msg_ctx_ops */ |
| typedef struct axis2_msg_ctx_ops axis2_msg_ctx_ops_t; |
| /** Type name for struct axis2_msg_ctx */ |
| typedef struct axis2_msg_ctx axis2_msg_ctx_t; |
| |
| struct axis2_svc; |
| struct axis2_op; |
| |
| struct axis2_conf_ctx; |
| struct axis2_svc_grp_ctx; |
| struct axis2_svc_ctx; |
| struct axis2_op_ctx; |
| struct axis2_conf; |
| struct axiom_soap_envelope; |
| struct axis2_options; |
| |
| /** |
| * message context ops struct. |
| * Encapsulator struct for ops of axis2_msg_ctx. |
| */ |
| struct axis2_msg_ctx_ops |
| { |
| /** |
| * Gets the base, which is of type context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to base context struct |
| */ |
| axis2_ctx_t *(AXIS2_CALL * |
| get_base)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets parent. Parent of a message context is of type operation. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to operation which is the parent |
| */ |
| struct axis2_op_ctx *(AXIS2_CALL * |
| get_parent)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets parent. Parent of a message context is of type operation. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param parent pointer to parent operation |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_parent)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_op_ctx *parent); |
| |
| /** |
| * Frees message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| free)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Initializes the message context. Based on the transport, service and |
| * operation qnames set on top of message context, correct instances of |
| * those struct instances would be extracted from configuration and |
| * set within message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param conf pointer to configuration |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| init)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_conf *conf); |
| |
| /** |
| * Gets WS-Addressing fault to address. Fault to address tells where to |
| * send the fault in case there is an error. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to endpoint reference struct representing the fault |
| * to address, returns a reference not a cloned copy |
| */ |
| axis2_endpoint_ref_t *(AXIS2_CALL * |
| get_fault_to)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets WS-Addressing from endpoint. From address tells where the |
| * request came from. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to endpoint reference struct representing the from |
| * address, returns a reference not a cloned copy |
| */ |
| axis2_endpoint_ref_t *(AXIS2_CALL * |
| get_from)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Checks if there is a SOAP fault on in flow. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if there is an in flow fault, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_in_fault_flow)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets the SOAP envelope. This SOAP envelope could be either request |
| * SOAP envelope or the response SOAP envelope, based on the state |
| * the message context is in. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to SOAP envelope stored within message context |
| */ |
| struct axiom_soap_envelope *(AXIS2_CALL * |
| get_soap_envelope)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets fault SOAP envelope. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to fault SOAP envelope stored within message context |
| */ |
| struct axiom_soap_envelope *(AXIS2_CALL * |
| get_fault_soap_envelope)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets message ID. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return message ID string corresponding to the message the message |
| * context is related to |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_msg_id)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets process fault status. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if process fault is on, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_process_fault)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets relates to information for the message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to relates to struct |
| */ |
| axis2_relates_to_t *(AXIS2_CALL * |
| get_relates_to)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets WS-Addressing reply to endpoint. Reply to address tells where |
| * the the response should be sent to. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to endpoint reference struct representing the reply |
| * to address, returns a reference not a cloned copy |
| */ |
| axis2_endpoint_ref_t *(AXIS2_CALL * |
| get_reply_to)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Checks the response status, whether it is written or not. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if response is already written, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_response_written)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Checks if it is on the server side that the message is being dealt |
| * with, or on the client side. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if it is server side, AXIS2_FALSE if it is client |
| * side |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_server_side)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets WS-Addressing to endpoint. To address tells where message should |
| * be sent to. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to endpoint reference struct representing the |
| * to address, returns a reference not a cloned copy |
| */ |
| axis2_endpoint_ref_t *(AXIS2_CALL * |
| get_to)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets WS-Addressing fault to endpoint. Fault to address tells where |
| * the fault message should be sent when there is an error. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param reference pointer to endpoint reference representing fault to |
| * address. message context assumes the ownership of endpoint struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_fault_to)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_endpoint_ref_t *reference); |
| |
| /** |
| * Sets WS-Addressing from endpoint. From address tells where |
| * the message came from. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param reference pointer to endpoint reference representing from |
| * address. message context assumes the ownership of endpoint struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_from)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_endpoint_ref_t *reference); |
| |
| /** |
| * Sets in fault flow status. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param in_fault_flow AXIS2_TRUE if there is a fault on in path, |
| * else AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_in_fault_flow)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t in_fault_flow); |
| |
| /** |
| * Sets SOAP envelope. The fact that if it is the request SOAP envelope |
| * or that of response depends on the current status represented by |
| * message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param soap_envelope pointer to SOAP envelope, message context |
| * assumes ownership of SOAP envelope |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_soap_envelope)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axiom_soap_envelope *soap_envelope); |
| |
| /** |
| * Sets fault SOAP envelope. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param soap_envelope pointer to SOAP envelope, message context |
| * assumes ownership of SOAP envelope |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_fault_soap_envelope)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axiom_soap_envelope *soap_envelope); |
| |
| /** |
| * Sets message ID. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param message_id message ID string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_message_id)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *message_id); |
| |
| /** |
| * Sets process fault bool value. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param process_fault AXIS2_TRUE if SOAP faults are to be processed, |
| * else AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_process_fault)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t process_fault); |
| |
| /** |
| * Sets relates to struct. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param reference pointer to relates to struct, message context |
| * assumes ownership of the struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_relates_to)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_relates_to_t *reference); |
| |
| /** |
| * Sets WS-Addressing reply to address indicating the location to which |
| * the reply would be sent. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param reference pointer to endpoint reference representing reply to |
| * address |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_reply_to)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_endpoint_ref_t *referance); |
| |
| /** |
| * Sets the bool value indicating the status of response. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param response_written AXIS2_TRUE if response is written, else |
| * AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_response_written)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t response_written); |
| |
| /** |
| * Sets the bool value indicating if it is the server side or the |
| * client side. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param server_side AXIS2_TRUE if it is server side, AXIS2_FALSE if it |
| * is client side |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_server_side)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t server_side); |
| |
| /** |
| * Sets WS-Addressing to address. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param reference pointer to endpoint reference struct representing |
| * the address where the request should be sent to. message context |
| * assumes ownership of endpoint struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_to)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_endpoint_ref_t *referance); |
| |
| /** |
| * Gets the bool value indicating if it is required to have a new thread |
| * for the invocation, or if the same thread of execution could be used. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if new thread is required, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_new_thread_required)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the bool value indicating if it is required to have a new thread |
| * for the invocation, or if the same thread of execution could be used. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param new_thread_required AXIS2_TRUE if a new thread is required, |
| * else AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_new_thread_required)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t new_thread_required); |
| |
| /** |
| * Sets WS-Addressing action. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param action_uri WSA action URI string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_wsa_action)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *action_uri); |
| |
| /** |
| * Gets WS-Addressing action. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to WSA action URI string |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_wsa_action)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets WS-Addressing message ID. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param message_id pointer to message ID string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_wsa_message_id)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *message_id); |
| |
| /** |
| * Gets WS-Addressing message ID. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return WSA message ID string |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_wsa_message_id)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets WS-Addressing message information headers. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to message information headers struct with |
| * WS-Addressing information. Returns a reference, not a cloned copy |
| */ |
| axis2_msg_info_headers_t *(AXIS2_CALL * |
| get_msg_info_headers)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets the bool value indicating the paused status. It is possible |
| * to pause the engine invocation by any handler. By calling this method |
| * one can find out if some handler has paused the invocation. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if message context is paused, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_paused)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the bool value indicating the paused status of invocation. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param paused paused |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_paused)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t paused); |
| |
| /** |
| * Gets the bool value indicating the keep value status. It is possible |
| * to keep alive the message context by any handler. By calling this method |
| * one can see whether it is possible to clean the message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if message context is keep alive, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| is_keep_alive)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the bool value indicating the keep alive status of invocation. |
| * By setting this one can indicate the engine not to clean the message |
| * context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param keep_alive keep alive |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_keep_alive)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t keep_alive); |
| |
| |
| /** |
| * Gets transport in description. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to transport in description struct, returns a |
| * reference not a cloned copy |
| */ |
| struct axis2_transport_in_desc *(AXIS2_CALL * |
| get_transport_in_desc)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets transport out description. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to transport out description struct, returns a |
| * reference not a cloned copy |
| */ |
| struct axis2_transport_out_desc *(AXIS2_CALL * |
| get_transport_out_desc)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets transport in description. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param transport_in_desc pointer to transport in description struct, |
| * message context does not assume the ownership of the struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_transport_in_desc)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_transport_in_desc *transport_in_desc); |
| |
| /** |
| * Sets transport out description. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param transport_out_desc pointer to transport out description, |
| * message context does not assume the ownership of the struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_transport_out_desc)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_transport_out_desc *transport_out_desc); |
| |
| /** |
| * Gets operation context related to the operation that this message |
| * context is related to. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to operation context struct |
| */ |
| struct axis2_op_ctx *(AXIS2_CALL * |
| get_op_ctx)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets operation context related to the operation that this message |
| * context is related to. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param op_ctx pointer to operation context, message context does not |
| * assume the ownership of operation context |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_op_ctx)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_op_ctx *op_ctx); |
| |
| /** |
| * Gets the bool value indicating the output written status. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if output is written, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_output_written)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the bool value indicating the output written status. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param output_written AXIS2_TRUE if output is written, else AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_output_written)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t output_written); |
| |
| /** |
| * Gets the ID of service context that relates to the service that is |
| * related to the message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return service context ID string |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_svc_ctx_id)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the ID of service context that relates to the service that is |
| * related to the message context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc_ctx_id The service context ID string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_svc_ctx_id)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *svc_ctx_id); |
| |
| /** |
| * Gets configuration context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to configuration context |
| */ |
| struct axis2_conf_ctx *(AXIS2_CALL * |
| get_conf_ctx)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets service context that relates to the service that the message |
| * context is related to. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to message context struct |
| */ |
| struct axis2_svc_ctx *(AXIS2_CALL * |
| get_svc_ctx)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets configuration context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param conf_ctx pointer to configuration context struct, message |
| * context does not assume the ownership of struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_conf_ctx)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_conf_ctx *conf_ctx); |
| |
| /** |
| * Sets service context. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc_ctx pointer to service context struct, message |
| * context does not assume the ownership of struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_svc_ctx)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_svc_ctx *svc_ctx); |
| |
| /** |
| * Sets message information headers. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param msg_info_headers pointer to message information headers, |
| * message context assumes the ownership of the struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_msg_info_headers)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_msg_info_headers_t *msg_info_headers); |
| |
| /** |
| * Gets configuration descriptor parameter with given key. This method |
| * recursively search the related description hierarchy for the parameter |
| * with given key until it is found or the parent of the description |
| * hierarchy is reached. The order of search is as follows: |
| * 1. search in operation description, if its there return |
| * 2. if the parameter is not found in operation or operation is NULL, |
| * search in service |
| * 3. if the parameter is not found in service or service is NULL search |
| * in configuration |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param key parameter key |
| * @return pointer to parameter struct corresponding to the given key |
| */ |
| axis2_param_t *(AXIS2_CALL * |
| get_parameter)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *key); |
| |
| /** |
| * Gets parameters related to a named module and a given handler |
| * description. The order of searching for parameter is as follows: |
| * 1. search in module configuration stored inside corresponding operation |
| * description if its there |
| * 2. search in corresponding operation if its there |
| * 3. search in module configurations stored inside corresponding |
| * service description if its there |
| * 4. search in corresponding service description if its there |
| * 5. search in module configurations stored inside configuration |
| * 6. search in configuration for parameters |
| * 7. get the corresponding module and search for the parameters |
| * 8. search in handler description for the parameter |
| * @param msg_ctx pointer to message context |
| * @param env pointer to environment struct |
| * @param key parameter key |
| * @param module_name name of the module |
| * @param handler_desc pointer to handler description |
| * @return pointer to parameter |
| */ |
| axis2_param_t *(AXIS2_CALL * |
| get_module_parameter)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *key, |
| const axis2_char_t *module_name, |
| axis2_handler_desc_t *handler_desc); |
| |
| /** |
| * Gets property corresponding to the given key. |
| * @param msg_ctx pointer to message context |
| * @param env pointer to environment struct |
| * @param key key string with which the property is stored |
| * @param persistent AXIS2_TRUE if the property is to be retrieved from |
| * persistent map, AXIS2_FALSE if the property is to be retrieved from |
| * non-persistent map |
| * @return pointer to property struct |
| */ |
| axis2_property_t *(AXIS2_CALL * |
| get_property)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *key, |
| const axis2_bool_t persistent); |
| |
| /** |
| * Sets property with given key. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param key key string |
| * @param value property to be stored |
| * @param persistent AXIS2_TRUE if the property is to be stored in |
| * persistent map, AXIS2_FALSE if the property is to be stored in |
| * non-persistent map |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_property)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *key, |
| axis2_property_t *value, |
| const axis2_bool_t persistent); |
| /** |
| * Gets the QName of the handler at which invocation was paused. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to QName of the paused handler |
| */ |
| const axis2_qname_t *(AXIS2_CALL * |
| get_paused_handler_name)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets the name of the phase at which the invocation was paused. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return name string of the paused phase. |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_paused_phase_name)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the name of the phase at which the invocation was paused. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param paused_phase_name paused phase name string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_paused_phase_name)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *paused_phase_name); |
| |
| /** |
| * Gets SOAP action. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return SOAP action string |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_soap_action)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets SOAP action. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param soap_action SOAP action string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_soap_action)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *soap_action); |
| |
| /** |
| * Gets the boolean value indicating if MTOM is enabled or not. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if MTOM is enabled, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_doing_mtom)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the boolean value indicating if MTOM is enabled or not. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param doing_mtom AXIS2_TRUE if MTOM is enabled, else AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_doing_mtom)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t doing_mtom); |
| |
| /** |
| * Gets the boolean value indicating if REST is enabled or not. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if REST is enabled, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_doing_rest)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the boolean value indicating if REST is enabled or not. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param doing_rest AXIS2_TRUE if REST is enabled, else AXIS2_FALSE |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_doing_rest)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t doing_rest); |
| |
| /** |
| * Sets the boolean value indicating if REST should be done through |
| * HTTP POST or HTTP GET. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param do_rest_through_post AXIS2_TRUE if REST is to be done with |
| * HTTP POST, else AXIS2_FALSE if REST is to be done with HTTP GET |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_do_rest_through_post)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t do_rest_through_post); |
| |
| |
| /** |
| * Sets the boolean value indicating if REST should be done through |
| * HTTP POST or HTTP GET. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if REST is to be done with HTTP POST, else |
| * AXIS2_FALSE if REST is to be done with HTTP GET |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_do_rest_through_post)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets the bool value indicating the SOAP version being used either |
| * SOAP 1.1 or SOAP 1.2 |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if SOAP 1.1 is being used, else AXIS2_FALSE if |
| * SOAP 1.2 is being used |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| get_is_soap_11)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the bool value indicating the SOAP version being used either |
| * SOAP 1.1 or SOAP 1.2 |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param is_soap11 AXIS2_TRUE if SOAP 1.1 is being used, else |
| * AXIS2_FALSE if SOAP 1.2 is being used |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_is_soap_11)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_bool_t is_soap11); |
| |
| /** |
| * Gets service group context. The returned service group context |
| * relates to the service group to which the service, related to the |
| * message context, belongs. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to service group struct |
| */ |
| struct axis2_svc_grp_ctx *(AXIS2_CALL * |
| get_svc_grp_ctx)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets service group context. The returned service group context |
| * relates to the service group to which the service, related to the |
| * message context, belongs. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc_grp_ctx pointer to service group context |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_svc_grp_ctx)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_svc_grp_ctx *svc_grp_ctx); |
| |
| |
| /** |
| * Gets the operation that is to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to operation, returns a reference not a cloned copy |
| */ |
| struct axis2_op *(AXIS2_CALL * |
| get_op)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| |
| /** |
| * Sets the operation that is to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param op pointer to operation, message context does not assume the |
| * ownership of operation |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_op)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_op *op); |
| |
| |
| /** |
| * Gets the service to which the operation to be invoked belongs. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to service struct, returns a reference not a cloned copy |
| */ |
| struct axis2_svc *(AXIS2_CALL * |
| get_svc)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| |
| /** |
| * Sets the service to which the operation to be invoked belongs. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc pointer to service struct, message context does not assume |
| * the ownership of struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_svc)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_svc *svc); |
| |
| /** |
| * Gets the service group to which the service to be invoked belongs. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to service group struct, returns a reference not |
| * a cloned copy |
| */ |
| struct axis2_svc_grp *(AXIS2_CALL * |
| get_svc_grp)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the service group to which the service to be invoked belongs. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc_grp pointer to service group struct, message context does |
| * not assume the ownership of the struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_svc_grp)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_svc_grp *svc_grp); |
| |
| |
| /** |
| * Gets the service group context ID. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return service group context ID string |
| */ |
| const axis2_char_t *(AXIS2_CALL * |
| get_svc_grp_ctx_id)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the service group context ID. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc_grp_ctx_id service group context ID string |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_svc_grp_ctx_id)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const axis2_char_t *svc_grp_ctx_id); |
| |
| /** |
| * Finds the service to be invoked. This function is used by dispatchers |
| * to locate the service to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer to service to be invoked |
| */ |
| struct axis2_svc *(AXIS2_CALL * |
| find_svc)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| /** |
| * Finds the operation to be invoked in the given service. This function |
| * is used by dispatchers to locate the operation to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param svc pointer to service to whom the operation belongs |
| * @return pointer to the operation to be invoked |
| */ |
| struct axis2_op *(AXIS2_CALL * |
| find_op)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_svc *svc); |
| |
| /** |
| * Gets the bool value indicating the paused status. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return AXIS2_TRUE if invocation is paused, else AXIS2_FALSE |
| */ |
| axis2_bool_t (AXIS2_CALL * |
| is_paused)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the options to be used in invocation. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param options pointer to options struct , message context does not |
| * assume the ownership of the struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_options )( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| struct axis2_options *options); |
| |
| /** |
| * Sets the flow to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param flow int value indicating the flow |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_flow )( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| int flow); |
| |
| /** |
| * Gets the flow to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return int value indicating the flow |
| */ |
| int (AXIS2_CALL * |
| get_flow )( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets the execution chain to be invoked. The execution chain is a |
| * list of phases containing the handlers to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param execution_chain pointer array list containing the list of |
| * handlers that constitute the execution chain. message context does |
| * not assume the ownership of the array list |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_execution_chain)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| axis2_array_list_t *execution_chain); |
| |
| /** |
| * Gets the execution chain to be invoked. The execution chain is a |
| * list of phases containing the handlers to be invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return pointer array list containing the list of handlers that |
| * constitute the execution chain. message context does not assume |
| * the ownership of the array list |
| */ |
| axis2_array_list_t *(AXIS2_CALL * |
| get_execution_chain)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Sets current handler index, indicating which handler is currently |
| * being invoked in the execution chain |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param index index of currently executed handler |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_current_handler_index)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const int index); |
| |
| /** |
| * Gets current handler index, indicating which handler is currently |
| * being invoked in the execution chain |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return index of currently executed handler |
| */ |
| int (AXIS2_CALL * |
| get_current_handler_index)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets paused handler index, indicating at which handler the execution |
| * chain was paused. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return index of handler at which invocation was paused |
| */ |
| int (AXIS2_CALL * |
| get_paused_handler_index)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| |
| /** |
| * Sets index of the current phase being invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @param index index of current phase |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| set_current_phase_index)( |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env, |
| const int index); |
| |
| /** |
| * Gets index of the current phase being invoked. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return index of current phase |
| */ |
| int (AXIS2_CALL * |
| get_current_phase_index)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| |
| /** |
| * Gets the phase at which the invocation was paused. |
| * @param msg_ctx message context |
| * @param env pointer to environment struct |
| * @return index of paused phase |
| */ |
| int (AXIS2_CALL * |
| get_paused_phase_index)( |
| const axis2_msg_ctx_t *msg_ctx, |
| const axis2_env_t *env); |
| }; |
| |
| /** |
| * message context struct. |
| */ |
| struct axis2_msg_ctx |
| { |
| /** operations of message context */ |
| axis2_msg_ctx_ops_t *ops; |
| }; |
| |
| |
| /** |
| * Creates a message context struct instance. |
| * @param env pointer to environment struct |
| * @param conf_ctx pointer to configuration context struct, message context |
| * does not assume the ownership of the struct |
| * @param transport_in_desc pointer to transport in description struct, |
| * message context does not assume the ownership of the struct |
| * @param transport_out_desc pointer to transport out description struct, |
| * message context does not assume the ownership of the struct |
| * @return pointer to newly created message context instance |
| */ |
| AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL |
| axis2_msg_ctx_create ( |
| const axis2_env_t *env, |
| struct axis2_conf_ctx *conf_ctx, |
| struct axis2_transport_in_desc *transport_in_desc, |
| struct axis2_transport_out_desc *transport_out_des); |
| |
| |
| /** Gets base context struct. |
| @sa axis2_msg_ctx_ops#get_base */ |
| #define AXIS2_MSG_CTX_GET_BASE(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_base(msg_ctx, env)) |
| |
| /** Gets parent operation context. |
| @sa axis2_msg_ctx_ops#get_parent */ |
| #define AXIS2_MSG_CTX_GET_PARENT(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_parent(msg_ctx, env)) |
| |
| /** Sets parent operation context. |
| @sa axis2_msg_ctx_ops#set_parent */ |
| #define AXIS2_MSG_CTX_SET_PARENT(msg_ctx, env, parent) \ |
| ((msg_ctx)->ops->get_parent(msg_ctx, env, parent)) |
| |
| /** Frees message context. |
| @sa axis2_msg_ctx_ops#free */ |
| #define AXIS2_MSG_CTX_FREE(msg_ctx, env) \ |
| ((msg_ctx)->ops->free(msg_ctx, env)) |
| |
| /** Initializes message context. |
| @sa axis2_msg_ctx_ops#init */ |
| #define AXIS2_MSG_CTX_INIT(msg_ctx, env, conf) \ |
| ((msg_ctx)->ops->init(msg_ctx, env, conf)) |
| |
| /** Gets WS-Addressing fault to address. |
| @sa axis2_msg_ctx_ops#get_fault_to */ |
| #define AXIS2_MSG_CTX_GET_FAULT_TO(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_fault_to(msg_ctx, env)) |
| |
| /** Gets WS-Addressing from address. |
| @sa axis2_msg_ctx_ops#get_from */ |
| #define AXIS2_MSG_CTX_GET_FROM(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_from(msg_ctx, env)) |
| |
| /** Gets in fault flow. |
| @sa axis2_msg_ctx_ops#get_in_fault_flow */ |
| #define AXIS2_MSG_CTX_GET_IN_FAULT_FLOW(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_in_fault_flow(msg_ctx, env)) |
| |
| /** Gets SOAP envelope. |
| @sa axis2_msg_ctx_ops#get_soap_envelope */ |
| #define AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_soap_envelope(msg_ctx, env)) |
| |
| /** Gets fault SOAP envelope. |
| @sa axis2_msg_ctx_ops#get_fault_soap_envelope */ |
| #define AXIS2_MSG_CTX_GET_FAULT_SOAP_ENVELOPE(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_fault_soap_envelope(msg_ctx, env)) |
| |
| /** Gets message ID. |
| @sa axis2_msg_ctx_ops#get_msg_id */ |
| #define AXIS2_MSG_CTX_GET_MSG_ID(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_msg_id(msg_ctx, env)) |
| |
| /** Gets bool value indicating if to process SOAP fault or not. |
| @sa axis2_msg_ctx_ops#get_process_fault */ |
| #define AXIS2_MSG_CTX_GET_PROCESS_FAULT(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_process_fault(msg_ctx, env)) |
| |
| /** Gets WS-Addressing relates to information. |
| @sa axis2_msg_ctx_ops#get_relates_to */ |
| #define AXIS2_MSG_CTX_GET_RELATES_TO(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_relates_to(msg_ctx, env)) |
| |
| /** Gets WS-Addressing reply to address. |
| @sa axis2_msg_ctx_ops#get_reply_to */ |
| #define AXIS2_MSG_CTX_GET_REPLY_TO(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_reply_to(msg_ctx, env)) |
| |
| /** Gets bool value indicating response written status. |
| @sa axis2_msg_ctx_ops#get_response_written */ |
| #define AXIS2_MSG_CTX_GET_RESPONSE_WRITTEN(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_response_written(msg_ctx, env)) |
| |
| /** Gets bool value indicating whether the invocation is happening on server |
| side or client side. |
| @sa axis2_msg_ctx_ops#get_server_side */ |
| #define AXIS2_MSG_CTX_GET_SERVER_SIDE(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_server_side(msg_ctx, env)) |
| |
| /** Gets WS-Addressing to address. |
| @sa axis2_msg_ctx_ops#get_to */ |
| #define AXIS2_MSG_CTX_GET_TO(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_to(msg_ctx, env)) |
| |
| /** Sets WS-Addressing fault to address. |
| @sa axis2_msg_ctx_ops#set_fault_to */ |
| #define AXIS2_MSG_CTX_SET_FAULT_TO(msg_ctx, env, reference) \ |
| ((msg_ctx)->ops->set_fault_to(msg_ctx, env, reference)) |
| |
| /** Sets WS-Addressing from address. |
| @sa axis2_msg_ctx_ops#set_from */ |
| #define AXIS2_MSG_CTX_SET_FROM(msg_ctx, env, reference) \ |
| ((msg_ctx)->ops->set_from(msg_ctx, env, reference)) |
| |
| /** Sets in fault flow. |
| @sa axis2_msg_ctx_ops#set_in_fault_flow */ |
| #define AXIS2_MSG_CTX_SET_IN_FAULT_FLOW(msg_ctx, env, in_fault_flow) \ |
| ((msg_ctx)->ops->get_in_fault_flow(msg_ctx, env, in_fault_flow)) |
| |
| /** Sets SOAP envelope. |
| @sa axis2_msg_ctx_ops#set_soap_envelope */ |
| #define AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx, env, soap_envelope) \ |
| ((msg_ctx)->ops->set_soap_envelope(msg_ctx, env, soap_envelope)) |
| |
| /** Sets fault SOAP envelope. |
| @sa axis2_msg_ctx_ops#set_fault_soap_envelope */ |
| #define AXIS2_MSG_CTX_SET_FAULT_SOAP_ENVELOPE(msg_ctx, env, soap_envelope) \ |
| ((msg_ctx)->ops->set_fault_soap_envelope(msg_ctx, env, soap_envelope)) |
| |
| /** Sets the message ID. |
| @sa axis2_msg_ctx_ops#set_message_id */ |
| #define AXIS2_MSG_CTX_SET_MESSAGE_ID(msg_ctx, env, message_id) \ |
| ((msg_ctx)->ops->set_message_id(msg_ctx, env, message_id)) |
| |
| /** Sets bool value indicating whether to process SOAP fault. |
| @sa axis2_msg_ctx_ops#set_process_fault */ |
| #define AXIS2_MSG_CTX_SET_PROCESS_FAULT(msg_ctx, env, process_fault) \ |
| ((msg_ctx)->ops->set_process_fault(msg_ctx, env, process_fault)) |
| |
| /** Sets WS-Addressing relates to information. |
| @sa axis2_msg_ctx_ops#set_relates_to */ |
| #define AXIS2_MSG_CTX_SET_RELATES_TO(msg_ctx, env, reference) \ |
| ((msg_ctx)->ops->set_relates_to(msg_ctx, env, reference)) |
| |
| /** Sets WS-Addressing reply to address. |
| @sa axis2_msg_ctx_ops#set_reply_to */ |
| #define AXIS2_MSG_CTX_SET_REPLY_TO(msg_ctx, env, reference) \ |
| ((msg_ctx)->ops->set_reply_to(msg_ctx, env, reference)) |
| |
| /** Sets bool value indicating response written status. |
| @sa axis2_msg_ctx_ops#set_response_written */ |
| #define AXIS2_MSG_CTX_SET_RESPONSE_WRITTEN(msg_ctx, env, response_written) \ |
| ((msg_ctx)->ops->set_response_written(msg_ctx, env, response_written)) |
| |
| /** Sets bool value indicating whether the invocation is happening on server |
| side or client side. |
| @sa axis2_msg_ctx_ops#set_server_side */ |
| #define AXIS2_MSG_CTX_SET_SERVER_SIDE(msg_ctx, env, server_side) \ |
| ((msg_ctx)->ops->set_server_side(msg_ctx, env, server_side)) |
| |
| /** Sets WS-Addressing to address. |
| @sa axis2_msg_ctx_ops#set_to */ |
| #define AXIS2_MSG_CTX_SET_TO(msg_ctx, env, reference) \ |
| ((msg_ctx)->ops->set_to(msg_ctx, env, reference)) |
| |
| /** Gets bool value indicating if a new thread required in invocation. |
| @sa axis2_msg_ctx_ops#get_new_thread_required */ |
| #define AXIS2_MSG_CTX_GET_NEW_THREAD_REQUIRED(msg_ctx, env) \ |
| ((msg_ctx)->ops->set_response_written(msg_ctx, env)) |
| |
| /** Sets bool value indicating if a new thread required in invocation. |
| @sa axis2_msg_ctx_ops#set_new_thread_required */ |
| #define AXIS2_MSG_CTX_SET_NEW_THREAD_REQUIRED(msg_ctx, env, new_thread_required) \ |
| ((msg_ctx)->ops->set_response_written(msg_ctx, env, new_thread_required)) |
| |
| /** Sets WS-Addressing action. |
| @sa axis2_msg_ctx_ops#set_wsa_action */ |
| #define AXIS2_MSG_CTX_SET_WSA_ACTION(msg_ctx, env, action_uri) \ |
| ((msg_ctx)->ops->set_wsa_action(msg_ctx, env, action_uri)) |
| |
| /** Gets WS-Addressing action. |
| @sa axis2_msg_ctx_ops#get_wsa_action */ |
| #define AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_wsa_action(msg_ctx, env)) |
| |
| /** Sets WS-Addressing message ID. |
| @sa axis2_msg_ctx_ops#set_wsa_message_id */ |
| #define AXIS2_MSG_CTX_SET_WSA_MESSAGE_ID(msg_ctx, env, message_id) \ |
| ((msg_ctx)->ops->set_wsa_message_id(msg_ctx, env, message_id)) |
| |
| /** Gets WS-Addressing message ID. |
| @sa axis2_msg_ctx_ops#get_wsa_message_id */ |
| #define AXIS2_MSG_CTX_GET_WSA_MESSAGE_ID(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_wsa_message_id(msg_ctx, env)) |
| |
| /** Gets WS-Addressing message information headers. |
| @sa axis2_msg_ctx_ops#get_msg_info_headers */ |
| #define AXIS2_MSG_CTX_GET_MSG_INFO_HEADERS(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_msg_info_headers(msg_ctx, env)) |
| |
| /** Gets bool value indicating the paused status of invocation. |
| @sa axis2_msg_ctx_ops#get_paused */ |
| #define AXIS2_MSG_CTX_GET_PAUSED(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_paused(msg_ctx, env)) |
| |
| /** Sets bool value indicating the paused status of invocation. |
| @sa axis2_msg_ctx_ops#set_paused */ |
| #define AXIS2_MSG_CTX_SET_PAUSED(msg_ctx, env, paused) \ |
| ((msg_ctx)->ops->set_paused(msg_ctx, env, paused)) |
| |
| /** Gets bool value indicating the keep alive status of invocation. |
| @sa axis2_msg_ctx_ops#is_keep_alive */ |
| #define AXIS2_MSG_CTX_IS_KEEP_ALIVE(msg_ctx, env) \ |
| ((msg_ctx)->ops->is_keep_alive(msg_ctx, env)) |
| |
| /** Sets bool value indicating the keep alive status of invocation. |
| @sa axis2_msg_ctx_ops#set_keep_alive */ |
| #define AXIS2_MSG_CTX_SET_KEEP_ALIVE(msg_ctx, env, keep_alive) \ |
| ((msg_ctx)->ops->set_keep_alive(msg_ctx, env, keep_alive)) |
| |
| |
| /** Gets transport in description. |
| @sa axis2_msg_ctx_ops#get_transport_in_desc */ |
| #define AXIS2_MSG_CTX_GET_TRANSPORT_IN_DESC(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_transport_in_desc(msg_ctx, env)) |
| |
| /** Gets transport out description. |
| @sa axis2_msg_ctx_ops#get_transport_out_desc */ |
| #define AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_transport_out_desc(msg_ctx, env)) |
| |
| /** Sets transport in description. |
| @sa axis2_msg_ctx_ops#set_transport_in_desc */ |
| #define AXIS2_MSG_CTX_SET_TRANSPORT_IN_DESC(msg_ctx, env, transport_in_desc) \ |
| ((msg_ctx)->ops->set_transport_in_desc(msg_ctx, env, transport_in_desc)) |
| |
| /** Sets transport out description. |
| @sa axis2_msg_ctx_ops#set_transport_out_desc */ |
| #define AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(msg_ctx, env, transport_out_desc) \ |
| ((msg_ctx)->ops->set_transport_out_desc(msg_ctx, env, transport_out_desc)) |
| |
| /** Gets operation context. |
| @sa axis2_msg_ctx_ops#get_op_ctx */ |
| #define AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_op_ctx(msg_ctx, env)) |
| |
| /** Sets operation context. |
| @sa axis2_msg_ctx_ops#set_op_ctx */ |
| #define AXIS2_MSG_CTX_SET_OP_CTX(msg_ctx, env, op_ctx) \ |
| ((msg_ctx)->ops->set_op_ctx(msg_ctx, env, op_ctx)) |
| |
| /** Gets bool value indicating output written status. |
| @sa axis2_msg_ctx_ops#get_output_written */ |
| #define AXIS2_MSG_CTX_GET_OUTPUT_WRITTEN(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_output_written(msg_ctx, env)) |
| |
| /** Sets bool value indicating output written status. |
| @sa axis2_msg_ctx_ops#set_output_written */ |
| #define AXIS2_MSG_CTX_SET_OUTPUT_WRITTEN(msg_ctx, env, output_written) \ |
| ((msg_ctx)->ops->set_output_written(msg_ctx, env, output_written)) |
| |
| /** Gets service context ID. |
| @sa axis2_msg_ctx_ops#get_svc_ctx_id */ |
| #define AXIS2_MSG_CTX_GET_SVC_CTX_ID(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_svc_ctx_id(msg_ctx, env)) |
| |
| /** Sets service context ID. |
| @sa axis2_msg_ctx_ops#set_svc_ctx_id */ |
| #define AXIS2_MSG_CTX_SET_SVC_CTX_ID(msg_ctx, env, svc_ctx_id) \ |
| ((msg_ctx)->ops->set_svc_ctx_id(msg_ctx, env, svc_ctx_id)) |
| |
| /** Gets configuration context. |
| @sa axis2_msg_ctx_ops#get_conf_ctx */ |
| #define AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_conf_ctx(msg_ctx, env)) |
| |
| /** Sets configuration context. |
| @sa axis2_msg_ctx_ops#set_conf_ctx */ |
| #define AXIS2_MSG_CTX_SET_CONF_CTX(msg_ctx, env, conf_ctx) \ |
| ((msg_ctx)->ops->set_conf_ctx(msg_ctx, env, conf_ctx)) |
| |
| /** Gets service context. |
| @sa axis2_msg_ctx_ops#get_svc_ctx */ |
| #define AXIS2_MSG_CTX_GET_SVC_CTX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_svc_ctx(msg_ctx, env)) |
| |
| /** Sets service context. |
| @sa axis2_msg_ctx_ops#set_svc_ctx */ |
| #define AXIS2_MSG_CTX_SET_SVC_CTX(msg_ctx, env, svc_ctx) \ |
| ((msg_ctx)->ops->set_svc_ctx(msg_ctx, env, svc_ctx)) |
| |
| /** Sets WS-Addressing message information headers. |
| @sa axis2_msg_ctx_ops#set_msg_info_headers */ |
| #define AXIS2_MSG_CTX_SET_MSG_INFO_HEADERS(msg_ctx, env, msg_info_headers) \ |
| ((msg_ctx)->ops->set_msg_info_headers(msg_ctx, env, msg_info_headers)) |
| |
| /** Gets parameter with the given key. |
| @sa axis2_msg_ctx_ops#get_parameter */ |
| #define AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx, env, key) \ |
| ((msg_ctx)->ops->get_parameter(msg_ctx, env, key)) |
| |
| /** Gets module parameter corresponding to given key, module name and handler |
| description. |
| @sa axis2_msg_ctx_ops#get_module_parameter */ |
| #define AXIS2_MSG_CTX_GET_MODULE_PARAMETER(msg_ctx, env, key, module_name, handler_desc) \ |
| ((msg_ctx)->ops->get_module_parameter(msg_ctx, env, key, module_name, handler_desc)) |
| |
| /** Gets property with given key. |
| @sa axis2_msg_ctx_ops#get_property */ |
| #define AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, key, persistent) \ |
| ((msg_ctx)->ops->get_property(msg_ctx, env, key, persistent)) |
| |
| /** Sets property with given key. |
| @sa axis2_msg_ctx_ops#set_property */ |
| #define AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, key, value, persistent) \ |
| ((msg_ctx)->ops->set_property(msg_ctx, env, key, value, persistent)) |
| |
| /** Gets name of the handler at which invocation was paused. |
| @sa axis2_msg_ctx_ops#get_paused_handler_name */ |
| #define AXIS2_MSG_CTX_GET_PAUSED_HANDLER_NAME(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_paused_handler_name(msg_ctx, env)) |
| |
| /** Gets name of the phase at which invocation was paused. |
| @sa axis2_msg_ctx_ops#get_paused_phase_name */ |
| #define AXIS2_MSG_CTX_GET_PAUSED_PHASE_NAME(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_paused_phase_name(msg_ctx, env)) |
| |
| /** Sets name of the phase at which invocation was paused. |
| @sa axis2_msg_ctx_ops#set_paused_phase_name */ |
| #define AXIS2_MSG_CTX_SET_PAUSED_PHASE_NAME(msg_ctx, env, paused_phase_name) \ |
| ((msg_ctx)->ops->set_paused_phase_name(msg_ctx, env, paused_phase_name)) |
| |
| /** Gets SOAP action. |
| @sa axis2_msg_ctx_ops#get_soap_action */ |
| #define AXIS2_MSG_CTX_GET_SOAP_ACTION(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_soap_action(msg_ctx, env)) |
| |
| /** Sets SOAP action. |
| @sa axis2_msg_ctx_ops#set_soap_action */ |
| #define AXIS2_MSG_CTX_SET_SOAP_ACTION(msg_ctx, env, soap_action) \ |
| ((msg_ctx)->ops->set_soap_action(msg_ctx, env, soap_action)) |
| |
| /** Gets bool value indicating whether MTOM is enabled. |
| @sa axis2_msg_ctx_ops#get_doing_mtom */ |
| #define AXIS2_MSG_CTX_GET_DOING_MTOM(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_doing_mtom(msg_ctx, env)) |
| |
| /** Sets bool value indicating whether MTOM is enabled. |
| @sa axis2_msg_ctx_ops#set_doing_mtom */ |
| #define AXIS2_MSG_CTX_SET_DOING_MTOM(msg_ctx, env, doing_mtom) \ |
| ((msg_ctx)->ops->set_doing_mtom(msg_ctx, env, doing_mtom)) |
| |
| /** Gets bool value indicating whether REST is enabled. |
| @sa axis2_msg_ctx_ops#get_doing_rest */ |
| #define AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_doing_rest(msg_ctx, env)) |
| |
| /** Sets bool value indicating whether REST is enabled. |
| @sa axis2_msg_ctx_ops#set_doing_rest */ |
| #define AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx, env, doing_rest) \ |
| ((msg_ctx)->ops->set_doing_rest(msg_ctx, env, doing_rest)) |
| |
| /** Sets bool value indicating whether REST should be done with HTTP POST. |
| @sa axis2_msg_ctx_ops#set_do_rest_through_post */ |
| #define AXIS2_MSG_CTX_SET_DO_REST_THROUGH_POST(msg_ctx, env, do_rest_through_post) \ |
| ((msg_ctx)->ops->set_do_rest_through_post(msg_ctx, env, do_rest_through_post)) |
| |
| /** Gets bool value indicating the SOAP version in use. |
| @sa axis2_msg_ctx_ops#set_is_soap_11 */ |
| #define AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_is_soap_11(msg_ctx, env)) |
| |
| /** Sets bool value indicating the SOAP version in use. |
| @sa axis2_msg_ctx_ops#set_is_soap_11 */ |
| #define AXIS2_MSG_CTX_SET_IS_SOAP_11(msg_ctx, env, is_soap11) \ |
| ((msg_ctx)->ops->set_is_soap_11(msg_ctx, env, is_soap11)) |
| |
| /** Gets service group context. |
| @sa axis2_msg_ctx_ops#get_svc_grp_ctx */ |
| #define AXIS2_MSG_CTX_GET_SVC_GRP_CTX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_svc_grp_ctx(msg_ctx, env)) |
| |
| /** Sets service group context. |
| @sa axis2_msg_ctx_ops#set_svc_grp_ctx */ |
| #define AXIS2_MSG_CTX_SET_SVC_GRP_CTX(msg_ctx, env, svc_grp_ctx) \ |
| ((msg_ctx)->ops->set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx)) |
| |
| /** Gets operation to be invoked. |
| @sa axis2_msg_ctx_ops#get_op */ |
| #define AXIS2_MSG_CTX_GET_OP(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_op(msg_ctx, env)) |
| |
| /** Sets operation to be invoked. |
| @sa axis2_msg_ctx_ops#set_op */ |
| #define AXIS2_MSG_CTX_SET_OP(msg_ctx, env, op) \ |
| ((msg_ctx)->ops->set_op(msg_ctx, env, op)) |
| |
| /** Gets service to be invoked. |
| @sa axis2_msg_ctx_ops#get_svc */ |
| #define AXIS2_MSG_CTX_GET_SVC(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_svc(msg_ctx, env)) |
| |
| /** Sets service to be invoked. |
| @sa axis2_msg_ctx_ops#set_svc */ |
| #define AXIS2_MSG_CTX_SET_SVC(msg_ctx, env, svc) \ |
| ((msg_ctx)->ops->set_svc(msg_ctx, env, svc)) |
| |
| /** Gets service group. |
| @sa axis2_msg_ctx_ops#get_svc_grp */ |
| #define AXIS2_MSG_CTX_GET_SVC_GRP(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_svc_grp(msg_ctx, env)) |
| |
| /** Sets service group. |
| @sa axis2_msg_ctx_ops#set_svc_grp */ |
| #define AXIS2_MSG_CTX_SET_SVC_GRP(msg_ctx, env, svc_grp) \ |
| ((msg_ctx)->ops->set_svc_grp(msg_ctx, env, svc_grp)) |
| |
| /** Gets service group context ID. |
| @sa axis2_msg_ctx_ops#get_svc_grp_ctx_id */ |
| #define AXIS2_MSG_CTX_GET_SVC_GRP_CTX_ID(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_svc_grp_ctx_id(msg_ctx, env)) |
| |
| /** Sets the service group context ID. |
| @sa axis2_msg_ctx_ops#set_svc_grp_ctx_id */ |
| #define AXIS2_MSG_CTX_SET_SVC_GRP_CTX_ID(msg_ctx, env, svc_grp_ctx_id) \ |
| ((msg_ctx)->ops->set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id)) |
| |
| /** Gets bool value indicating whether invocation is paused. |
| @sa axis2_msg_ctx_ops#is_paused */ |
| #define AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env) \ |
| ((msg_ctx)->ops->is_paused(msg_ctx, env)) |
| |
| /** Finds service. |
| @sa axis2_msg_ctx_ops#find_svc */ |
| #define AXIS2_MSG_CTX_FIND_SVC(msg_ctx, env) \ |
| ((msg_ctx)->ops->find_svc(msg_ctx, env)) |
| |
| /** Finds operation. |
| @sa axis2_msg_ctx_ops#find_op */ |
| #define AXIS2_MSG_CTX_FIND_OP(msg_ctx, env, svc) \ |
| ((msg_ctx)->ops->find_op(msg_ctx, env, svc)) |
| |
| /** Sets options. |
| @sa axis2_msg_ctx_ops#set_options */ |
| #define AXIS2_MSG_CTX_SET_OPTIONS(msg_ctx, env, options) \ |
| ((msg_ctx)->ops->set_options(msg_ctx, env, options)) |
| |
| /** Sets flow. |
| @sa axis2_msg_ctx_ops#set_flow */ |
| #define AXIS2_MSG_CTX_SET_FLOW(msg_ctx, env, flow) \ |
| ((msg_ctx)->ops->set_flow(msg_ctx, env, flow)) |
| |
| /** Gets flow. |
| @sa axis2_msg_ctx_ops#get_flow */ |
| #define AXIS2_MSG_CTX_GET_FLOW(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_flow(msg_ctx, env)) |
| |
| /** Sets execution chain. |
| @sa axis2_msg_ctx_ops#set_execution_chain */ |
| #define AXIS2_MSG_CTX_SET_EXECUTION_CHAIN(msg_ctx, env, chain) \ |
| ((msg_ctx)->ops->set_execution_chain(msg_ctx, env, chain)) |
| |
| /** Gets execution chain. |
| @sa axis2_msg_ctx_ops#get_execution_chain */ |
| #define AXIS2_MSG_CTX_GET_EXECUTION_CHAIN(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_execution_chain(msg_ctx, env)) |
| |
| /** Sets current handler index. |
| @sa axis2_msg_ctx_ops#set_current_handler_index */ |
| #define AXIS2_MSG_CTX_SET_CURRENT_HANDLER_INDEX(msg_ctx, env, index) \ |
| ((msg_ctx)->ops->set_current_handler_index(msg_ctx, env, index)) |
| |
| /** Gets current handler index. |
| @sa axis2_msg_ctx_ops#get_current_handler_index */ |
| #define AXIS2_MSG_CTX_GET_CURRENT_HANDLER_INDEX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_current_handler_index(msg_ctx, env)) |
| |
| /** Gets paused handler index. |
| @sa axis2_msg_ctx_ops#get_paused_handler_index */ |
| #define AXIS2_MSG_CTX_GET_PAUSED_HANDLER_INDEX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_paused_handler_index(msg_ctx, env)) |
| |
| /** Sets current phase index. |
| @sa axis2_msg_ctx_ops#set_current_phase_index */ |
| #define AXIS2_MSG_CTX_SET_CURRENT_PHASE_INDEX(msg_ctx, env, index) \ |
| ((msg_ctx)->ops->set_current_phase_index(msg_ctx, env, index)) |
| |
| /** Gets current phase index. |
| @sa axis2_msg_ctx_ops#get_current_phase_index */ |
| #define AXIS2_MSG_CTX_GET_CURRENT_PHASE_INDEX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_current_phase_index(msg_ctx, env)) |
| |
| /** Gets paused phase index. |
| @sa axis2_msg_ctx_ops#get_paused_phase_index */ |
| #define AXIS2_MSG_CTX_GET_PAUSED_PHASE_INDEX(msg_ctx, env) \ |
| ((msg_ctx)->ops->get_paused_phase_index(msg_ctx, env)) |
| |
| /** @} */ |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* AXIS2_MSG_CTX_H */ |
