axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r494687 [4/4] - in /webservices/axis2/trunk/c: include/ modules/core/context/ modules/core/engine/
Date Wed, 10 Jan 2007 02:11:16 GMT
Modified: webservices/axis2/trunk/c/modules/core/context/msg_ctx.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/context/msg_ctx.c?view=diff&rev=494687&r1=494686&r2=494687
==============================================================================
--- webservices/axis2/trunk/c/modules/core/context/msg_ctx.c (original)
+++ webservices/axis2/trunk/c/modules/core/context/msg_ctx.c Tue Jan  9 18:11:15 2007
@@ -27,641 +27,122 @@
 #include <axiom_soap_const.h>
 #include <axis2_options.h>
 
-typedef struct axis2_msg_ctx_impl axis2_msg_ctx_impl_t;
-
-/**
- * @brief Message Context struct impl
- * Axis2 Message Context impl
- */
-struct axis2_msg_ctx_impl
-{
-    /** message context interface struct */
-    axis2_msg_ctx_t msg_ctx;
-    /** base context struct */
-    axis2_ctx_t *base;
-    /** parent of message context is an op context instance */
-    struct axis2_op_ctx *parent;
-    /** process fault enabled? */
-    axis2_bool_t process_fault;
-    /**
-     * Addressing Information for Axis 2
-     * Following Properties will be kept inside this, these fields will be initially filled by
-     * the transport. Then later an addressing handler will make relevant changes to this, if addressing
-     * information is present in the SOAP header.
-     */
-    axis2_msg_info_headers_t *msg_info_headers;
-    axis2_bool_t msg_info_headers_deep_copy;
-
-    struct axis2_op_ctx *op_ctx;
-    struct axis2_svc_ctx *svc_ctx;
-    struct axis2_svc_grp_ctx *svc_grp_ctx;
-    struct axis2_conf_ctx *conf_ctx;
-
-    /** op */
-    axis2_op_t *op;
-    /** service */
-    axis2_svc_t *svc;
-    /** service group */
-    axis2_svc_grp_t *svc_grp;
-
-    axis2_transport_in_desc_t *transport_in_desc;
-    axis2_transport_out_desc_t *transport_out_desc;
-
-    /** SOAP envelope */
-    axiom_soap_envelope_t *soap_envelope;
-    /** SOAP Fault envelope */
-    axiom_soap_envelope_t *fault_soap_envelope;
-    /** response written? */
-    axis2_bool_t response_written;
-    /** in fault flow? */
-    axis2_bool_t in_fault_flow;
-    /** is this server side? */
-    axis2_bool_t server_side;
-    /** message ID */
-    axis2_char_t *message_id;
-    /** new thread required? */
-    axis2_bool_t new_thread_required;
-    /** paused */
-    axis2_bool_t paused;
-    axis2_bool_t keep_alive;
-    /** output written? */
-    axis2_bool_t output_written;
-    /** service context ID */
-    axis2_char_t *svc_ctx_id;
-    /** paused phase name */
-    axis2_char_t *paused_phase_name;
-    /** paused handler name */
-    axis2_qname_t *paused_handler_name;
-    /** SOAP action */
-    axis2_char_t *soap_action;
-    /** are we doing MTOM now? */
-    axis2_bool_t doing_mtom;
-    /** are we doing REST now? */
-    axis2_bool_t doing_rest;
-    /** Rest through HTTP POST? */
-    axis2_bool_t do_rest_through_post;
-    /** use SOAP 1.1? */
-    axis2_bool_t is_soap_11;
-    /** service group context id */
-    axis2_char_t *svc_grp_ctx_id;
-    /** qname of transport in */
-    axis2_qname_t *transport_in_desc_qname;
-    /** qname of transport out */
-    axis2_qname_t *transport_out_desc_qname;
-    /** service group id */
-    axis2_char_t *svc_grp_id;
-    /** service description qname */
-    axis2_qname_t *svc_qname;
-    /** op qname */
-    axis2_qname_t *op_qname;
-    /* To keep track of the direction */
-    int flow;
-    /** The chain of Handlers/Phases for processing this message */
-    axis2_array_list_t *execution_chain;
-    /** Index into the execution chain of the currently executing handler */
-    int current_handler_index;
-    /** Index of the paused  handler */
-    int paused_handler_index;
-    /** Index of the paused  phase */
-    int paused_phase_index;
-    /** Index into the current Phase of the currently executing handler (if any)*/
-    int current_phase_index;
-};
-
-#define AXIS2_INTF_TO_IMPL(msg_ctx) ((axis2_msg_ctx_impl_t *) msg_ctx)
-
-struct axis2_ctx *AXIS2_CALL
-            axis2_msg_ctx_get_base(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-struct axis2_op_ctx *AXIS2_CALL
-            axis2_msg_ctx_get_parent(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_parent(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_op_ctx *parent);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_free(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_init(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_conf *conf);
-
-axis2_endpoint_ref_t *AXIS2_CALL
-axis2_msg_ctx_get_fault_to(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_endpoint_ref_t *AXIS2_CALL
-axis2_msg_ctx_get_from(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_in_fault_flow(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axiom_soap_envelope_t *AXIS2_CALL
-axis2_msg_ctx_get_soap_envelope(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axiom_soap_envelope_t *AXIS2_CALL
-axis2_msg_ctx_get_fault_soap_envelope(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_msg_id(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_process_fault(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_relates_to_t *AXIS2_CALL
-axis2_msg_ctx_get_relates_to(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_endpoint_ref_t *AXIS2_CALL
-axis2_msg_ctx_get_reply_to(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_response_written(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_server_side(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_endpoint_ref_t *AXIS2_CALL
-axis2_msg_ctx_get_to(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_fault_to(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_endpoint_ref_t *reference);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_from(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_endpoint_ref_t *reference);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_in_fault_flow(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t in_fault_flow);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_soap_envelope(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axiom_soap_envelope_t *soap_envelope);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_fault_soap_envelope(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axiom_soap_envelope_t *soap_envelope);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_message_id(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *message_id);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_process_fault(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t process_fault);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_relates_to(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_relates_to_t *reference);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_reply_to(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_endpoint_ref_t *reference);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_response_written(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t response_written);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_server_side(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t server_side);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_to(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_endpoint_ref_t *reference);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_new_thread_required(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_new_thread_required(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t new_thread_required);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_wsa_action(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *action_uri);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_wsa_action(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_wsa_message_id(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *message_id);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_wsa_message_id(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_msg_info_headers_t *AXIS2_CALL
-axis2_msg_ctx_get_msg_info_headers(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_paused(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_paused(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t paused);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_is_keep_alive(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_keep_alive(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t keep_alive);
-
-struct axis2_transport_in_desc *AXIS2_CALL
-            axis2_msg_ctx_get_transport_in_desc(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-struct axis2_transport_out_desc *AXIS2_CALL
-            axis2_msg_ctx_get_transport_out_desc(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_transport_in_desc(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_transport_in_desc *transport_in_desc);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_transport_out_desc(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_transport_out_desc *transport_out_desc);
-
-struct axis2_op_ctx *AXIS2_CALL
-            axis2_msg_ctx_get_op_ctx(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_op_ctx(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_op_ctx *op_ctx);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_output_written(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_output_written(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t output_written);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_svc_ctx_id(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_svc_ctx_id(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *svc_ctx_id);
-
-struct axis2_conf_ctx *AXIS2_CALL
-            axis2_msg_ctx_get_conf_ctx(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-struct axis2_svc_ctx *AXIS2_CALL
-            axis2_msg_ctx_get_svc_ctx(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_conf_ctx(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_conf_ctx *conf_ctx);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_svc_ctx(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_svc_ctx *svc_ctx);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_msg_info_headers(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_msg_info_headers_t *msg_info_headers);
-
-axis2_param_t *AXIS2_CALL
-axis2_msg_ctx_get_parameter(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *key);
-
-axis2_param_t *AXIS2_CALL
-axis2_msg_ctx_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);
-
-axis2_property_t *AXIS2_CALL
-axis2_msg_ctx_get_property(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *key,
-    const axis2_bool_t persistent);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_property(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *key,
-    axis2_property_t *value,
-    axis2_bool_t persistent);
-
-const axis2_qname_t *AXIS2_CALL
-axis2_msg_ctx_get_paused_handler_name(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_paused_phase_name(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_paused_phase_name(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *paused_phase_name);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_soap_action(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_soap_action(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *soap_action);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_doing_mtom(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_doing_mtom(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t doing_mtom);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_doing_rest(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_doing_rest(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t doing_rest);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_do_rest_through_post(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t do_rest_through_post);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_do_rest_through_post(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_get_is_soap_11(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_is_soap_11(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_bool_t is_soap11);
-
-struct axis2_svc_grp_ctx *AXIS2_CALL
-            axis2_msg_ctx_get_svc_grp_ctx(
-                const axis2_msg_ctx_t *msg_ctx,
-                const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_svc_grp_ctx(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    struct axis2_svc_grp_ctx *svc_grp_ctx);
-
-axis2_op_t *AXIS2_CALL
-axis2_msg_ctx_get_op(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_op(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_op_t *op);
-
-axis2_svc_t *AXIS2_CALL
-axis2_msg_ctx_get_svc(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_svc(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_svc_t *svc);
-
-axis2_svc_grp_t *AXIS2_CALL
-axis2_msg_ctx_get_svc_grp(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_svc_grp(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    axis2_svc_grp_t *svc_grp);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_ctx_get_svc_grp_ctx_id(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_svc_grp_ctx_id(
-    struct axis2_msg_ctx *msg_ctx,
-    const axis2_env_t *env,
-    const axis2_char_t *svc_grp_ctx_id);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_ctx_is_paused(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_svc_t *AXIS2_CALL
-axis2_msg_ctx_find_svc(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_op_t *AXIS2_CALL
-axis2_msg_ctx_find_op(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    axis2_svc_t *svc);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_options(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    axis2_options_t *options);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_flow(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    const int flow);
-
-int AXIS2_CALL
-axis2_msg_ctx_get_flow(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_execution_chain(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    axis2_array_list_t *execution_chain);
-
-axis2_array_list_t *AXIS2_CALL
-axis2_msg_ctx_get_execution_chain(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
+struct axis2_msg_ctx
+{
+    /** base context struct */
+    axis2_ctx_t *base;
+    /** parent of message context is an op context instance */
+    struct axis2_op_ctx *parent;
+    /** process fault enabled? */
+    axis2_bool_t process_fault;
+    /**
+     * Addressing Information for Axis 2
+     * Following Properties will be kept inside this, these fields will be initially filled by
+     * the transport. Then later an addressing handler will make relevant changes to this, if addressing
+     * information is present in the SOAP header.
+     */
+    axis2_msg_info_headers_t *msg_info_headers;
+    axis2_bool_t msg_info_headers_deep_copy;
 
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_current_handler_index(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    const int index);
+    struct axis2_op_ctx *op_ctx;
+    struct axis2_svc_ctx *svc_ctx;
+    struct axis2_svc_grp_ctx *svc_grp_ctx;
+    struct axis2_conf_ctx *conf_ctx;
 
-int AXIS2_CALL
-axis2_msg_ctx_get_current_handler_index(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
+    /** op */
+    axis2_op_t *op;
+    /** service */
+    axis2_svc_t *svc;
+    /** service group */
+    axis2_svc_grp_t *svc_grp;
 
-int AXIS2_CALL
-axis2_msg_ctx_get_paused_handler_index(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
+    axis2_transport_in_desc_t *transport_in_desc;
+    axis2_transport_out_desc_t *transport_out_desc;
 
-axis2_status_t AXIS2_CALL
-axis2_msg_ctx_set_current_phase_index(
-    axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env,
-    const int index);
+    /** SOAP envelope */
+    axiom_soap_envelope_t *soap_envelope;
+    /** SOAP Fault envelope */
+    axiom_soap_envelope_t *fault_soap_envelope;
+    /** response written? */
+    axis2_bool_t response_written;
+    /** in fault flow? */
+    axis2_bool_t in_fault_flow;
+    /** is this server side? */
+    axis2_bool_t server_side;
+    /** message ID */
+    axis2_char_t *message_id;
+    /** new thread required? */
+    axis2_bool_t new_thread_required;
+    /** paused */
+    axis2_bool_t paused;
+    axis2_bool_t keep_alive;
+    /** output written? */
+    axis2_bool_t output_written;
+    /** service context ID */
+    axis2_char_t *svc_ctx_id;
+    /** paused phase name */
+    axis2_char_t *paused_phase_name;
+    /** paused handler name */
+    axis2_qname_t *paused_handler_name;
+    /** SOAP action */
+    axis2_char_t *soap_action;
+    /** are we doing MTOM now? */
+    axis2_bool_t doing_mtom;
+    /** are we doing REST now? */
+    axis2_bool_t doing_rest;
+    /** Rest through HTTP POST? */
+    axis2_bool_t do_rest_through_post;
+    /** use SOAP 1.1? */
+    axis2_bool_t is_soap_11;
+    /** service group context id */
+    axis2_char_t *svc_grp_ctx_id;
+    /** qname of transport in */
+    axis2_qname_t *transport_in_desc_qname;
+    /** qname of transport out */
+    axis2_qname_t *transport_out_desc_qname;
+    /** service group id */
+    axis2_char_t *svc_grp_id;
+    /** service description qname */
+    axis2_qname_t *svc_qname;
+    /** op qname */
+    axis2_qname_t *op_qname;
+    /* To keep track of the direction */
+    int flow;
+    /** The chain of Handlers/Phases for processing this message */
+    axis2_array_list_t *execution_chain;
+    /** Index into the execution chain of the currently executing handler */
+    int current_handler_index;
+    /** Index of the paused  handler */
+    int paused_handler_index;
+    /** Index of the paused  phase */
+    int paused_phase_index;
+    /** Index into the current Phase of the currently executing handler (if any)*/
+    int current_phase_index;
 
-int AXIS2_CALL
-axis2_msg_ctx_get_current_phase_index(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
+    /**
+     * 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);
 
-int AXIS2_CALL
-axis2_msg_ctx_get_paused_phase_index(
-    const axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env);
+};
 
 AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL
 axis2_msg_ctx_create(
@@ -670,204 +151,90 @@
     struct axis2_transport_in_desc *transport_in_desc,
     struct axis2_transport_out_desc *transport_out_desc)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+    axis2_msg_ctx_t *msg_ctx = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_ctx_impl_t));
-    if (!msg_ctx_impl)
+    msg_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_ctx_t));
+    if (!msg_ctx)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
 
-    msg_ctx_impl->msg_ctx.ops = NULL;
-    msg_ctx_impl->base = NULL;
-    msg_ctx_impl->process_fault = AXIS2_FALSE;
-    msg_ctx_impl->msg_info_headers = NULL;
-    msg_ctx_impl->op_ctx = NULL;
-    msg_ctx_impl->svc_ctx = NULL;
-    msg_ctx_impl->svc_grp_ctx = NULL;
-    msg_ctx_impl->conf_ctx = NULL;
-    msg_ctx_impl->op = NULL;
-    msg_ctx_impl->svc = NULL;
-    msg_ctx_impl->svc_grp = NULL;
-    msg_ctx_impl->transport_in_desc = NULL;
-    msg_ctx_impl->transport_out_desc = NULL;
-    msg_ctx_impl->soap_envelope = NULL;
-    msg_ctx_impl->fault_soap_envelope = NULL;
-    msg_ctx_impl->response_written = AXIS2_FALSE;
-    msg_ctx_impl->in_fault_flow = AXIS2_FALSE;
-    msg_ctx_impl->server_side = AXIS2_FALSE;
-    msg_ctx_impl->message_id = NULL;
-    msg_ctx_impl->new_thread_required = AXIS2_FALSE;
-    msg_ctx_impl->paused = AXIS2_FALSE;
-    msg_ctx_impl->keep_alive = AXIS2_FALSE;
-    msg_ctx_impl->output_written = AXIS2_FALSE;
-    msg_ctx_impl->svc_ctx_id = NULL;
-    msg_ctx_impl->paused_phase_name = NULL;
-    msg_ctx_impl->paused_handler_name = NULL;
-    msg_ctx_impl->soap_action = NULL;
-    msg_ctx_impl->doing_mtom = AXIS2_FALSE;
-    msg_ctx_impl->doing_rest = AXIS2_FALSE;
-    msg_ctx_impl->do_rest_through_post = AXIS2_FALSE;
-    msg_ctx_impl->is_soap_11 = AXIS2_FALSE;
-    msg_ctx_impl->svc_grp_ctx_id = NULL;
-    msg_ctx_impl->transport_in_desc_qname = NULL;
-    msg_ctx_impl->transport_out_desc_qname = NULL;
-    msg_ctx_impl->svc_grp_id = NULL;
-    msg_ctx_impl->svc_qname = NULL;
-    msg_ctx_impl->op_qname = NULL;
-    msg_ctx_impl->flow = AXIS2_IN_FLOW;
-    msg_ctx_impl->execution_chain = NULL;
-    msg_ctx_impl->current_handler_index = -1;
-    msg_ctx_impl->paused_handler_index = -1;
-    msg_ctx_impl->current_phase_index = 0;
-    msg_ctx_impl->paused_phase_index = 0;
+    msg_ctx->base = NULL;
+    msg_ctx->process_fault = AXIS2_FALSE;
+    msg_ctx->msg_info_headers = NULL;
+    msg_ctx->op_ctx = NULL;
+    msg_ctx->svc_ctx = NULL;
+    msg_ctx->svc_grp_ctx = NULL;
+    msg_ctx->conf_ctx = NULL;
+    msg_ctx->op = NULL;
+    msg_ctx->svc = NULL;
+    msg_ctx->svc_grp = NULL;
+    msg_ctx->transport_in_desc = NULL;
+    msg_ctx->transport_out_desc = NULL;
+    msg_ctx->soap_envelope = NULL;
+    msg_ctx->fault_soap_envelope = NULL;
+    msg_ctx->response_written = AXIS2_FALSE;
+    msg_ctx->in_fault_flow = AXIS2_FALSE;
+    msg_ctx->server_side = AXIS2_FALSE;
+    msg_ctx->message_id = NULL;
+    msg_ctx->new_thread_required = AXIS2_FALSE;
+    msg_ctx->paused = AXIS2_FALSE;
+    msg_ctx->keep_alive = AXIS2_FALSE;
+    msg_ctx->output_written = AXIS2_FALSE;
+    msg_ctx->svc_ctx_id = NULL;
+    msg_ctx->paused_phase_name = NULL;
+    msg_ctx->paused_handler_name = NULL;
+    msg_ctx->soap_action = NULL;
+    msg_ctx->doing_mtom = AXIS2_FALSE;
+    msg_ctx->doing_rest = AXIS2_FALSE;
+    msg_ctx->do_rest_through_post = AXIS2_FALSE;
+    msg_ctx->is_soap_11 = AXIS2_FALSE;
+    msg_ctx->svc_grp_ctx_id = NULL;
+    msg_ctx->transport_in_desc_qname = NULL;
+    msg_ctx->transport_out_desc_qname = NULL;
+    msg_ctx->svc_grp_id = NULL;
+    msg_ctx->svc_qname = NULL;
+    msg_ctx->op_qname = NULL;
+    msg_ctx->flow = AXIS2_IN_FLOW;
+    msg_ctx->execution_chain = NULL;
+    msg_ctx->current_handler_index = -1;
+    msg_ctx->paused_handler_index = -1;
+    msg_ctx->current_phase_index = 0;
+    msg_ctx->paused_phase_index = 0;
 
-    msg_ctx_impl->base = axis2_ctx_create(env);
-    if (!(msg_ctx_impl->base))
+    msg_ctx->base = axis2_ctx_create(env);
+    if (!(msg_ctx->base))
     {
-        axis2_msg_ctx_free(&(msg_ctx_impl->msg_ctx), env);
+        axis2_msg_ctx_free(msg_ctx, env);
         return NULL;
     }
 
     if (transport_in_desc)
-        msg_ctx_impl->transport_in_desc = transport_in_desc;
+        msg_ctx->transport_in_desc = transport_in_desc;
     if (transport_out_desc)
-        msg_ctx_impl->transport_out_desc = transport_out_desc;
+        msg_ctx->transport_out_desc = transport_out_desc;
     if (conf_ctx)
-        msg_ctx_impl->conf_ctx = conf_ctx;
+        msg_ctx->conf_ctx = conf_ctx;
 
-    if (msg_ctx_impl->transport_in_desc)
-        msg_ctx_impl->transport_in_desc_qname =
+    if (msg_ctx->transport_in_desc)
+        msg_ctx->transport_in_desc_qname =
             (axis2_qname_t *)AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env);
-    if (msg_ctx_impl->transport_out_desc)
-        msg_ctx_impl->transport_out_desc_qname =
+    if (msg_ctx->transport_out_desc)
+        msg_ctx->transport_out_desc_qname =
             (axis2_qname_t *)AXIS2_TRANSPORT_OUT_DESC_GET_QNAME(transport_out_desc, env);
 
-    msg_ctx_impl->msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
-    if (!(msg_ctx_impl->msg_info_headers))
-    {
-        axis2_msg_ctx_free(&(msg_ctx_impl->msg_ctx), env);
-        return NULL;
-    }
-    msg_ctx_impl->msg_info_headers_deep_copy = AXIS2_TRUE;
-
-    /* initialize ops */
-    msg_ctx_impl->msg_ctx.ops  = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_ctx_ops_t));
-    if (!msg_ctx_impl->msg_ctx.ops)
+    msg_ctx->msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL);
+    if (!(msg_ctx->msg_info_headers))
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        axis2_msg_ctx_free(&(msg_ctx_impl->msg_ctx), env);
+        axis2_msg_ctx_free(msg_ctx, env);
         return NULL;
     }
+    msg_ctx->msg_info_headers_deep_copy = AXIS2_TRUE;
 
-    msg_ctx_impl->msg_ctx.ops->get_base = axis2_msg_ctx_get_base;
-    msg_ctx_impl->msg_ctx.ops->get_parent = axis2_msg_ctx_get_parent;
-    msg_ctx_impl->msg_ctx.ops->set_parent = axis2_msg_ctx_set_parent;
-    msg_ctx_impl->msg_ctx.ops->free = axis2_msg_ctx_free;
-    msg_ctx_impl->msg_ctx.ops->init = axis2_msg_ctx_init;
-    msg_ctx_impl->msg_ctx.ops->get_fault_to = axis2_msg_ctx_get_fault_to;
-    msg_ctx_impl->msg_ctx.ops->get_from = axis2_msg_ctx_get_from;
-    msg_ctx_impl->msg_ctx.ops->get_in_fault_flow = axis2_msg_ctx_get_in_fault_flow;
-    msg_ctx_impl->msg_ctx.ops->get_soap_envelope = axis2_msg_ctx_get_soap_envelope;
-    msg_ctx_impl->msg_ctx.ops->get_fault_soap_envelope = axis2_msg_ctx_get_fault_soap_envelope;
-    msg_ctx_impl->msg_ctx.ops->get_msg_id = axis2_msg_ctx_get_msg_id;
-    msg_ctx_impl->msg_ctx.ops->get_process_fault = axis2_msg_ctx_get_process_fault;
-    msg_ctx_impl->msg_ctx.ops->get_relates_to = axis2_msg_ctx_get_relates_to;
-    msg_ctx_impl->msg_ctx.ops->get_reply_to = axis2_msg_ctx_get_reply_to;
-    msg_ctx_impl->msg_ctx.ops->get_response_written = axis2_msg_ctx_get_response_written;
-    msg_ctx_impl->msg_ctx.ops->get_server_side = axis2_msg_ctx_get_server_side;
-    msg_ctx_impl->msg_ctx.ops->get_to = axis2_msg_ctx_get_to;
-    msg_ctx_impl->msg_ctx.ops->set_fault_to = axis2_msg_ctx_set_fault_to;
-    msg_ctx_impl->msg_ctx.ops->set_from = axis2_msg_ctx_set_from;
-    msg_ctx_impl->msg_ctx.ops->set_in_fault_flow = axis2_msg_ctx_set_in_fault_flow;
-    msg_ctx_impl->msg_ctx.ops->set_soap_envelope = axis2_msg_ctx_set_soap_envelope;
-    msg_ctx_impl->msg_ctx.ops->set_fault_soap_envelope = axis2_msg_ctx_set_fault_soap_envelope;
-    msg_ctx_impl->msg_ctx.ops->set_message_id = axis2_msg_ctx_set_message_id;
-    msg_ctx_impl->msg_ctx.ops->set_process_fault = axis2_msg_ctx_set_process_fault;
-    msg_ctx_impl->msg_ctx.ops->set_relates_to = axis2_msg_ctx_set_relates_to;
-    msg_ctx_impl->msg_ctx.ops->set_reply_to = axis2_msg_ctx_set_reply_to;
-    msg_ctx_impl->msg_ctx.ops->set_response_written = axis2_msg_ctx_set_response_written;
-    msg_ctx_impl->msg_ctx.ops->set_server_side = axis2_msg_ctx_set_server_side;
-    msg_ctx_impl->msg_ctx.ops->set_to = axis2_msg_ctx_set_to;
-    msg_ctx_impl->msg_ctx.ops->get_new_thread_required = axis2_msg_ctx_get_new_thread_required;
-    msg_ctx_impl->msg_ctx.ops->set_new_thread_required = axis2_msg_ctx_set_new_thread_required;
-    msg_ctx_impl->msg_ctx.ops->set_wsa_action = axis2_msg_ctx_set_wsa_action;
-    msg_ctx_impl->msg_ctx.ops->get_wsa_action = axis2_msg_ctx_get_wsa_action;
-    msg_ctx_impl->msg_ctx.ops->set_wsa_message_id = axis2_msg_ctx_set_wsa_message_id;
-    msg_ctx_impl->msg_ctx.ops->get_wsa_message_id = axis2_msg_ctx_get_wsa_message_id;
-    msg_ctx_impl->msg_ctx.ops->get_msg_info_headers = axis2_msg_ctx_get_msg_info_headers;
-    msg_ctx_impl->msg_ctx.ops->get_paused = axis2_msg_ctx_get_paused;
-    msg_ctx_impl->msg_ctx.ops->set_paused = axis2_msg_ctx_set_paused;
-    msg_ctx_impl->msg_ctx.ops->set_keep_alive = axis2_msg_ctx_set_keep_alive;
-    msg_ctx_impl->msg_ctx.ops->is_keep_alive = axis2_msg_ctx_is_keep_alive;
-    msg_ctx_impl->msg_ctx.ops->get_transport_in_desc = axis2_msg_ctx_get_transport_in_desc;
-    msg_ctx_impl->msg_ctx.ops->get_transport_out_desc = axis2_msg_ctx_get_transport_out_desc;
-    msg_ctx_impl->msg_ctx.ops->set_transport_in_desc = axis2_msg_ctx_set_transport_in_desc;
-    msg_ctx_impl->msg_ctx.ops->set_transport_out_desc = axis2_msg_ctx_set_transport_out_desc;
-    msg_ctx_impl->msg_ctx.ops->get_op_ctx = axis2_msg_ctx_get_op_ctx;
-    msg_ctx_impl->msg_ctx.ops->set_op_ctx = axis2_msg_ctx_set_op_ctx;
-    msg_ctx_impl->msg_ctx.ops->get_output_written = axis2_msg_ctx_get_output_written;
-    msg_ctx_impl->msg_ctx.ops->set_output_written = axis2_msg_ctx_set_output_written;
-    msg_ctx_impl->msg_ctx.ops->get_svc_ctx_id = axis2_msg_ctx_get_svc_ctx_id;
-    msg_ctx_impl->msg_ctx.ops->set_svc_ctx_id = axis2_msg_ctx_set_svc_ctx_id;
-    msg_ctx_impl->msg_ctx.ops->get_conf_ctx = axis2_msg_ctx_get_conf_ctx;
-    msg_ctx_impl->msg_ctx.ops->get_svc_ctx = axis2_msg_ctx_get_svc_ctx;
-    msg_ctx_impl->msg_ctx.ops->set_conf_ctx = axis2_msg_ctx_set_conf_ctx;
-    msg_ctx_impl->msg_ctx.ops->set_svc_ctx = axis2_msg_ctx_set_svc_ctx;
-    msg_ctx_impl->msg_ctx.ops->set_msg_info_headers = axis2_msg_ctx_set_msg_info_headers;
-    msg_ctx_impl->msg_ctx.ops->get_parameter = axis2_msg_ctx_get_parameter;
-    msg_ctx_impl->msg_ctx.ops->get_module_parameter = axis2_msg_ctx_get_module_parameter;
-    msg_ctx_impl->msg_ctx.ops->get_property = axis2_msg_ctx_get_property;
-    msg_ctx_impl->msg_ctx.ops->set_property = axis2_msg_ctx_set_property;
-    msg_ctx_impl->msg_ctx.ops->get_paused_handler_name = axis2_msg_ctx_get_paused_handler_name;
-    msg_ctx_impl->msg_ctx.ops->get_paused_phase_name = axis2_msg_ctx_get_paused_phase_name;
-    msg_ctx_impl->msg_ctx.ops->set_paused_phase_name = axis2_msg_ctx_set_paused_phase_name;
-    msg_ctx_impl->msg_ctx.ops->get_soap_action = axis2_msg_ctx_get_soap_action;
-    msg_ctx_impl->msg_ctx.ops->set_soap_action = axis2_msg_ctx_set_soap_action;
-    msg_ctx_impl->msg_ctx.ops->get_doing_mtom = axis2_msg_ctx_get_doing_mtom;
-    msg_ctx_impl->msg_ctx.ops->set_doing_mtom = axis2_msg_ctx_set_doing_mtom;
-    msg_ctx_impl->msg_ctx.ops->get_doing_rest = axis2_msg_ctx_get_doing_rest;
-    msg_ctx_impl->msg_ctx.ops->set_doing_rest = axis2_msg_ctx_set_doing_rest;
-    msg_ctx_impl->msg_ctx.ops->set_do_rest_through_post = axis2_msg_ctx_set_do_rest_through_post;
-    msg_ctx_impl->msg_ctx.ops->get_do_rest_through_post = axis2_msg_ctx_get_do_rest_through_post;
-    msg_ctx_impl->msg_ctx.ops->get_is_soap_11 = axis2_msg_ctx_get_is_soap_11;
-    msg_ctx_impl->msg_ctx.ops->set_is_soap_11 = axis2_msg_ctx_set_is_soap_11;
-    msg_ctx_impl->msg_ctx.ops->get_svc_grp_ctx = axis2_msg_ctx_get_svc_grp_ctx;
-    msg_ctx_impl->msg_ctx.ops->set_svc_grp_ctx = axis2_msg_ctx_set_svc_grp_ctx;
-    msg_ctx_impl->msg_ctx.ops->get_op = axis2_msg_ctx_get_op;
-    msg_ctx_impl->msg_ctx.ops->set_op = axis2_msg_ctx_set_op;
-    msg_ctx_impl->msg_ctx.ops->get_svc = axis2_msg_ctx_get_svc;
-    msg_ctx_impl->msg_ctx.ops->set_svc = axis2_msg_ctx_set_svc;
-    msg_ctx_impl->msg_ctx.ops->get_svc_grp = axis2_msg_ctx_get_svc_grp;
-    msg_ctx_impl->msg_ctx.ops->set_svc_grp = axis2_msg_ctx_set_svc_grp;
-    msg_ctx_impl->msg_ctx.ops->get_svc_grp_ctx_id = axis2_msg_ctx_get_svc_grp_ctx_id;
-    msg_ctx_impl->msg_ctx.ops->set_svc_grp_ctx_id = axis2_msg_ctx_set_svc_grp_ctx_id;
-    msg_ctx_impl->msg_ctx.ops->is_paused = axis2_msg_ctx_is_paused;
-    msg_ctx_impl->msg_ctx.ops->find_svc = axis2_msg_ctx_find_svc;
-    msg_ctx_impl->msg_ctx.ops->find_op = axis2_msg_ctx_find_op;
-    msg_ctx_impl->msg_ctx.ops->set_options = axis2_msg_ctx_set_options;
-    msg_ctx_impl->msg_ctx.ops->set_flow = axis2_msg_ctx_set_flow;
-    msg_ctx_impl->msg_ctx.ops->get_flow = axis2_msg_ctx_get_flow;
-    msg_ctx_impl->msg_ctx.ops->get_execution_chain =
-        axis2_msg_ctx_get_execution_chain;
-    msg_ctx_impl->msg_ctx.ops->set_execution_chain =
-        axis2_msg_ctx_set_execution_chain;
-    msg_ctx_impl->msg_ctx.ops->get_current_handler_index =
-        axis2_msg_ctx_get_current_handler_index;
-    msg_ctx_impl->msg_ctx.ops->set_current_handler_index =
-        axis2_msg_ctx_set_current_handler_index;
-    msg_ctx_impl->msg_ctx.ops->get_paused_handler_index =
-        axis2_msg_ctx_get_paused_handler_index;
-    msg_ctx_impl->msg_ctx.ops->get_current_phase_index =
-        axis2_msg_ctx_get_current_phase_index;
-    msg_ctx_impl->msg_ctx.ops->set_current_phase_index =
-        axis2_msg_ctx_set_current_phase_index;
-    msg_ctx_impl->msg_ctx.ops->get_paused_phase_index =
-        axis2_msg_ctx_get_paused_phase_index;
-    return &(msg_ctx_impl->msg_ctx);
+    return msg_ctx;
 }
 
 /******************************************************************************/
@@ -877,7 +244,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->base;
+    return msg_ctx->base;
 }
 
 
@@ -887,7 +254,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->parent;
+    return msg_ctx->parent;
 }
 
 axis2_status_t AXIS2_CALL
@@ -900,7 +267,7 @@
 
     if (parent)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->parent = parent;
+        msg_ctx->parent = parent;
     }
 
     return AXIS2_SUCCESS;
@@ -911,77 +278,67 @@
     axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->paused || msg_ctx_impl->keep_alive)
+    if (msg_ctx->paused || msg_ctx->keep_alive)
         return AXIS2_SUCCESS;
     
-    if (msg_ctx_impl->msg_ctx.ops)
-    {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->msg_ctx.ops);
-        msg_ctx_impl->msg_ctx.ops = NULL;
-    }
-
-    if (msg_ctx_impl->base)
+    if (msg_ctx->base)
     {
-        AXIS2_CTX_FREE(msg_ctx_impl->base, env);
-        msg_ctx_impl->base = NULL;
+        AXIS2_CTX_FREE(msg_ctx->base, env);
+        msg_ctx->base = NULL;
     }
 
-    if (msg_ctx_impl->msg_info_headers && msg_ctx_impl->msg_info_headers_deep_copy)
+    if (msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy)
     {
-        AXIS2_MSG_INFO_HEADERS_FREE(msg_ctx_impl->msg_info_headers, env);
-        msg_ctx_impl->msg_info_headers = NULL;
+        AXIS2_MSG_INFO_HEADERS_FREE(msg_ctx->msg_info_headers, env);
+        msg_ctx->msg_info_headers = NULL;
     }
 
-    if (msg_ctx_impl->message_id)
+    if (msg_ctx->message_id)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->message_id);
-        msg_ctx_impl->message_id = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->message_id);
+        msg_ctx->message_id = NULL;
     }
 
-    if (msg_ctx_impl->svc_ctx_id)
+    if (msg_ctx->svc_ctx_id)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->svc_ctx_id);
-        msg_ctx_impl->svc_ctx_id = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->svc_ctx_id);
+        msg_ctx->svc_ctx_id = NULL;
     }
 
-    if (msg_ctx_impl->paused_phase_name)
+    if (msg_ctx->paused_phase_name)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->paused_phase_name);
-        msg_ctx_impl->paused_phase_name = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->paused_phase_name);
+        msg_ctx->paused_phase_name = NULL;
     }
 
-    if (msg_ctx_impl->soap_action)
+    if (msg_ctx->soap_action)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->soap_action);
-        msg_ctx_impl->soap_action = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->soap_action);
+        msg_ctx->soap_action = NULL;
     }
 
-    if (msg_ctx_impl->svc_grp_ctx_id)
+    if (msg_ctx->svc_grp_ctx_id)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->svc_grp_ctx_id);
-        msg_ctx_impl->svc_grp_ctx_id = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->svc_grp_ctx_id);
+        msg_ctx->svc_grp_ctx_id = NULL;
     }
 
-    if (msg_ctx_impl->soap_envelope)
+    if (msg_ctx->soap_envelope)
     {
-        AXIOM_SOAP_ENVELOPE_FREE(msg_ctx_impl->soap_envelope, env);
-        msg_ctx_impl->soap_envelope = NULL;
+        AXIOM_SOAP_ENVELOPE_FREE(msg_ctx->soap_envelope, env);
+        msg_ctx->soap_envelope = NULL;
     }
 
-    if (msg_ctx_impl->fault_soap_envelope)
+    if (msg_ctx->fault_soap_envelope)
     {
-        AXIOM_SOAP_ENVELOPE_FREE(msg_ctx_impl->fault_soap_envelope, env);
-        msg_ctx_impl->fault_soap_envelope = NULL;
+        AXIOM_SOAP_ENVELOPE_FREE(msg_ctx->fault_soap_envelope, env);
+        msg_ctx->fault_soap_envelope = NULL;
     }
 
-    AXIS2_FREE(env->allocator, msg_ctx_impl);
-    msg_ctx_impl = NULL;
+    AXIS2_FREE(env->allocator, msg_ctx);
+    msg_ctx = NULL;
 
     return AXIS2_SUCCESS;
 }
@@ -992,42 +349,38 @@
     const axis2_env_t *env,
     struct axis2_conf *conf)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->transport_in_desc_qname)
+    if (msg_ctx->transport_in_desc_qname)
     {
-        msg_ctx_impl->transport_in_desc = AXIS2_CONF_GET_TRANSPORT_IN(conf, env,
-                msg_ctx_impl->transport_in_desc_qname);
+        msg_ctx->transport_in_desc = AXIS2_CONF_GET_TRANSPORT_IN(conf, env,
+                msg_ctx->transport_in_desc_qname);
     }
 
-    if (msg_ctx_impl->transport_out_desc_qname)
+    if (msg_ctx->transport_out_desc_qname)
     {
-        msg_ctx_impl->transport_out_desc = AXIS2_CONF_GET_TRANSPORT_OUT(conf,
-                env, msg_ctx_impl->transport_out_desc_qname);
+        msg_ctx->transport_out_desc = AXIS2_CONF_GET_TRANSPORT_OUT(conf,
+                env, msg_ctx->transport_out_desc_qname);
     }
 
-    if (msg_ctx_impl->svc_grp_id)
+    if (msg_ctx->svc_grp_id)
     {
-        msg_ctx_impl->svc_grp = AXIS2_CONF_GET_SVC_GRP(conf, env,
-                msg_ctx_impl->svc_grp_id);
+        msg_ctx->svc_grp = AXIS2_CONF_GET_SVC_GRP(conf, env,
+                msg_ctx->svc_grp_id);
     }
 
-    if (msg_ctx_impl->svc_qname)
+    if (msg_ctx->svc_qname)
     {
-        msg_ctx_impl->svc = AXIS2_CONF_GET_SVC(conf, env,
-                AXIS2_QNAME_GET_LOCALPART(msg_ctx_impl->svc_qname, env));
+        msg_ctx->svc = AXIS2_CONF_GET_SVC(conf, env,
+                AXIS2_QNAME_GET_LOCALPART(msg_ctx->svc_qname, env));
     }
 
-    if (msg_ctx_impl->op_qname)
+    if (msg_ctx->op_qname)
     {
-        if (msg_ctx_impl->svc)
-            msg_ctx_impl->op = AXIS2_SVC_GET_OP_WITH_QNAME(msg_ctx_impl->svc,
-                    env, msg_ctx_impl->op_qname);
+        if (msg_ctx->svc)
+            msg_ctx->op = AXIS2_SVC_GET_OP_WITH_QNAME(msg_ctx->svc,
+                    env, msg_ctx->op_qname);
     }
 
     return AXIS2_SUCCESS;
@@ -1041,15 +394,11 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_GET_FAULT_TO(msg_ctx_impl->msg_info_headers, env);
+        return AXIS2_MSG_INFO_HEADERS_GET_FAULT_TO(msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1061,15 +410,11 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_GET_FROM(msg_ctx_impl->msg_info_headers, env);
+        return AXIS2_MSG_INFO_HEADERS_GET_FROM(msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1081,7 +426,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->in_fault_flow;
+    return msg_ctx->in_fault_flow;
 }
 
 axiom_soap_envelope_t *AXIS2_CALL
@@ -1090,7 +435,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->soap_envelope;
+    return msg_ctx->soap_envelope;
 }
 
 axiom_soap_envelope_t *AXIS2_CALL
@@ -1099,7 +444,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->fault_soap_envelope;
+    return msg_ctx->fault_soap_envelope;
 }
 
 const axis2_char_t *AXIS2_CALL
@@ -1107,16 +452,12 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
         return AXIS2_MSG_INFO_HEADERS_GET_MESSAGE_ID(
-                    msg_ctx_impl->msg_info_headers, env);
+                    msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1128,7 +469,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->process_fault;
+    return msg_ctx->process_fault;
 }
 
 axis2_relates_to_t *AXIS2_CALL
@@ -1136,15 +477,11 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_GET_RELATES_TO(msg_ctx_impl->msg_info_headers, env);
+        return AXIS2_MSG_INFO_HEADERS_GET_RELATES_TO(msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1155,15 +492,11 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_GET_REPLY_TO(msg_ctx_impl->msg_info_headers, env);
+        return AXIS2_MSG_INFO_HEADERS_GET_REPLY_TO(msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1175,7 +508,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->response_written;
+    return msg_ctx->response_written;
 }
 
 axis2_bool_t AXIS2_CALL
@@ -1184,7 +517,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->server_side;
+    return msg_ctx->server_side;
 }
 
 axis2_endpoint_ref_t *AXIS2_CALL
@@ -1192,15 +525,11 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_GET_TO(msg_ctx_impl->msg_info_headers, env);
+        return AXIS2_MSG_INFO_HEADERS_GET_TO(msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1213,15 +542,11 @@
     const axis2_env_t *env,
     axis2_endpoint_ref_t *reference)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_SET_TO(msg_ctx_impl->msg_info_headers,
+        return AXIS2_MSG_INFO_HEADERS_SET_TO(msg_ctx->msg_info_headers,
                 env, reference);
     }
 
@@ -1234,16 +559,11 @@
     const axis2_env_t *env,
     axis2_endpoint_ref_t *reference)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_SET_FROM(msg_ctx_impl->msg_info_headers,
+        return AXIS2_MSG_INFO_HEADERS_SET_FROM(msg_ctx->msg_info_headers,
                 env, reference);
     }
 
@@ -1258,7 +578,7 @@
     axis2_bool_t in_fault_flow)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->in_fault_flow = in_fault_flow;
+    msg_ctx->in_fault_flow = in_fault_flow;
     return  AXIS2_SUCCESS;
 }
 
@@ -1275,7 +595,7 @@
         axiom_namespace_t *ns = NULL;
         axis2_char_t *soap_ns = NULL;
 
-        AXIS2_INTF_TO_IMPL(msg_ctx)->soap_envelope  = soap_envelope ;
+        msg_ctx->soap_envelope  = soap_envelope ;
         ns = AXIOM_SOAP_ENVELOPE_GET_NAMESPACE(soap_envelope, env);
         if (ns)
         {
@@ -1284,10 +604,10 @@
             {
                 if (AXIS2_STRCASECMP(soap_ns,
                         AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) == 0)
-                    AXIS2_INTF_TO_IMPL(msg_ctx)->is_soap_11 = AXIS2_FALSE;
+                    msg_ctx->is_soap_11 = AXIS2_FALSE;
                 else if (AXIS2_STRCASECMP(soap_ns,
                         AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) == 0)
-                    AXIS2_INTF_TO_IMPL(msg_ctx)->is_soap_11 = AXIS2_TRUE;
+                    msg_ctx->is_soap_11 = AXIS2_TRUE;
                 else
                 {
                     AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOAP_VERSION,
@@ -1303,7 +623,9 @@
         return AXIS2_FAILURE;
     }
     else
-        AXIS2_INTF_TO_IMPL(msg_ctx)->soap_envelope = NULL;
+    {
+        msg_ctx->soap_envelope = NULL;
+    }
 
     return AXIS2_SUCCESS;
 }
@@ -1315,7 +637,7 @@
     axiom_soap_envelope_t *soap_envelope)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->fault_soap_envelope  = soap_envelope ;
+    msg_ctx->fault_soap_envelope  = soap_envelope ;
     return AXIS2_SUCCESS;
 }
 
@@ -1325,17 +647,12 @@
     const axis2_env_t *env,
     const axis2_char_t *message_id)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
         return AXIS2_MSG_INFO_HEADERS_SET_MESSAGE_ID(
-                    msg_ctx_impl->msg_info_headers, env, message_id);
+                    msg_ctx->msg_info_headers, env, message_id);
     }
 
     return AXIS2_SUCCESS;
@@ -1349,7 +666,7 @@
     axis2_bool_t process_fault)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->process_fault  = process_fault;
+    msg_ctx->process_fault  = process_fault;
     return  AXIS2_SUCCESS;
 }
 
@@ -1359,17 +676,12 @@
     const axis2_env_t *env,
     axis2_relates_to_t *reference)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
         return AXIS2_MSG_INFO_HEADERS_SET_RELATES_TO(
-                    msg_ctx_impl->msg_info_headers, env, reference);
+                    msg_ctx->msg_info_headers, env, reference);
     }
 
     return AXIS2_SUCCESS;
@@ -1382,17 +694,12 @@
     const axis2_env_t *env,
     axis2_endpoint_ref_t *reference)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
         return AXIS2_MSG_INFO_HEADERS_SET_REPLY_TO(
-                    msg_ctx_impl->msg_info_headers, env, reference);
+                    msg_ctx->msg_info_headers, env, reference);
     }
 
     return AXIS2_SUCCESS;
@@ -1405,7 +712,7 @@
     axis2_bool_t response_written)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->response_written  = response_written ;
+    msg_ctx->response_written  = response_written ;
     return  AXIS2_SUCCESS;
 }
 
@@ -1416,7 +723,7 @@
     axis2_bool_t server_side)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->server_side = server_side;
+    msg_ctx->server_side = server_side;
     return  AXIS2_SUCCESS;
 }
 
@@ -1426,16 +733,11 @@
     const axis2_env_t *env,
     axis2_endpoint_ref_t *reference)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_SET_TO(msg_ctx_impl->msg_info_headers,
+        return AXIS2_MSG_INFO_HEADERS_SET_TO(msg_ctx->msg_info_headers,
                 env, reference);
     }
 
@@ -1448,7 +750,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->new_thread_required;
+    return msg_ctx->new_thread_required;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1458,7 +760,7 @@
     axis2_bool_t new_thread_required)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->new_thread_required = new_thread_required;
+    msg_ctx->new_thread_required = new_thread_required;
     return AXIS2_SUCCESS;
 }
 
@@ -1468,16 +770,11 @@
     const axis2_env_t *env,
     const axis2_char_t *action_uri)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_SET_ACTION(msg_ctx_impl->msg_info_headers,
+        return AXIS2_MSG_INFO_HEADERS_SET_ACTION(msg_ctx->msg_info_headers,
                 env, action_uri);
     }
 
@@ -1489,16 +786,11 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
-        return AXIS2_MSG_INFO_HEADERS_GET_ACTION(msg_ctx_impl->msg_info_headers,
+        return AXIS2_MSG_INFO_HEADERS_GET_ACTION(msg_ctx->msg_info_headers,
                 env);
     }
 
@@ -1511,17 +803,12 @@
     const axis2_env_t *env,
     const axis2_char_t *message_id)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
         return AXIS2_MSG_INFO_HEADERS_SET_MESSAGE_ID(
-                    msg_ctx_impl->msg_info_headers, env, message_id);
+                    msg_ctx->msg_info_headers, env, message_id);
     }
 
     return AXIS2_SUCCESS;
@@ -1532,17 +819,12 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, NULL);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-
-    if (msg_ctx_impl->msg_info_headers)
+    if (msg_ctx->msg_info_headers)
     {
         return AXIS2_MSG_INFO_HEADERS_GET_MESSAGE_ID(
-                    msg_ctx_impl->msg_info_headers, env);
+                    msg_ctx->msg_info_headers, env);
     }
 
     return NULL;
@@ -1555,7 +837,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers;
+    return msg_ctx->msg_info_headers;
 }
 
 axis2_bool_t AXIS2_CALL
@@ -1564,7 +846,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->paused;
+    return msg_ctx->paused;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1573,12 +855,9 @@
     const axis2_env_t *env,
     axis2_bool_t paused)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-    msg_ctx_impl->paused = paused;
-    msg_ctx_impl->paused_phase_index = msg_ctx_impl->current_phase_index;
+    msg_ctx->paused = paused;
+    msg_ctx->paused_phase_index = msg_ctx->current_phase_index;
     return AXIS2_SUCCESS;
 }
 
@@ -1588,11 +867,8 @@
     const axis2_env_t *env,
     axis2_bool_t keep_alive)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-    msg_ctx_impl->keep_alive = keep_alive;
+    msg_ctx->keep_alive = keep_alive;
     return AXIS2_SUCCESS;
 }
 
@@ -1602,7 +878,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->keep_alive;
+    return msg_ctx->keep_alive;
 }
 
 struct axis2_transport_in_desc *AXIS2_CALL
@@ -1611,7 +887,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->transport_in_desc;
+    return msg_ctx->transport_in_desc;
 }
 
 struct axis2_transport_out_desc *AXIS2_CALL
@@ -1620,7 +896,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->transport_out_desc;
+    return msg_ctx->transport_out_desc;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1633,8 +909,8 @@
 
     if (transport_in_desc)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->transport_in_desc = transport_in_desc;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->transport_in_desc_qname =
+        msg_ctx->transport_in_desc = transport_in_desc;
+        msg_ctx->transport_in_desc_qname =
             (axis2_qname_t *)AXIS2_TRANSPORT_IN_DESC_GET_QNAME(transport_in_desc, env);
     }
 
@@ -1651,8 +927,8 @@
 
     if (transport_out_desc)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->transport_out_desc = transport_out_desc;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->transport_out_desc_qname =
+        msg_ctx->transport_out_desc = transport_out_desc;
+        msg_ctx->transport_out_desc_qname =
             (axis2_qname_t *)AXIS2_TRANSPORT_OUT_DESC_GET_QNAME(transport_out_desc, env);
     }
 
@@ -1665,7 +941,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->op_ctx;
+    return msg_ctx->op_ctx;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1674,22 +950,18 @@
     const axis2_env_t *env,
     struct axis2_op_ctx *op_ctx)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
     if (op_ctx)
     {
-        msg_ctx_impl->op_ctx = op_ctx;
+        msg_ctx->op_ctx = op_ctx;
 
-        if (msg_ctx_impl->svc_ctx)
+        if (msg_ctx->svc_ctx)
         {
-            if (!(AXIS2_OP_CTX_GET_PARENT(msg_ctx_impl->op_ctx, env)))
+            if (!(AXIS2_OP_CTX_GET_PARENT(msg_ctx->op_ctx, env)))
             {
-                AXIS2_OP_CTX_SET_PARENT(msg_ctx_impl->op_ctx, env,
-                        msg_ctx_impl->svc_ctx);
+                AXIS2_OP_CTX_SET_PARENT(msg_ctx->op_ctx, env,
+                        msg_ctx->svc_ctx);
             }
         }
         axis2_msg_ctx_set_parent(msg_ctx, env, op_ctx);
@@ -1704,7 +976,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->output_written;
+    return msg_ctx->output_written;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1714,7 +986,7 @@
     axis2_bool_t output_written)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->output_written = output_written;
+    msg_ctx->output_written = output_written;
     return AXIS2_SUCCESS;
 }
 
@@ -1724,7 +996,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->svc_ctx_id;
+    return msg_ctx->svc_ctx_id;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1733,22 +1005,18 @@
     const axis2_env_t *env,
     const axis2_char_t *svc_ctx_id)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->svc_ctx_id)
+    if (msg_ctx->svc_ctx_id)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->svc_ctx_id);
-        msg_ctx_impl->svc_ctx_id = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->svc_ctx_id);
+        msg_ctx->svc_ctx_id = NULL;
     }
 
     if (svc_ctx_id)
     {
-        msg_ctx_impl->svc_ctx_id = AXIS2_STRDUP(svc_ctx_id, env);
-        if (!(msg_ctx_impl->svc_ctx_id))
+        msg_ctx->svc_ctx_id = AXIS2_STRDUP(svc_ctx_id, env);
+        if (!(msg_ctx->svc_ctx_id))
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return AXIS2_FAILURE;
@@ -1763,7 +1031,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->conf_ctx;
+    return msg_ctx->conf_ctx;
 }
 
 struct axis2_svc_ctx *AXIS2_CALL
@@ -1772,7 +1040,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->svc_ctx;
+    return msg_ctx->svc_ctx;
 }
 
 axis2_status_t AXIS2_CALL
@@ -1785,7 +1053,7 @@
 
     if (conf_ctx)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->conf_ctx = conf_ctx;
+        msg_ctx->conf_ctx = conf_ctx;
     }
 
     return AXIS2_SUCCESS;
@@ -1797,20 +1065,16 @@
     const axis2_env_t *env,
     struct axis2_svc_ctx *svc_ctx)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
     if (svc_ctx)
     {
-        msg_ctx_impl->svc_ctx = svc_ctx;
+        msg_ctx->svc_ctx = svc_ctx;
 
-        if (msg_ctx_impl->op_ctx)
+        if (msg_ctx->op_ctx)
         {
-            if (!AXIS2_OP_CTX_GET_PARENT(msg_ctx_impl->op_ctx, env))
-                AXIS2_OP_CTX_SET_PARENT(msg_ctx_impl->op_ctx, env, svc_ctx);
+            if (!AXIS2_OP_CTX_GET_PARENT(msg_ctx->op_ctx, env))
+                AXIS2_OP_CTX_SET_PARENT(msg_ctx->op_ctx, env, svc_ctx);
         }
         axis2_msg_ctx_set_svc(msg_ctx, env, AXIS2_SVC_CTX_GET_SVC(svc_ctx, env));
     }
@@ -1828,15 +1092,14 @@
 
     if (msg_info_headers)
     {
-        if (AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers && 
-            AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers_deep_copy)
+        if (msg_ctx->msg_info_headers && 
+            msg_ctx->msg_info_headers_deep_copy)
         {
-            AXIS2_MSG_INFO_HEADERS_FREE(
-                AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers, env);
-            AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers = NULL;
+            AXIS2_MSG_INFO_HEADERS_FREE(msg_ctx->msg_info_headers, env);
+            msg_ctx->msg_info_headers = NULL;
         }
-        AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers = msg_info_headers;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers_deep_copy = AXIS2_FALSE;
+        msg_ctx->msg_info_headers = msg_info_headers;
+        msg_ctx->msg_info_headers_deep_copy = AXIS2_FALSE;
     }
 
     return AXIS2_SUCCESS;
@@ -1849,43 +1112,40 @@
     const axis2_env_t *env,
     const axis2_char_t *key)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
     axis2_param_t *param = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->op)
+    if (msg_ctx->op)
     {
-        param = AXIS2_OP_GET_PARAM(msg_ctx_impl->op, env, key);
+        param = AXIS2_OP_GET_PARAM(msg_ctx->op, env, key);
         if (param)
         {
             return param;
         }
     }
 
-    if (msg_ctx_impl->svc)
+    if (msg_ctx->svc)
     {
-        param = AXIS2_SVC_GET_PARAM(msg_ctx_impl->svc, env, key);
+        param = AXIS2_SVC_GET_PARAM(msg_ctx->svc, env, key);
         if (param)
         {
             return param;
         }
     }
 
-    if (msg_ctx_impl->svc_grp)
+    if (msg_ctx->svc_grp)
     {
-        param = AXIS2_SVC_GRP_GET_PARAM(msg_ctx_impl->svc_grp, env, key);
+        param = AXIS2_SVC_GRP_GET_PARAM(msg_ctx->svc_grp, env, key);
         if (param)
         {
             return param;
         }
     }
 
-    if (msg_ctx_impl->conf_ctx)
+    if (msg_ctx->conf_ctx)
     {
-        axis2_conf_t *conf = AXIS2_CONF_CTX_GET_CONF(msg_ctx_impl->conf_ctx, env);
+        axis2_conf_t *conf = AXIS2_CONF_CTX_GET_CONF(msg_ctx->conf_ctx, env);
         param = AXIS2_CONF_GET_PARAM(conf, env, key);
     }
 
@@ -1902,7 +1162,7 @@
     axis2_handler_desc_t *handler_desc)
 {
     /** NOTE: This method is not used in anywhere, hence can be removed*/
-    /*axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+    /*
     axis2_param_t *param = NULL;
     axis2_module_desc_t *module_desc = NULL;
     axis2_qname_t *qname = NULL;
@@ -1911,13 +1171,11 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     /*AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
     qname = axis2_qname_create(env, module_name, NULL, NULL);
 
-    if (msg_ctx_impl->op)
+    if (msg_ctx->op)
     {
-        module_desc = AXIS2_OP_GET_MODULE_DESC(msg_ctx_impl->op, env, qname);
+        module_desc = AXIS2_OP_GET_MODULE_DESC(msg_ctx->op, env, qname);
         AXIS2_QNAME_FREE(qname, env);
         if (module_desc) 
         {
@@ -1928,7 +1186,7 @@
             } 
             else 
             {
-                param = AXIS2_OP_GET_PARAM(msg_ctx_impl->op, env, key);
+                param = AXIS2_OP_GET_PARAM(msg_ctx->op, env, key);
                 if (param)
                 {
                     return param;
@@ -1937,9 +1195,9 @@
         }
     }
 
-    if (msg_ctx_impl->svc)
+    if (msg_ctx->svc)
     {
-        module_desc = AXIS2_SVC_GET_MODULE_DESC(msg_ctx_impl->svc, env, qname);
+        module_desc = AXIS2_SVC_GET_MODULE_DESC(msg_ctx->svc, env, qname);
         AXIS2_QNAME_FREE(qname, env);
         if (module_desc) 
         {
@@ -1950,7 +1208,7 @@
             } 
             else 
             {
-                param = AXIS2_SVC_GET_PARAM(msg_ctx_impl->svc, env, key);
+                param = AXIS2_SVC_GET_PARAM(msg_ctx->svc, env, key);
                 if (param)
                 {
                     return param;
@@ -1959,9 +1217,9 @@
         }
     }
 
-    if (msg_ctx_impl->svc_grp)
+    if (msg_ctx->svc_grp)
     {
-        module_desc = AXIS2_SVC_GRP_GET_MODULE_DESC(msg_ctx_impl->svc_grp, env, qname);
+        module_desc = AXIS2_SVC_GRP_GET_MODULE_DESC(msg_ctx->svc_grp, env, qname);
         AXIS2_QNAME_FREE(qname, env);
         if (module_desc) 
         {
@@ -1972,7 +1230,7 @@
             } 
             else 
             {
-                param = AXIS2_SVC_GRP_GET_PARAM(msg_ctx_impl->svc_grp, env, key);
+                param = AXIS2_SVC_GRP_GET_PARAM(msg_ctx->svc_grp, env, key);
                 if (param)
                 {
                     return param;
@@ -1981,7 +1239,7 @@
         }
     }
 
-    conf = AXIS2_CONF_CTX_GET_CONF(msg_ctx_impl->conf_ctx, env);
+    conf = AXIS2_CONF_CTX_GET_CONF(msg_ctx->conf_ctx, env);
     if (conf)
     {
         module_desc = AXIS2_CONF_GET_MODULE_DESC(conf, env, qname);
@@ -2034,24 +1292,21 @@
     const axis2_char_t *key,
     const axis2_bool_t persistent)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
     void *obj = NULL;
     axis2_ctx_t *ctx = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
     /* search in message context */
-    obj = AXIS2_CTX_GET_PROPERTY(msg_ctx_impl->base, env, key, persistent);
+    obj = AXIS2_CTX_GET_PROPERTY(msg_ctx->base, env, key, persistent);
     if (obj)
     {
         return obj;
     }
 
-    if (msg_ctx_impl->op_ctx)
+    if (msg_ctx->op_ctx)
     {
-        ctx = AXIS2_OP_CTX_GET_BASE(msg_ctx_impl->op_ctx, env);
+        ctx = AXIS2_OP_CTX_GET_BASE(msg_ctx->op_ctx, env);
         if (ctx)
         {
             obj = AXIS2_CTX_GET_PROPERTY(ctx, env, key, persistent);
@@ -2062,9 +1317,9 @@
         }
     }
 
-    if (msg_ctx_impl->svc_ctx)
+    if (msg_ctx->svc_ctx)
     {
-        ctx = AXIS2_SVC_CTX_GET_BASE(msg_ctx_impl->svc_ctx, env);
+        ctx = AXIS2_SVC_CTX_GET_BASE(msg_ctx->svc_ctx, env);
         if (ctx)
         {
             obj = AXIS2_CTX_GET_PROPERTY(ctx, env, key, persistent);
@@ -2075,9 +1330,9 @@
         }
     }
 
-    if (msg_ctx_impl->svc_grp_ctx)
+    if (msg_ctx->svc_grp_ctx)
     {
-        ctx = AXIS2_SVC_GRP_CTX_GET_BASE(msg_ctx_impl->svc_grp_ctx, env);
+        ctx = AXIS2_SVC_GRP_CTX_GET_BASE(msg_ctx->svc_grp_ctx, env);
         if (ctx)
         {
             obj = AXIS2_CTX_GET_PROPERTY(ctx, env, key, persistent);
@@ -2088,9 +1343,9 @@
         }
     }
 
-    if (msg_ctx_impl->conf_ctx)
+    if (msg_ctx->conf_ctx)
     {
-        ctx = AXIS2_CONF_CTX_GET_BASE(msg_ctx_impl->conf_ctx, env);
+        ctx = AXIS2_CONF_CTX_GET_BASE(msg_ctx->conf_ctx, env);
         if (ctx)
         {
             obj = AXIS2_CTX_GET_PROPERTY(ctx, env, key, persistent);
@@ -2112,13 +1367,9 @@
     axis2_property_t *value,
     axis2_bool_t persistent)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    return AXIS2_CTX_SET_PROPERTY(msg_ctx_impl->base, env, key, value, persistent);
+    return AXIS2_CTX_SET_PROPERTY(msg_ctx->base, env, key, value, persistent);
 }
 
 const axis2_qname_t *AXIS2_CALL
@@ -2127,7 +1378,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->paused_handler_name;
+    return msg_ctx->paused_handler_name;
 }
 
 const axis2_char_t *AXIS2_CALL
@@ -2136,7 +1387,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->paused_phase_name;
+    return msg_ctx->paused_phase_name;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2145,22 +1396,18 @@
     const axis2_env_t *env,
     const axis2_char_t *paused_phase_name)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->paused_phase_name)
+    if (msg_ctx->paused_phase_name)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->paused_phase_name);
-        msg_ctx_impl->paused_phase_name = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->paused_phase_name);
+        msg_ctx->paused_phase_name = NULL;
     }
 
     if (paused_phase_name)
     {
-        msg_ctx_impl->paused_phase_name = AXIS2_STRDUP(paused_phase_name, env);
-        if (!(msg_ctx_impl->paused_phase_name))
+        msg_ctx->paused_phase_name = AXIS2_STRDUP(paused_phase_name, env);
+        if (!(msg_ctx->paused_phase_name))
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return AXIS2_FAILURE;
@@ -2176,7 +1423,7 @@
 {
     AXIS2_ENV_CHECK(env, NULL);
 
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->soap_action;
+    return msg_ctx->soap_action;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2185,22 +1432,18 @@
     const axis2_env_t *env,
     const axis2_char_t *soap_action)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->soap_action)
+    if (msg_ctx->soap_action)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->soap_action);
-        msg_ctx_impl->soap_action = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->soap_action);
+        msg_ctx->soap_action = NULL;
     }
 
     if (soap_action)
     {
-        msg_ctx_impl->soap_action = AXIS2_STRDUP(soap_action, env);
-        if (!(msg_ctx_impl->soap_action))
+        msg_ctx->soap_action = AXIS2_STRDUP(soap_action, env);
+        if (!(msg_ctx->soap_action))
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return AXIS2_FAILURE;
@@ -2215,7 +1458,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->doing_mtom;
+    return msg_ctx->doing_mtom;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2225,7 +1468,7 @@
     axis2_bool_t doing_mtom)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->doing_mtom = doing_mtom;
+    msg_ctx->doing_mtom = doing_mtom;
     return AXIS2_SUCCESS;
 }
 
@@ -2235,7 +1478,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->doing_rest;
+    return msg_ctx->doing_rest;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2245,7 +1488,7 @@
     axis2_bool_t doing_rest)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->doing_rest = doing_rest;
+    msg_ctx->doing_rest = doing_rest;
     return AXIS2_SUCCESS;
 }
 
@@ -2256,7 +1499,7 @@
     axis2_bool_t do_rest_through_post)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->do_rest_through_post = do_rest_through_post;
+    msg_ctx->do_rest_through_post = do_rest_through_post;
     return AXIS2_SUCCESS;
 }
 
@@ -2266,7 +1509,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->do_rest_through_post;
+    return msg_ctx->do_rest_through_post;
 }
 
 axis2_bool_t AXIS2_CALL
@@ -2275,7 +1518,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->is_soap_11;
+    return msg_ctx->is_soap_11;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2285,7 +1528,7 @@
     axis2_bool_t is_soap11)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->is_soap_11 = is_soap11;
+    msg_ctx->is_soap_11 = is_soap11;
     return AXIS2_SUCCESS;
 }
 
@@ -2295,7 +1538,7 @@
                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp_ctx;
+    return msg_ctx->svc_grp_ctx;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2308,7 +1551,7 @@
 
     if (svc_grp_ctx)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp_ctx = svc_grp_ctx;
+        msg_ctx->svc_grp_ctx = svc_grp_ctx;
     }
 
     return AXIS2_SUCCESS;
@@ -2320,7 +1563,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->op;
+    return msg_ctx->op;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2333,8 +1576,8 @@
 
     if (op)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->op = op;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->op_qname = (axis2_qname_t *)AXIS2_OP_GET_QNAME(op, env);
+        msg_ctx->op = op;
+        msg_ctx->op_qname = (axis2_qname_t *)AXIS2_OP_GET_QNAME(op, env);
     }
 
     return AXIS2_SUCCESS;
@@ -2346,7 +1589,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->svc;
+    return msg_ctx->svc;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2360,14 +1603,14 @@
     if (svc)
     {
         axis2_svc_grp_t *svc_grp = NULL;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->svc = svc;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->svc_qname = (axis2_qname_t *)AXIS2_SVC_GET_QNAME(svc, env);
+        msg_ctx->svc = svc;
+        msg_ctx->svc_qname = (axis2_qname_t *)AXIS2_SVC_GET_QNAME(svc, env);
 
         svc_grp = AXIS2_SVC_GET_PARENT(svc, env);
         if (svc_grp)
         {
-            AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp = svc_grp;
-            AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp_id =
+            msg_ctx->svc_grp = svc_grp;
+            msg_ctx->svc_grp_id =
                 (axis2_char_t *)AXIS2_SVC_GRP_GET_NAME(svc_grp, env);
         }
     }
@@ -2381,7 +1624,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp;
+    return msg_ctx->svc_grp;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2394,8 +1637,8 @@
 
     if (svc_grp)
     {
-        AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp = svc_grp;
-        AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp_id =
+        msg_ctx->svc_grp = svc_grp;
+        msg_ctx->svc_grp_id =
             (axis2_char_t *)AXIS2_SVC_GRP_GET_NAME(svc_grp, env);
     }
 
@@ -2408,7 +1651,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->svc_grp_ctx_id;
+    return msg_ctx->svc_grp_ctx_id;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2417,22 +1660,18 @@
     const axis2_env_t *env,
     const axis2_char_t *svc_grp_ctx_id)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (msg_ctx_impl->svc_grp_ctx_id)
+    if (msg_ctx->svc_grp_ctx_id)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->svc_grp_ctx_id);
-        msg_ctx_impl->svc_grp_ctx_id = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->svc_grp_ctx_id);
+        msg_ctx->svc_grp_ctx_id = NULL;
     }
 
     if (svc_grp_ctx_id)
     {
-        msg_ctx_impl->svc_grp_ctx_id = AXIS2_STRDUP(svc_grp_ctx_id, env);
-        if (!(msg_ctx_impl->svc_grp_ctx_id))
+        msg_ctx->svc_grp_ctx_id = AXIS2_STRDUP(svc_grp_ctx_id, env);
+        if (!(msg_ctx->svc_grp_ctx_id))
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return AXIS2_FAILURE;
@@ -2447,24 +1686,29 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->paused;
+    return msg_ctx->paused;
 }
 
-axis2_svc_t *AXIS2_CALL
-axis2_msg_ctx_find_svc(
+axis2_status_t AXIS2_CALL
+axis2_msg_ctx_set_find_svc(
     axis2_msg_ctx_t *msg_ctx,
-    const axis2_env_t *env)
+    const axis2_env_t *env, 
+    void *func)
 {
-    return NULL;
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    msg_ctx->find_svc = func;
+    return AXIS2_SUCCESS;
 }
 
-axis2_op_t *AXIS2_CALL
-axis2_msg_ctx_find_op(
+axis2_status_t AXIS2_CALL
+axis2_msg_ctx_set_find_op(
     axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env,
-    axis2_svc_t *svc)
+    void *func)
 {
-    return NULL;
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    msg_ctx->find_op = func;
+    return AXIS2_SUCCESS;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2473,7 +1717,6 @@
     const axis2_env_t *env,
     axis2_options_t *options)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
     axis2_property_t *rest_val = NULL;
 	axis2_char_t *value;
 	const axis2_char_t *soap_action = NULL;;
@@ -2481,19 +1724,17 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, options, AXIS2_FAILURE);
 
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-
-    if (AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers && msg_ctx_impl->msg_info_headers_deep_copy)
+    if (msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy)
     {
         AXIS2_MSG_INFO_HEADERS_FREE(
-            AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers, env);
-        AXIS2_INTF_TO_IMPL(msg_ctx)->msg_info_headers = NULL;
+            msg_ctx->msg_info_headers, env);
+        msg_ctx->msg_info_headers = NULL;
     }
-    msg_ctx_impl->msg_info_headers =
+    msg_ctx->msg_info_headers =
         AXIS2_OPTIONS_GET_MSG_INFO_HEADERS(options, env);
-    msg_ctx_impl->msg_info_headers_deep_copy = AXIS2_FALSE;
+    msg_ctx->msg_info_headers_deep_copy = AXIS2_FALSE;
 
-    AXIS2_CTX_SET_NON_PERSISTANT_MAP(msg_ctx_impl->base, env,
+    AXIS2_CTX_SET_NON_PERSISTANT_MAP(msg_ctx->base, env,
             AXIS2_OPTIONS_GET_PROPERTIES(options, env));
     rest_val = (axis2_property_t *) AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
             AXIS2_ENABLE_REST, AXIS2_FALSE);
@@ -2507,16 +1748,16 @@
 		}
     }
 
-    if (msg_ctx_impl->soap_action)
+    if (msg_ctx->soap_action)
     {
-        AXIS2_FREE(env->allocator, msg_ctx_impl->soap_action);
-        msg_ctx_impl->soap_action = NULL;
+        AXIS2_FREE(env->allocator, msg_ctx->soap_action);
+        msg_ctx->soap_action = NULL;
     }
     
     soap_action = AXIS2_OPTIONS_GET_SOAP_ACTION(options, env);
     if (AXIS2_OPTIONS_GET_SOAP_ACTION(options, env))
     {
-        msg_ctx_impl->soap_action = AXIS2_STRDUP(soap_action, env);
+        msg_ctx->soap_action = AXIS2_STRDUP(soap_action, env);
     }
 
     return AXIS2_SUCCESS;
@@ -2530,7 +1771,7 @@
     int flow)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->flow = flow;
+    msg_ctx->flow = flow;
     return AXIS2_SUCCESS;
 }
 
@@ -2540,7 +1781,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, -1);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->flow;
+    return msg_ctx->flow;
 }
 
 
@@ -2551,10 +1792,10 @@
     axis2_array_list_t *execution_chain)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->execution_chain = execution_chain;
-    AXIS2_INTF_TO_IMPL(msg_ctx)->current_handler_index = -1;
-    AXIS2_INTF_TO_IMPL(msg_ctx)->paused_handler_index = -1;
-    AXIS2_INTF_TO_IMPL(msg_ctx)->current_phase_index = 0;
+    msg_ctx->execution_chain = execution_chain;
+    msg_ctx->current_handler_index = -1;
+    msg_ctx->paused_handler_index = -1;
+    msg_ctx->current_phase_index = 0;
     return AXIS2_SUCCESS;
 }
 
@@ -2564,7 +1805,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->execution_chain;
+    return msg_ctx->execution_chain;
 }
 
 axis2_status_t AXIS2_CALL
@@ -2574,15 +1815,15 @@
     const int index)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->current_handler_index = index;
-    if (AXIS2_INTF_TO_IMPL(msg_ctx)->execution_chain)
+    msg_ctx->current_handler_index = index;
+    if (msg_ctx->execution_chain)
     {
         axis2_handler_t *handler = (axis2_handler_t *)
-                AXIS2_ARRAY_LIST_GET(AXIS2_INTF_TO_IMPL(msg_ctx)->execution_chain,
+                AXIS2_ARRAY_LIST_GET(msg_ctx->execution_chain,
                         env, index);
         if (handler)
         {
-            AXIS2_INTF_TO_IMPL(msg_ctx)->paused_handler_name =
+            msg_ctx->paused_handler_name =
                 (axis2_qname_t *)AXIS2_HANDLER_GET_QNAME(handler, env);
         }
     }
@@ -2594,11 +1835,8 @@
     const axis2_msg_ctx_t *msg_ctx,
     const axis2_env_t *env)
 {
-    axis2_msg_ctx_impl_t *msg_ctx_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    msg_ctx_impl = AXIS2_INTF_TO_IMPL(msg_ctx);
-    return msg_ctx_impl->current_handler_index;
+    return msg_ctx->current_handler_index;
 }
 
 int AXIS2_CALL
@@ -2606,7 +1844,7 @@
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->paused_handler_index;
+    return msg_ctx->paused_handler_index;
 }
 
 
@@ -2617,7 +1855,7 @@
     const int index)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(msg_ctx)->current_phase_index = index;
+    msg_ctx->current_phase_index = index;
     return AXIS2_SUCCESS;
 
 }
@@ -2628,7 +1866,7 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->current_phase_index;
+    return msg_ctx->current_phase_index;
 }
 
 int AXIS2_CALL
@@ -2637,5 +1875,21 @@
     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    return AXIS2_INTF_TO_IMPL(msg_ctx)->paused_phase_index;
+    return msg_ctx->paused_phase_index;
+}
+
+AXIS2_EXTERN axis2_svc_t * AXIS2_CALL
+axis2_msg_ctx_find_svc(axis2_msg_ctx_t *msg_ctx,
+    const axis2_env_t *env)
+{
+    return msg_ctx->find_svc(msg_ctx, env);
+}
+
+AXIS2_EXTERN axis2_op_t * AXIS2_CALL
+axis2_msg_ctx_find_op(axis2_msg_ctx_t *msg_ctx,
+    const axis2_env_t *env,
+    axis2_svc_t *svc)
+{
+    return msg_ctx->find_op(msg_ctx, env, svc);
 }
+

Modified: webservices/axis2/trunk/c/modules/core/engine/addr_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/addr_disp.c?view=diff&rev=494687&r1=494686&r2=494687
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/addr_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/addr_disp.c Tue Jan  9 18:11:15 2007
@@ -252,8 +252,8 @@
         
     }
 
-    msg_ctx->ops->find_svc = axis2_addr_disp_find_svc;
-    msg_ctx->ops->find_op = axis2_addr_disp_find_op;
+    axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_addr_disp_find_svc);
+    axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_addr_disp_find_op);
 
     return axis2_disp_invoke(handler, env, msg_ctx);
 }

Modified: webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c?view=diff&rev=494687&r1=494686&r2=494687
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c Tue Jan  9 18:11:15 2007
@@ -195,8 +195,8 @@
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx->ops->find_svc = axis2_req_uri_disp_find_svc;
-    msg_ctx->ops->find_op = axis2_req_uri_disp_find_op;
+    axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_req_uri_disp_find_svc);
+    axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_req_uri_disp_find_op);
 
     return axis2_disp_invoke(handler, env, msg_ctx);
 }

Modified: webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c?view=diff&rev=494687&r1=494686&r2=494687
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c Tue Jan  9 18:11:15 2007
@@ -151,8 +151,9 @@
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx->ops->find_svc = axiom_soap_action_disp_find_svc;
-    msg_ctx->ops->find_op = axiom_soap_action_disp_find_op;
+    axis2_msg_ctx_set_find_svc(msg_ctx, env, axiom_soap_action_disp_find_svc);
+    axis2_msg_ctx_set_find_op(msg_ctx, env, axiom_soap_action_disp_find_op);
 
     return axis2_disp_invoke(handler, env, msg_ctx);
 }
+

Modified: webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c?view=diff&rev=494687&r1=494686&r2=494687
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c Tue Jan  9 18:11:15 2007
@@ -227,8 +227,8 @@
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    msg_ctx->ops->find_svc = axiom_soap_body_disp_find_svc;
-    msg_ctx->ops->find_op = axiom_soap_body_disp_find_op;
+    axis2_msg_ctx_set_find_svc(msg_ctx, env, axiom_soap_body_disp_find_svc);
+    axis2_msg_ctx_set_find_op(msg_ctx, env, axiom_soap_body_disp_find_op);
 
     return axis2_disp_invoke(handler, env, msg_ctx);
 }



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message