axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r345817 - in /webservices/axis2/trunk/c/modules/core/description/src: flow.c flow_container.c module_desc.c operation.c param_container.c svc_grp.c
Date Mon, 21 Nov 2005 03:15:20 GMT
Author: damitha
Date: Sun Nov 20 19:15:08 2005
New Revision: 345817

URL: http://svn.apache.org/viewcvs?rev=345817&view=rev
Log:
operation is now almost complete. context related code has to be added

Modified:
    webservices/axis2/trunk/c/modules/core/description/src/flow.c
    webservices/axis2/trunk/c/modules/core/description/src/flow_container.c
    webservices/axis2/trunk/c/modules/core/description/src/module_desc.c
    webservices/axis2/trunk/c/modules/core/description/src/operation.c
    webservices/axis2/trunk/c/modules/core/description/src/param_container.c
    webservices/axis2/trunk/c/modules/core/description/src/svc_grp.c

Modified: webservices/axis2/trunk/c/modules/core/description/src/flow.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/src/flow.c?rev=345817&r1=345816&r2=345817&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/src/flow.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/src/flow.c Sun Nov 20 19:15:08 2005
@@ -20,7 +20,7 @@
  * @brief Flow struct impl
  *	Axis2 Flow impl  
  */
-typedef struct axis2_flow_impl_s
+typedef struct axis2_flow_impl
 {
 	axis2_flow_t flow;
     /**

Modified: webservices/axis2/trunk/c/modules/core/description/src/flow_container.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/src/flow_container.c?rev=345817&r1=345816&r2=345817&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/src/flow_container.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/src/flow_container.c Sun Nov 20 19:15:08 2005
@@ -20,7 +20,7 @@
  * @brief Flow container struct impl
  *	Container for flows  
  */ 
-typedef struct axis2_flow_container_impl_s
+typedef struct axis2_flow_container_impl
 {
 	axis2_flow_container_t flow_container;
     /**

Modified: webservices/axis2/trunk/c/modules/core/description/src/module_desc.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/src/module_desc.c?rev=345817&r1=345816&r2=345817&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/src/module_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/src/module_desc.c Sun Nov 20 19:15:08 2005
@@ -20,7 +20,7 @@
  * @brief Module Descripton struct impl
  *	Module Descripton 
  */ 
-typedef struct axis2_module_desc_impl_s
+typedef struct axis2_module_desc_impl
 {
 	axis2_module_desc_t module_desc;
     
@@ -28,10 +28,6 @@
     
     axis2_engine_config_t *parent;
     
-    axis2_flow_container_t *flow_container;
-    
-    axis2_param_container_t *params;
-    
     /** 
      * To store module opeartions , which are suppose to be added to a service 
      * if it is engaged to a service
@@ -48,6 +44,87 @@
 axis2_module_desc_free(axis2_module_desc_t *module_desc,
                             axis2_env_t **env);
 
+axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_in_flow(axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_in_flow(axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env,
+                                    axis2_flow_t *in_flow);
+
+axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_out_flow(axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_out_flow(axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env,
+                                    axis2_flow_t *out_flow);
+
+axis2_flow_t * AXIS2_CALL
+axis2_module_desc_get_fault_in_flow(axis2_module_desc_t *module_desc,
+                                        axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_fault_in_flow(axis2_module_desc_t *module_desc,
+                                        axis2_env_t **env,
+                                        axis2_flow_t *falut_in_flow);
+
+axis2_flow_t *AXIS2_CALL
+axis2_module_desc_get_fault_out_flow(axis2_module_desc_t *module_desc,
+                                            axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_fault_out_flow(axis2_module_desc_t *module_desc,
+                                            axis2_env_t **env,
+                                            axis2_flow_t *fault_out_flow);
+
+axis2_qname_t * AXIS2_CALL
+axis2_module_desc_get_name (axis2_module_desc_t *module_desc,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_name (axis2_module_desc_t *module_desc,
+                                axis2_env_t **env,
+                                axis2_qname_t *qname);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_add_operation (axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env,
+                                    axis2_operation_t *operation);
+
+axis2_hash_t * AXIS2_CALL
+axis2_module_desc_get_operations (axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env);
+
+axis2_engine_config_t * AXIS2_CALL
+axis2_module_desc_get_parent (axis2_module_desc_t *module_desc,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_parent (axis2_module_desc_t *module_desc,
+                                axis2_env_t **env,
+                                axis2_engine_config_t *parent);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_add_param(axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env,
+                                    axis2_param_t *param);
+
+axis2_param_t * AXIS2_CALL
+axis2_module_desc_get_param(axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env,
+                                    const axis2_char_t *name);
+
+axis2_array_list_t * AXIS2_CALL
+axis2_module_desc_get_params (axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env);
+
+axis2_bool_t AXIS2_CALL
+axis2_module_desc_is_param_locked (axis2_module_desc_t *module_desc,
+                                    axis2_env_t **env,
+                                    const axis2_char_t *param_name);
 
 /************************** End of function prototypes ************************/
 
@@ -63,17 +140,17 @@
 	if(NULL == module_desc_impl)
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL); 
     
-    module_desc_impl->params = axis2_param_container_create(env);
-    if(NULL == module_desc_impl->params)
+    module_desc_impl->module_desc.params = axis2_param_container_create(env);
+    if(NULL == module_desc_impl->module_desc.params)
     {
         AXIS2_FREE((*env)->allocator, module_desc_impl);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
     }
     
-    module_desc_impl->flow_container = axis2_flow_container_create(env);
-    if(NULL == module_desc_impl->flow_container)
+    module_desc_impl->module_desc.flow_container = axis2_flow_container_create(env);
+    if(NULL == module_desc_impl->module_desc.flow_container)
     {
-        AXIS2_PARAM_CONTAINER_FREE(module_desc_impl->params, env);
+        AXIS2_PARAM_CONTAINER_FREE(module_desc_impl->module_desc.params, env);
         AXIS2_FREE((*env)->allocator, module_desc_impl);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
     }
@@ -81,8 +158,8 @@
     module_desc_impl->operations = axis2_hash_make(env);
     if(NULL == module_desc_impl->operations)
     {
-        AXIS2_PARAM_CONTAINER_FREE(module_desc_impl->params, env);
-        AXIS2_FLOW_CONTAINER_FREE(module_desc_impl->flow_container, env); 
+        AXIS2_PARAM_CONTAINER_FREE(module_desc_impl->module_desc.params, env);
+        AXIS2_FLOW_CONTAINER_FREE(module_desc_impl->module_desc.flow_container, env); 
         AXIS2_FREE((*env)->allocator, module_desc_impl);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);        
     }
@@ -91,14 +168,48 @@
 		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_module_desc_ops_t));
 	if(NULL == module_desc_impl->module_desc.ops)
     {
-        AXIS2_PARAM_CONTAINER_FREE(module_desc_impl->params, env);
-        AXIS2_FLOW_CONTAINER_FREE(module_desc_impl->flow_container, env);
+        AXIS2_PARAM_CONTAINER_FREE(module_desc_impl->module_desc.params, env);
+        AXIS2_FLOW_CONTAINER_FREE(module_desc_impl->module_desc.flow_container, env);
         axis2_hash_free(module_desc_impl->operations, env);
         AXIS2_FREE((*env)->allocator, module_desc_impl);
 		AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
     }
     
-	/*module_desc_impl->module_desc.ops->free =  axis2_module_desc_free;*/
+	module_desc_impl->module_desc.ops->free = axis2_module_desc_free;
+    module_desc_impl->module_desc.ops->get_in_flow = axis2_module_desc_get_in_flow;
+    module_desc_impl->module_desc.ops->set_in_flow = axis2_module_desc_set_in_flow;
+    module_desc_impl->module_desc.ops->get_out_flow = axis2_module_desc_get_out_flow;
+    module_desc_impl->module_desc.ops->set_out_flow = axis2_module_desc_set_out_flow;
+    
+    module_desc_impl->module_desc.ops->get_fault_in_flow = 
+        axis2_module_desc_get_fault_in_flow;
+    
+    module_desc_impl->module_desc.ops->set_fault_in_flow = 
+        axis2_module_desc_set_fault_in_flow;
+    
+    module_desc_impl->module_desc.ops->get_fault_out_flow = 
+        axis2_module_desc_get_fault_out_flow;
+    
+    module_desc_impl->module_desc.ops->set_fault_out_flow = 
+        axis2_module_desc_set_fault_out_flow;
+    
+    module_desc_impl->module_desc.ops->get_name = axis2_module_desc_get_name;
+    module_desc_impl->module_desc.ops->set_name = axis2_module_desc_set_name;
+    
+    module_desc_impl->module_desc.ops->add_operation = 
+        axis2_module_desc_add_operation;
+    
+    module_desc_impl->module_desc.ops->get_operations = 
+        axis2_module_desc_get_operations;
+    
+    module_desc_impl->module_desc.ops->get_parent = axis2_module_desc_get_parent;
+    module_desc_impl->module_desc.ops->set_parent = axis2_module_desc_set_parent;
+    module_desc_impl->module_desc.ops->add_param = axis2_module_desc_add_param;
+    module_desc_impl->module_desc.ops->get_param = axis2_module_desc_get_param;
+    module_desc_impl->module_desc.ops->get_params = axis2_module_desc_get_params;
+    
+    module_desc_impl->module_desc.ops->is_param_locked = 
+        axis2_module_desc_is_param_locked;
 	
     module_desc_impl->qname = NULL;
 
@@ -135,11 +246,11 @@
     if(NULL != module_desc->ops)
         AXIS2_FREE((*env)->allocator, module_desc->ops);
     
-    if(NULL == AXIS2_INTF_TO_IMPL(module_desc)->params)
-        AXIS2_PARAM_CONTAINER_FREE(AXIS2_INTF_TO_IMPL(module_desc)->params, env);
+    if(NULL == module_desc->params)
+        AXIS2_PARAM_CONTAINER_FREE(module_desc->params, env);
     
-    if(NULL == AXIS2_INTF_TO_IMPL(module_desc)->flow_container)
-        AXIS2_FLOW_CONTAINER_FREE(AXIS2_INTF_TO_IMPL(module_desc)->flow_container, env);
+    if(NULL == module_desc->flow_container)
+        AXIS2_FLOW_CONTAINER_FREE(module_desc->flow_container, env);
     
     if(NULL != AXIS2_INTF_TO_IMPL(module_desc)->parent)
         AXIS2_ENGINE_CONFIG_FREE(AXIS2_INTF_TO_IMPL(module_desc)->parent, env);
@@ -154,25 +265,16 @@
     
     return AXIS2_SUCCESS;
 }
-    
-/**
- * Get fault out flow
- * @return in flow
- */
+
 axis2_flow_t *AXIS2_CALL
 axis2_module_desc_get_in_flow(axis2_module_desc_t *module_desc,
                                     axis2_env_t **env)
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
     
-    return AXIS2_FLOW_CONTAINER_GET_IN_FLOW(AXIS2_INTF_TO_IMPL(module_desc)-> \
-        flow_container, env);
+    return AXIS2_FLOW_CONTAINER_GET_IN_FLOW(module_desc->flow_container, env);
 }
 
-/**
- * Set in flow
- * @param in_flow in flow
- */
 axis2_status_t AXIS2_CALL
 axis2_module_desc_set_in_flow(axis2_module_desc_t *module_desc,
                                     axis2_env_t **env,
@@ -181,28 +283,19 @@
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, in_flow, AXIS2_FAILURE);
     
-    return AXIS2_FLOW_CONTAINER_SET_IN_FLOW(AXIS2_INTF_TO_IMPL(module_desc)-> \
-        flow_container, env, in_flow);    
+    return AXIS2_FLOW_CONTAINER_SET_IN_FLOW(module_desc->flow_container, env, 
+        in_flow);    
 }
 
-/**
- * Get out flow
- * @return out flow
- */
 axis2_flow_t *AXIS2_CALL
 axis2_module_desc_get_out_flow(axis2_module_desc_t *module_desc,
                                     axis2_env_t **env)
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
     
-    return AXIS2_FLOW_CONTAINER_GET_OUT_FLOW(AXIS2_INTF_TO_IMPL(module_desc)-> \
-        flow_container, env);
+    return AXIS2_FLOW_CONTAINER_GET_OUT_FLOW(module_desc->flow_container, env);
 }
 
-/**
- * Set out flow
- * @param out_flow out flow
- */
 axis2_status_t AXIS2_CALL
 axis2_module_desc_set_out_flow(axis2_module_desc_t *module_desc,
                                     axis2_env_t **env,
@@ -211,28 +304,19 @@
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, out_flow, AXIS2_FAILURE);
     
-    return AXIS2_FLOW_CONTAINER_SET_OUT_FLOW(AXIS2_INTF_TO_IMPL(module_desc)-> \
-        flow_container, env, out_flow);
+    return AXIS2_FLOW_CONTAINER_SET_OUT_FLOW(module_desc->flow_container, env, 
+        out_flow);
 }
 
-/**
- * Get fault in flow
- * @return fault in flow
- */
 axis2_flow_t * AXIS2_CALL
 axis2_module_desc_get_fault_in_flow(axis2_module_desc_t *module_desc,
                                         axis2_env_t **env)
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
     
-    return AXIS2_FLOW_CONTAINER_GET_FAULT_IN_FLOW(
-        AXIS2_INTF_TO_IMPL(module_desc)->flow_container, env);
+    return AXIS2_FLOW_CONTAINER_GET_FAULT_IN_FLOW(module_desc->flow_container, env);
 }
 
-/**
- * set fault in flow
- * @param falut_in_flow falut in flow
- */
 axis2_status_t AXIS2_CALL
 axis2_module_desc_set_fault_in_flow(axis2_module_desc_t *module_desc,
                                         axis2_env_t **env,
@@ -241,27 +325,18 @@
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, falut_in_flow, AXIS2_FAILURE);
     
-    return AXIS2_FLOW_CONTAINER_SET_FAULT_IN_FLOW(AXIS2_INTF_TO_IMPL(
-        module_desc)->flow_container,env, falut_in_flow);
+    return AXIS2_FLOW_CONTAINER_SET_FAULT_IN_FLOW(module_desc->flow_container,
+        env, falut_in_flow);
 }
 
-/**
- * Get fault out flow
- * @return fault out flow
- */
 axis2_flow_t *AXIS2_CALL
 axis2_module_desc_get_fault_out_flow(axis2_module_desc_t *module_desc,
                                             axis2_env_t **env)
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
-    return AXIS2_FLOW_CONTAINER_GET_FAULT_OUT_FLOW(AXIS2_INTF_TO_IMPL(
-        module_desc)->flow_container, env);
+    return AXIS2_FLOW_CONTAINER_GET_FAULT_OUT_FLOW(module_desc->flow_container, env);
 }
 
-/**
- * Set fault out flow
- * @param fault_out_flow fault out flow
- */
 axis2_status_t AXIS2_CALL
 axis2_module_desc_set_fault_out_flow(axis2_module_desc_t *module_desc,
                                             axis2_env_t **env,
@@ -270,13 +345,10 @@
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, fault_out_flow, AXIS2_FAILURE);
     
-    return AXIS2_FLOW_CONTAINER_SET_FAULT_OUT_FLOW(AXIS2_INTF_TO_IMPL(
-        module_desc)->flow_container, env, fault_out_flow);
+    return AXIS2_FLOW_CONTAINER_SET_FAULT_OUT_FLOW(module_desc->flow_container, 
+        env, fault_out_flow);
 }
 
-/**
- * @return
- */
 axis2_qname_t * AXIS2_CALL
 axis2_module_desc_get_name (axis2_module_desc_t *module_desc,
                                 axis2_env_t **env)
@@ -286,9 +358,6 @@
     return AXIS2_INTF_TO_IMPL(module_desc)->qname;
 }
 
-/**
- * @param name
- */
 axis2_status_t AXIS2_CALL
 axis2_module_desc_set_name (axis2_module_desc_t *module_desc,
                                 axis2_env_t **env,
@@ -326,7 +395,7 @@
                                     axis2_env_t **env)
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
-    return AXIS2_INTF_TO_IMPL(module_desc)->opeartions;
+    return AXIS2_INTF_TO_IMPL(module_desc)->operations;
 }
 
 axis2_engine_config_t * AXIS2_CALL
@@ -340,44 +409,39 @@
 axis2_status_t AXIS2_CALL
 axis2_module_desc_set_parent (axis2_module_desc_t *module_desc,
                                 axis2_env_t **env,
-                                axis2_engine_config_t **parent)
+                                axis2_engine_config_t *parent)
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, parent, AXIS2_FAILURE);
     AXIS2_INTF_TO_IMPL(module_desc)->parent = parent;
+    return AXIS2_SUCCESS;
 }
 
-/**
- * Add parameter
- * @param param
- */
 axis2_status_t AXIS2_CALL
-axis2_module_desc_add_param(module_desc_t *module_desc,
+axis2_module_desc_add_param(axis2_module_desc_t *module_desc,
                                     axis2_env_t **env,
                                     axis2_param_t *param)
 {
+    axis2_char_t *param_name_l = NULL;
+    axis2_status_t ret_status = AXIS2_FAILURE;
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
     
-    axis2_char_t *param_name = AXIS2_PARAM_GET_NAME(param, env);
-    if(NULL == param_name)
-        AXIS2_SET_ERROR((*env)->error, AXIS2_ERROR_INVALID_STATE_PARAM, 
+    param_name_l = AXIS2_PARAM_GET_NAME(param, env);
+    if(NULL == param_name_l)
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_PARAM, 
             AXIS2_FAILURE);
-    if(axis2_module_desc_is_param_locked(module_desc, env, param_name)
+    if(AXIS2_TRUE == axis2_module_desc_is_param_locked(module_desc, env, param_name_l))
     {
-        AXIS2_SET_ERROR((*env)->error, 
+        AXIS2_ERROR_SET((*env)->error, 
             AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
     }
     else
     {        
-        AXIS2_PARAM_CONTAINER_ADD_PARAM(AXIS2_INTF_TO_IMPL(module_desc)->
-            param_container, env, param);
-    }    
+        ret_status = AXIS2_PARAM_CONTAINER_ADD_PARAM(module_desc->params, env, param);
+    } 
+    return ret_status;    
 }
 
-/**
- * @param name
- * @return parameter
- */
 axis2_param_t * AXIS2_CALL
 axis2_module_desc_get_param(axis2_module_desc_t *module_desc,
                                     axis2_env_t **env,
@@ -386,8 +450,7 @@
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
     AXIS2_PARAM_CHECK((*env)->error, name, NULL);
     
-    return AXIS2_PARAM_CONTAINER_GET_PARAM(AXIS2_INTF_TO_IMPL(module_desc)->
-        param_container, env, name)
+    return AXIS2_PARAM_CONTAINER_GET_PARAM(module_desc->params, env, name);
 }
 
 axis2_array_list_t * AXIS2_CALL
@@ -396,45 +459,40 @@
 {
     AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
     
-    return AXIS2_PARAM_CONTAINER_GET_PARAMS(AXIS2_INTF_TO_IMPL(module_desc)->
-        params, env);
+    return AXIS2_PARAM_CONTAINER_GET_PARAMS(module_desc->params, env);
 }
 
-/**
- * To check whether a given paramter is locked
- * @param param_name
- * @return whether parameter is locked
- */
 axis2_bool_t AXIS2_CALL
-axis2_module_desc_is_param_locked (axis2_module_desc_t module_desc,
+axis2_module_desc_is_param_locked (axis2_module_desc_t *module_desc,
                                     axis2_env_t **env,
                                     const axis2_char_t *param_name)
 {
-    AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FALSE);
     axis2_bool_t locked = AXIS2_FALSE;
+    axis2_bool_t ret_state = AXIS2_FALSE;
+    axis2_param_t *param_l = NULL;
+    AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FALSE);
+    
     
     AXIS2_PARAM_CHECK((*env)->error, param_name, AXIS2_FALSE);
-    axis2_char_t *param_name_l = AXIS2_STRDUP(param_name, env);
-    if(NULL == param_name_l)
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FALSE);
     
     /* checking the locked value of parent*/
     if(NULL != AXIS2_INTF_TO_IMPL(module_desc)->parent)
         locked = AXIS2_ENGINE_CONFIG_IS_PARAM_LOCKED(AXIS2_INTF_TO_IMPL(
-                    module_desc)->parent, env, param_name_l);
+                    module_desc)->parent, env, param_name);
     
     if(AXIS2_TRUE == locked)
     {
-        return AXIS2_TRUE;
+        ret_state = AXIS2_TRUE;
     }
     else
     {
-        axis2_parem_t param_l = axis2_module_desc_get_param(module_desc, env, 
-            param_name_l);
-        if(NULL != param && AXIS2_TRUE == AXIS2_PARAM_IS_LOCKED)
-            return AXIS2_TRUE;
+        param_l = axis2_module_desc_get_param(module_desc, env, 
+            param_name);
+        if(NULL != param_l && AXIS2_TRUE == AXIS2_PARAM_IS_LOCKED(param_l, env))
+            ret_state = AXIS2_TRUE;
         else
-            return AXIS2_FALSE;
+            ret_state = AXIS2_FALSE;
         
-    }        
+    }  
+    return ret_state;    
 }

Modified: webservices/axis2/trunk/c/modules/core/description/src/operation.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/src/operation.c?rev=345817&r1=345816&r2=345817&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/src/operation.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/src/operation.c Sun Nov 20 19:15:08 2005
@@ -20,13 +20,21 @@
  * @brief Operaton struct impl
  *	Axis2 Operations  
  */ 
-typedef struct axis2_operation_impl_s
+typedef struct axis2_operation_impl
 {
 	axis2_operation_t operation;
-	axis2_param_container_t *param_container;
-    axis2_wsdl_operation_t *wsdl_operation;
+    
 	struct axis2_svc *parent;
-	axis2_msg_recv_t *msg_recv;
+	struct axis2_msg_recv *msg_recv;
+        
+    axis2_array_list_t *remaining_phases_in_flow;
+    axis2_array_list_t *phases_out_flow;
+    axis2_array_list_t *phases_in_fault_flow;
+    axis2_array_list_t *phases_out_fault_flow;
+    int mep;
+    /*To store deploytime module refs */
+    axis2_array_list_t *modulerefs;
+    
 } axis2_operation_impl_t;
 
 #define AXIS2_INTF_TO_IMPL(operation) ((axis2_operation_impl_t *)operation)
@@ -68,9 +76,9 @@
 axis2_status_t AXIS2_CALL
 axis2_operation_set_msg_recv (axis2_operation_t *operation, 
                                 axis2_env_t **env,
-                                axis2_msg_recv_t *msg_recv);
+                                struct axis2_msg_recv *msg_recv);
 
-axis2_msg_recv_t * AXIS2_CALL
+struct axis2_msg_recv * AXIS2_CALL
 axis2_operation_get_msg_recv (axis2_operation_t *operation, 
                                 axis2_env_t **env);
 
@@ -92,40 +100,173 @@
 axis2_operation_get_msg_exchange_pattern (axis2_operation_t *operation, 
                                             axis2_env_t **env);
 
-axis2_hash_t * AXIS2_CALL
-axis2_operation_get_component_properties(axis2_operation_t *operation,
+axis2_char_t * AXIS2_CALL
+axis2_operation_get_style (axis2_operation_t *operation,
+                            axis2_env_t **env);
+
+axis2_status_t  AXIS2_CALL
+axis2_operation_set_style (axis2_operation_t *operation,
+                            axis2_env_t **env,
+                            axis2_char_t *style);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_engage_module(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_module_desc_t *moduleref);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_to_engage_module_list(axis2_operation_t *operation,
+                                            axis2_env_t **env,
+                                            axis2_module_desc_t *module_name);
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_modules(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+int AXIS2_CALL
+axis2_operation_get_axis_specific_MEP_constant(axis2_operation_t *operation,
+                                                axis2_env_t **env);
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_phases_in_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env);
+
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_phases_out_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env);
+
+axis2_array_list_t * AXIS2_CALL
+axis2_operation_get_phases_out_flow(axis2_operation_t *operation,
                                         axis2_env_t **env);
 
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_remaining_phases_in_flow(axis2_operation_t *operation,
+                                                axis2_env_t **env);
+
 axis2_status_t AXIS2_CALL
-axis2_operation_set_component_properties(axis2_operation_t *operation,
-                                        axis2_env_t **env,
-                                        axis2_hash_t *properties);
+axis2_operation_set_phases_in_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env,
+                                            axis2_array_list_t *list);
 
-axis2_wsdl_component_t * AXIS2_CALL
-axis2_operation_get_component_property(axis2_operation_t *operation,
-                                        axis2_env_t **env,
-                                        const axis2_char_t *key);
+axis2_status_t AXIS2_CALL
+axis2_operation_set_phases_out_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env,
+                                            axis2_array_list_t *list);
 
 axis2_status_t AXIS2_CALL
-axis2_operation_set_component_property (axis2_operation_t *operation,
+axis2_operation_set_phases_out_flow(axis2_operation_t *operation,
                                         axis2_env_t **env,
-                                        const void *key,
-                                        void *value);
+                                        axis2_array_list_t *list);
 
-axis2_char_t * AXIS2_CALL
-axis2_operation_get_style (axis2_operation_t *operation,
-                            axis2_env_t **env);
+axis2_status_t AXIS2_CALL
+axis2_operation_set_remaining_phases_in_flow(axis2_operation_t *operation,
+                                                axis2_env_t **env,
+                                                axis2_array_list_t *list);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_module(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_qname_t *module_name);
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_module_refs(axis2_operation_t *operation,
+                                    axis2_env_t **env);
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_infaults(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_infaults(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_linked_list_t *infaults);
+
+struct axis2_wsdl_msg_ref *AXIS2_CALL
+axis2_operation_get_input_msg(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_input_msg(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                struct axis2_wsdl_msg_ref *input_msg); 
+
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_outfaults(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_outfaults(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_linked_list_t *outfaults);
+
+struct axis2_wsdl_msg_ref *AXIS2_CALL
+axis2_operation_get_output_msg(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_output_msg(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                struct axis2_wsdl_msg_ref *output_msg); 
+
+
+axis2_bool_t AXIS2_CALL
+axis2_operation_is_safe(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_safety(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_bool_t safe);
+
+axis2_char_t *AXIS2_CALL
+axis2_operation_get_target_namespace(axis2_operation_t *operation,
+                                        axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_infault(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_fault_ref_t *infault);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_outfault(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_fault_ref_t *outfault);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_feature(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_feature_t *feature);
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_features(axis2_operation_t *operation,
+                                axis2_env_t **env); 
 
-axis2_status_t  AXIS2_CALL
-axis2_operation_set_style (axis2_operation_t *operation,
-                            axis2_env_t **env,
-                            axis2_char_t *style);
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_property(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_property_t *wsdl_property);
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_Properties(axis2_operation_t *operation,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL 
+axis2_operation_set_wsdl_opeartion(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_operation_t *wsdl_operation);
 
 /************************* End of function headers ****************************/	
 
 axis2_operation_t * AXIS2_CALL
 axis2_operation_create (axis2_env_t **env)
 {
+    struct axis2_param_container *param_container_l = NULL;
+    axis2_array_list_t *array_list_l = NULL;
+    
     AXIS2_ENV_CHECK(env, NULL);
 	axis2_operation_impl_t *operation_impl = 
 		(axis2_operation_impl_t *) AXIS2_MALLOC ((*env)->allocator,
@@ -136,32 +277,49 @@
 		AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
 	}
     
-    operation_impl->param_container = (axis2_param_container_t *)
+    operation_impl->operation.param_container = (axis2_param_container_t *)
 		axis2_param_container_create(env);		
-	if(NULL == operation_impl->param_container)
+	if(NULL == operation_impl->operation.param_container)
 	{
         AXIS2_FREE((*env)->allocator, operation_impl);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);		
 	}
 
-	operation_impl->wsdl_operation = (axis2_wsdl_operation_t *)
+	operation_impl->operation.wsdl_operation = (axis2_wsdl_operation_t *)
 		axis2_wsdl_operation_create(env);		
-	if(NULL == operation_impl->wsdl_operation)
+	if(NULL == operation_impl->operation.wsdl_operation)
 	{
-        AXIS2_PARAM_CONTAINER_FREE(operation_impl->param_container, env);
+        AXIS2_PARAM_CONTAINER_FREE(operation_impl->operation.param_container, env);
         AXIS2_FREE((*env)->allocator, operation_impl);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);		
 	}
 
-    AXIS2_WSDL_OPERATION_SET_MSG_EXCHANGE_PATTERN(operation_impl->wsdl_operation,
-        env, MEP_URI_IN_OUT);    
+    operation_impl->remaining_phases_in_flow = axis2_array_list_create(env, 0);
+    if(NULL == operation_impl->remaining_phases_in_flow)
+        axis2_operation_free(&(operation_impl->operation), env);
+    
+    operation_impl->phases_out_flow = axis2_array_list_create(env, 0);
+    if(NULL == operation_impl->phases_out_flow)
+        axis2_operation_free(&(operation_impl->operation), env);
+    
+    operation_impl->phases_in_fault_flow = axis2_array_list_create(env, 0);
+    if(NULL == operation_impl->phases_in_fault_flow)
+        axis2_operation_free(&(operation_impl->operation), env);
+    
+    operation_impl->modulerefs = axis2_array_list_create(env, 0);
+    if(NULL == operation_impl->modulerefs)
+        axis2_operation_free(&(operation_impl->operation), env);
+    
+    operation_impl->phases_out_fault_flow = axis2_array_list_create(env, 0);
+    if(NULL == operation_impl->phases_out_fault_flow)
+        axis2_operation_free(&(operation_impl->operation), env);
     
     operation_impl->operation.ops = AXIS2_MALLOC((*env)->allocator, 
         sizeof(axis2_operation_ops_t));
 	if(NULL == operation_impl->operation.ops)
 	{
-        AXIS2_PARAM_CONTAINER_FREE(operation_impl->param_container, env);
-        AXIS2_WSDL_OPERATION_FREE(operation_impl->wsdl_operation, env);
+        AXIS2_PARAM_CONTAINER_FREE(operation_impl->operation.param_container, env);
+        AXIS2_WSDL_OPERATION_FREE(operation_impl->operation.wsdl_operation, env);
         AXIS2_FREE((*env)->allocator, operation_impl);
 		AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
 	}
@@ -184,26 +342,64 @@
     
 	operation_impl->operation.ops->get_msg_exchange_pattern
 		= axis2_operation_get_msg_exchange_pattern;
-    
-    operation_impl->operation.ops->get_component_properties = 
-        axis2_operation_get_component_properties;
-        
-    operation_impl->operation.ops->set_component_properties = 
-        axis2_operation_set_component_properties;
-        
-    operation_impl->operation.ops->get_component_property = 
-        axis2_operation_get_component_property;
-        
-    operation_impl->operation.ops->set_component_property = 
-        axis2_operation_set_component_property;
         
     operation_impl->operation.ops->set_style = axis2_operation_set_style;
     
 	operation_impl->operation.ops->get_style = axis2_operation_get_style; 
-	
+
+    operation_impl->operation.ops->engage_module = axis2_operation_engage_module;
+    operation_impl->operation.ops->add_to_engage_module_list = axis2_operation_add_to_engage_module_list;
+    operation_impl->operation.ops->get_modules = axis2_operation_get_modules;
+    operation_impl->operation.ops->get_axis_specific_MEP_constant = axis2_operation_get_axis_specific_MEP_constant;
+    operation_impl->operation.ops->get_phases_in_fault_flow = axis2_operation_get_phases_in_fault_flow;
+    operation_impl->operation.ops->get_phases_out_fault_flow = axis2_operation_get_phases_out_fault_flow;
+    operation_impl->operation.ops->get_phases_out_flow = axis2_operation_get_phases_out_flow;
+    operation_impl->operation.ops->get_remaining_phases_in_flow = axis2_operation_get_remaining_phases_in_flow;
+    operation_impl->operation.ops->set_phases_in_fault_flow = axis2_operation_set_phases_in_fault_flow;
+    operation_impl->operation.ops->set_phases_out_fault_flow = axis2_operation_set_phases_out_fault_flow;
+    operation_impl->operation.ops->set_phases_out_flow = axis2_operation_set_phases_out_flow;
+    operation_impl->operation.ops->set_remaining_phases_in_flow = axis2_operation_set_remaining_phases_in_flow;
+    operation_impl->operation.ops->add_module = axis2_operation_add_module;
+    operation_impl->operation.ops->get_module_refs = axis2_operation_get_module_refs;
+    operation_impl->operation.ops->get_infaults = axis2_operation_get_infaults;
+    operation_impl->operation.ops->set_infaults = axis2_operation_set_infaults;
+    operation_impl->operation.ops->get_input_msg = axis2_operation_get_input_msg;
+    operation_impl->operation.ops->set_input_msg = axis2_operation_set_input_msg;
+    operation_impl->operation.ops->get_outfaults = axis2_operation_get_outfaults;
+    operation_impl->operation.ops->set_outfaults = axis2_operation_set_outfaults;
+    operation_impl->operation.ops->get_output_msg = axis2_operation_get_output_msg;
+    operation_impl->operation.ops->set_output_msg = axis2_operation_set_output_msg;
+    operation_impl->operation.ops->is_safe = axis2_operation_is_safe;
+    operation_impl->operation.ops->set_safety = axis2_operation_set_safety;
+    operation_impl->operation.ops->get_target_namespace = axis2_operation_get_target_namespace;
+    operation_impl->operation.ops->add_infault = axis2_operation_add_infault;
+    operation_impl->operation.ops->add_outfault = axis2_operation_add_outfault;
+    operation_impl->operation.ops->add_feature = axis2_operation_add_feature;
+    operation_impl->operation.ops->get_features = axis2_operation_get_features;
+    operation_impl->operation.ops->add_property = axis2_operation_add_property;
+    operation_impl->operation.ops->get_Properties = axis2_operation_get_Properties;
+    operation_impl->operation.ops->set_wsdl_opeartion = axis2_operation_set_wsdl_opeartion;
+
+
 	operation_impl->parent = NULL;
 	
 	operation_impl->msg_recv = NULL;
+    
+    operation_impl->mep = MEP_CONSTANT_INVALID;
+    
+    axis2_operation_set_msg_exchange_pattern(&(operation_impl->operation), env, 
+        (axis2_char_t *) AXIS2_STRDUP(MEP_URI_IN_OUT, env));
+    
+    param_container_l = axis2_param_container_create(env);
+    if(NULL == param_container_l)
+        return NULL;
+    AXIS2_WSDL_COMPONENT_SET_COMPONENT_PROPERTY(operation_impl->operation.wsdl_operation->
+        extensible_component->wsdl_component, env, PARAMETER_KEY, param_container_l);
+    
+    array_list_l = axis2_array_list_create(env, 0);
+    if(NULL == array_list_l) return NULL;
+    AXIS2_WSDL_COMPONENT_SET_COMPONENT_PROPERTY(operation_impl->operation.wsdl_operation->
+        extensible_component->wsdl_component, env, MODULEREF_KEY, array_list_l);
 						
 	return &(operation_impl->operation);
 }
@@ -238,8 +434,9 @@
 	}
     
     AXIS2_PARAM_CHECK((*env)->error, wsdl_operation, NULL);	
-	
-    operation_impl->wsdl_operation = wsdl_operation;
+	if(NULL != operation_impl->operation.wsdl_operation)
+        AXIS2_WSDL_OPERATION_FREE(operation_impl->operation.wsdl_operation, env);
+    operation_impl->operation.wsdl_operation = wsdl_operation;
        
 	return &(operation_impl->operation);	
 }
@@ -254,12 +451,12 @@
 	if(NULL != operation->ops)
 		AXIS2_FREE((*env)->allocator, operation->ops);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(operation)->param_container)
-	    AXIS2_PARAM_CONTAINER_FREE(AXIS2_INTF_TO_IMPL(operation)->param_container
+    if(NULL != operation->param_container)
+	    AXIS2_PARAM_CONTAINER_FREE(operation->param_container
         , env);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(operation)->wsdl_operation)
-	    AXIS2_WSDL_OPERATION_FREE(AXIS2_INTF_TO_IMPL(operation)->wsdl_operation
+    if(NULL != operation->wsdl_operation)
+	    AXIS2_WSDL_OPERATION_FREE(operation->wsdl_operation
         , env);
     
     if(NULL != AXIS2_INTF_TO_IMPL(operation)->parent)
@@ -267,6 +464,25 @@
     
     if(NULL != AXIS2_INTF_TO_IMPL(operation)->msg_recv)
 	    AXIS2_MSG_RECV_FREE(AXIS2_INTF_TO_IMPL(operation)->msg_recv, env);
+    
+    if(NULL != AXIS2_INTF_TO_IMPL(operation)->remaining_phases_in_flow)
+        AXIS2_ARRAY_LIST_FREE(AXIS2_INTF_TO_IMPL(operation)->remaining_phases_in_flow,
+            env);
+    
+    if(NULL != AXIS2_INTF_TO_IMPL(operation)->phases_out_flow)
+        AXIS2_ARRAY_LIST_FREE(AXIS2_INTF_TO_IMPL(operation)->phases_out_flow,
+            env);
+    
+    if(NULL != AXIS2_INTF_TO_IMPL(operation)->phases_in_fault_flow)
+        AXIS2_ARRAY_LIST_FREE(AXIS2_INTF_TO_IMPL(operation)->phases_in_fault_flow,
+            env);
+    
+    if(NULL != AXIS2_INTF_TO_IMPL(operation)->phases_out_fault_flow)
+        AXIS2_ARRAY_LIST_FREE(AXIS2_INTF_TO_IMPL(operation)->phases_out_fault_flow,
+            env);
+    
+    if(NULL != AXIS2_INTF_TO_IMPL(operation)->modulerefs)
+        AXIS2_ARRAY_LIST_FREE(AXIS2_INTF_TO_IMPL(operation)->modulerefs, env);
         
     AXIS2_FREE((*env)->allocator, AXIS2_INTF_TO_IMPL(operation));
     
@@ -291,7 +507,8 @@
     else
     {
         param_container_l = (axis2_param_container_t *) 
-            axis2_operation_get_component_property(operation, env, 
+            AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(
+                operation->wsdl_operation->extensible_component->wsdl_component, env, 
                 (axis2_char_t *) PARAMETER_KEY);
         return AXIS2_PARAM_CONTAINER_ADD_PARAM(param_container_l, env, param);
     }
@@ -307,12 +524,10 @@
     axis2_param_container_t *param_container_l = NULL;
 	AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FALSE);
 	AXIS2_PARAM_CHECK((*env)->error, param_name, NULL);
-    if(AXIS2_INTF_TO_IMPL(operation)->param_container)
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_OPERATION, NULL);
 	
     param_container_l = (axis2_param_container_t *) 
-        axis2_operation_get_component_property(operation, env, (axis2_char_t *) 
-            PARAMETER_KEY);
+        AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(operation->wsdl_operation->
+            extensible_component->wsdl_component, env, (axis2_char_t *) PARAMETER_KEY);
 	
 	return AXIS2_PARAM_CONTAINER_GET_PARAM(param_container_l, env, param_name);
 }
@@ -323,12 +538,12 @@
 {
     axis2_param_container_t *param_container_l = NULL;
 	AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FALSE);
-    AXIS2_PARAM_CHECK((*env)->error, AXIS2_INTF_TO_IMPL(operation)->param_container, 
+    AXIS2_PARAM_CHECK((*env)->error, operation->param_container, 
         AXIS2_FALSE);
 	
     param_container_l = (axis2_param_container_t *) 
-        axis2_operation_get_component_property(operation, env, (axis2_char_t *) 
-            PARAMETER_KEY);
+        AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(operation->wsdl_operation->
+            extensible_component->wsdl_component, env, (axis2_char_t *) PARAMETER_KEY);
 	return AXIS2_PARAM_CONTAINER_GET_PARAMS(param_container_l, env);
 }
 
@@ -340,7 +555,7 @@
     axis2_svc_t *parent_l = NULL;
     axis2_param_t *param_l = NULL;
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FALSE);
-    if(AXIS2_INTF_TO_IMPL(operation)->param_container)
+    if(operation->param_container)
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_OPERATION, 
             AXIS2_FALSE);
 	
@@ -371,7 +586,10 @@
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, svc, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(operation)->parent = svc;
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    if(operation_impl->parent)
+        AXIS2_SVC_FREE(operation_impl->parent, env);
+    operation_impl->parent = svc;
 	return AXIS2_SUCCESS;
 }
 
@@ -386,16 +604,20 @@
 axis2_status_t AXIS2_CALL 
 axis2_operation_set_msg_recv (axis2_operation_t *operation, 
                                 axis2_env_t **env,
-		                        axis2_msg_recv_t *msg_recv)
+		                        struct axis2_msg_recv *msg_recv)
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, msg_recv, AXIS2_FAILURE);
-	AXIS2_INTF_TO_IMPL(operation)->msg_recv = msg_recv;
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    if(operation_impl->msg_recv)
+        AXIS2_MSG_RECV_FREE(operation_impl->msg_recv, env);
+    
+	operation_impl->msg_recv = msg_recv;
 	
 	return AXIS2_SUCCESS;
 }
 
-axis2_msg_recv_t * AXIS2_CALL
+struct axis2_msg_recv * AXIS2_CALL
 axis2_operation_get_msg_recv (axis2_operation_t *operation, 
                                 axis2_env_t **env)
 {
@@ -410,8 +632,7 @@
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
 	
-    return AXIS2_WSDL_OPERATION_SET_NAME(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env, qname);
+    return AXIS2_WSDL_OPERATION_SET_NAME(operation->wsdl_operation, env, qname);
 }
     
 axis2_qname_t * AXIS2_CALL
@@ -420,7 +641,7 @@
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
 	
-    return AXIS2_WSDL_OPERATION_GET_NAME(AXIS2_INTF_TO_IMPL(operation)->wsdl_operation,
+    return AXIS2_WSDL_OPERATION_GET_NAME(operation->wsdl_operation,
         env);
 }
 
@@ -430,8 +651,9 @@
 		                                    const axis2_char_t *pattern)
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, pattern, AXIS2_FAILURE);
     
-    return AXIS2_WSDL_OPERATION_SET_MSG_EXCHANGE_PATTERN(AXIS2_INTF_TO_IMPL(operation)->
+    return AXIS2_WSDL_OPERATION_SET_MSG_EXCHANGE_PATTERN(operation->
         wsdl_operation, env, pattern);
 }
 
@@ -442,73 +664,554 @@
     AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
     
     return AXIS2_WSDL_OPERATION_GET_MSG_EXCHANGE_PATTERN
-        (AXIS2_INTF_TO_IMPL(operation)->wsdl_operation, env);
+        (operation->wsdl_operation, env);
 }
 
-axis2_hash_t * AXIS2_CALL
-axis2_operation_get_component_properties(axis2_operation_t *operation,
-                                        axis2_env_t **env)
+axis2_char_t * AXIS2_CALL
+axis2_operation_get_style (axis2_operation_t *operation,
+                            axis2_env_t **env)
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
     
-    return AXIS2_WSDL_OPERATION_GET_COMPONENT_PROPERTIES(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env);
+    return AXIS2_WSDL_OPERATION_GET_STYLE(operation->wsdl_operation, env);
+}
+
+axis2_status_t  AXIS2_CALL
+axis2_operation_set_style (axis2_operation_t *operation,
+                            axis2_env_t **env,
+                            axis2_char_t *style)
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, style, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_OPERATION_SET_STYLE(operation->wsdl_operation, env, style);
 }
 
 axis2_status_t AXIS2_CALL
-axis2_operation_set_component_properties(axis2_operation_t *operation,
-                                        axis2_env_t **env,
-                                        axis2_hash_t *properties)
+axis2_operation_engage_module(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_module_desc_t *moduleref) 
 {
+    int index = 0;
+    int size = 0;
+    axis2_array_list_t *collection_module = NULL;
+    struct axis2_module_desc *module_desc = NULL;
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, moduleref, AXIS2_FAILURE);
+    
+    collection_module = (axis2_array_list_t *) 
+        AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(operation->wsdl_operation->
+        extensible_component->wsdl_component, env, MODULEREF_KEY);
     
-    return AXIS2_WSDL_OPERATION_SET_COMPONENT_PROPERTIES(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env, properties);
+    size = AXIS2_ARRAY_LIST_SIZE(collection_module, env);
+    for(index = 0; index < size; index++)
+    {
+        module_desc = (axis2_module_desc_t *) AXIS2_ARRAY_LIST_GET(
+            collection_module, env, index);
+        
+        if(AXIS2_QNAME_EQUALS(AXIS2_MODULE_DESC_GET_NAME(module_desc, env), env,
+                AXIS2_MODULE_DESC_GET_NAME(moduleref, env)))
+            AXIS2_ERROR_SET((*env)->error, 
+                AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_OPERATION, AXIS2_FAILURE);
+
+    }
+    /*    new PhaseResolver().engageModuleToOperation(this, moduleref);*/
+    return AXIS2_ARRAY_LIST_ADD(collection_module, env, moduleref);
 }
 
-axis2_wsdl_component_t * AXIS2_CALL
-axis2_operation_get_component_property(axis2_operation_t *operation,
-                                        axis2_env_t **env,
-                                        const axis2_char_t *key)
+axis2_status_t AXIS2_CALL
+axis2_operation_add_to_engage_module_list(axis2_operation_t *operation,
+                                            axis2_env_t **env,
+                                            axis2_module_desc_t *module_name) 
+{
+    axis2_array_list_t *collection_module = NULL;
+    axis2_module_desc_t *module_desc = NULL;
+    int size = 0;
+    int index = 0;
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, module_name, AXIS2_FAILURE);
+    
+    collection_module = (axis2_array_list_t *) 
+        AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(operation->wsdl_operation->
+            extensible_component->wsdl_component, env, MODULEREF_KEY);
+    
+    size = AXIS2_ARRAY_LIST_SIZE(collection_module, env);
+    for(index = 0; index < size; index++)
+    {
+        module_desc = (axis2_module_desc_t *) AXIS2_ARRAY_LIST_GET(
+            collection_module, env, index);
+        
+        if(AXIS2_QNAME_EQUALS(AXIS2_MODULE_DESC_GET_NAME(module_desc, env), env,
+                AXIS2_MODULE_DESC_GET_NAME(module_name, env)))
+            AXIS2_ERROR_SET((*env)->error, 
+                AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_OPERATION, AXIS2_FAILURE);
+
+    }
+    return AXIS2_ARRAY_LIST_ADD(collection_module, env, module_name);
+}
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_modules(axis2_operation_t *operation,
+                                axis2_env_t **env) 
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, key, NULL);
+    return (axis2_array_list_t *) AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(
+        operation->wsdl_operation->extensible_component->wsdl_component, env, 
+            MODULEREF_KEY);
+}
+
+int AXIS2_CALL
+axis2_operation_get_axis_specific_MEP_constant(axis2_operation_t *operation,
+                                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
     
-    return AXIS2_WSDL_OPERATION_GET_COMPONENT_PROPERTY(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env, key); 
+    if (operation_impl->mep != MEP_CONSTANT_INVALID) 
+    {
+        return operation_impl->mep;
+    }
+
+    int temp = MEP_CONSTANT_INVALID;
+
+    if (AXIS2_STRCMP(MEP_URI_IN_OUT, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_IN_OUT;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_IN_ONLY, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_IN_ONLY;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_IN_OPTIONAL_OUT, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_IN_OPTIONAL_OUT;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_OUT_IN, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_OUT_IN;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_OUT_ONLY, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_OUT_ONLY;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_OUT_OPTIONAL_IN, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_OUT_OPTIONAL_IN;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_ROBUST_IN_ONLY, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_ROBUST_IN_ONLY;
+    } 
+    else if (AXIS2_STRCMP(MEP_URI_ROBUST_OUT_ONLY, 
+            axis2_operation_get_msg_exchange_pattern(operation, env))) 
+    {
+        temp = MEP_CONSTANT_ROBUST_OUT_ONLY;
+    }
+
+    if (temp == MEP_CONSTANT_INVALID) 
+    {
+        AXIS2_ERROR_SET((*env)->error, 
+            AXIS2_ERROR_COULD_NOT_MAP_MEP_URI_TO_MEP_CONSTANT, AXIS2_FAILURE);
+    }
+    operation_impl->mep = temp;
+    return operation_impl->mep;
+
+}
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_phases_in_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_INTF_TO_IMPL(operation)->phases_in_fault_flow;
+}
+
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_phases_out_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_INTF_TO_IMPL(operation)->phases_out_fault_flow;
+}
+
+
+axis2_array_list_t * AXIS2_CALL
+axis2_operation_get_phases_out_flow(axis2_operation_t *operation,
+                                        axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_INTF_TO_IMPL(operation)->phases_out_flow;
+}
+
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_remaining_phases_in_flow(axis2_operation_t *operation,
+                                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_INTF_TO_IMPL(operation)->remaining_phases_in_flow;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_phases_in_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env,
+                                            axis2_array_list_t *list) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, list, AXIS2_FAILURE);
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    if(operation_impl->phases_in_fault_flow)
+       AXIS2_WSDL_OPERATION_FREE(operation_impl->phases_in_fault_flow, env);
+    
+    operation_impl->phases_in_fault_flow = list;
+    return AXIS2_SUCCESS;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_operation_set_component_property (axis2_operation_t *operation,
+axis2_operation_set_phases_out_fault_flow(axis2_operation_t *operation,
+                                            axis2_env_t **env,
+                                            axis2_array_list_t *list) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, list, AXIS2_FAILURE);
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    if(operation_impl->phases_out_fault_flow)
+       AXIS2_WSDL_OPERATION_FREE(operation_impl->phases_out_fault_flow, env);
+    
+    operation_impl->phases_out_fault_flow = list;
+    return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_phases_out_flow(axis2_operation_t *operation,
                                         axis2_env_t **env,
-                                        const void *key,
-                                        void *value)
+                                        axis2_array_list_t *list) 
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, key, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, list, AXIS2_FAILURE);
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    if(operation_impl->phases_out_flow)
+       AXIS2_WSDL_OPERATION_FREE(operation_impl->phases_out_flow, env);
     
-    return AXIS2_WSDL_OPERATION_SET_COMPONENT_PROPERTY(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env, (axis2_char_t *) key, value);
+    operation_impl->phases_out_flow = list;
+    return AXIS2_SUCCESS;
 }
 
-axis2_char_t * AXIS2_CALL
-axis2_operation_get_style (axis2_operation_t *operation,
-                            axis2_env_t **env)
+axis2_status_t AXIS2_CALL
+axis2_operation_set_remaining_phases_in_flow(axis2_operation_t *operation,
+                                                axis2_env_t **env,
+                                                axis2_array_list_t *list) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, list, AXIS2_FAILURE);
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    if(operation_impl->remaining_phases_in_flow)
+       AXIS2_LINKED_LIST_FREE(operation_impl->remaining_phases_in_flow, env);
+    operation_impl->remaining_phases_in_flow = list;
+    return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_module(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_qname_t *module_name) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, module_name, AXIS2_FAILURE);
+    axis2_operation_impl_t *operation_impl = AXIS2_INTF_TO_IMPL(operation);
+    return AXIS2_ARRAY_LIST_ADD(operation_impl->modulerefs, env, module_name);
+}
+
+axis2_array_list_t *AXIS2_CALL
+axis2_operation_get_module_refs(axis2_operation_t *operation,
+                                    axis2_env_t **env) 
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_INTF_TO_IMPL(operation)->modulerefs;
+}
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_infaults(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_OPERATION_GET_INFAULTS(operation->wsdl_operation, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_infaults(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_linked_list_t *infaults) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, infaults, AXIS2_FAILURE);
     
-    return AXIS2_WSDL_OPERATION_GET_STYLE(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env);
+    return AXIS2_WSDL_OPERATION_SET_INFAULTS(operation->wsdl_operation, env, infaults);
 }
 
-axis2_status_t  AXIS2_CALL
-axis2_operation_set_style (axis2_operation_t *operation,
-                            axis2_env_t **env,
-                            axis2_char_t *style)
+struct axis2_wsdl_msg_ref *AXIS2_CALL
+axis2_operation_get_input_msg(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_OPERATION_GET_INPUT_MSG(operation->wsdl_operation, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_input_msg(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                struct axis2_wsdl_msg_ref *input_msg) 
 {
     AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, style, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, input_msg, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_OPERATION_SET_INPUT_MSG(operation->wsdl_operation, env, input_msg);
+}
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_outfaults(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_OPERATION_GET_OUTFAULTS(operation->wsdl_operation, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_outfaults(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_linked_list_t *outfaults) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, outfaults, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_OPERATION_SET_OUTFAULTS(operation->wsdl_operation, env, outfaults);
+}
+
+struct axis2_wsdl_msg_ref *AXIS2_CALL
+axis2_operation_get_output_msg(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_OPERATION_GET_OUTPUT_MSG(operation->wsdl_operation, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_output_msg(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                struct axis2_wsdl_msg_ref *output_msg) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, output_msg, AXIS2_FAILURE);
     
-    return AXIS2_WSDL_OPERATION_SET_STYLE(AXIS2_INTF_TO_IMPL(operation)->
-        wsdl_operation, env, style);
+    return AXIS2_WSDL_OPERATION_SET_OUTPUT_MSG(operation->wsdl_operation, env, output_msg);
+}
+
+axis2_bool_t AXIS2_CALL
+axis2_operation_is_safe(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FALSE);
+    return AXIS2_WSDL_OPERATION_IS_SAFE(operation->wsdl_operation, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_set_safety(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_bool_t safe) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    return AXIS2_WSDL_OPERATION_SET_SAFETY(operation->wsdl_operation, env, safe);
+}
+
+axis2_char_t *AXIS2_CALL
+axis2_operation_get_target_namespace(axis2_operation_t *operation,
+                                        axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_OPERATION_GET_TARGET_NAMESPACE(operation->wsdl_operation,
+        env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_infault(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_fault_ref_t *infault) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, infault, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_OPERATION_ADD_INFAULT(operation->wsdl_operation, env, infault);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_outfault(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_fault_ref_t *outfault) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, outfault, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_OPERATION_ADD_OUTFAULT(operation->wsdl_operation, env, outfault);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_feature(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_feature_t *feature) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, feature, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_EXTENSIBLE_COMPONENT_ADD_FEATURE(operation->wsdl_operation->
+        extensible_component, env, feature);
+}
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_features(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_EXTENSIBLE_COMPONENT_GET_FEATURES(operation->
+        wsdl_operation->extensible_component, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_operation_add_property(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_property_t *wsdl_property) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, wsdl_property, AXIS2_FAILURE);
+    
+    return AXIS2_WSDL_EXTENSIBLE_COMPONENT_ADD_PROPERTY(operation->wsdl_operation->
+        extensible_component, env, wsdl_property);
+}
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_operation_get_Properties(axis2_operation_t *operation,
+                                axis2_env_t **env) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, NULL);
+    return AXIS2_WSDL_EXTENSIBLE_COMPONENT_GET_PROPERTIES(operation->
+        wsdl_operation->extensible_component, env);
+}
+
+axis2_status_t AXIS2_CALL 
+axis2_operation_set_wsdl_opeartion(axis2_operation_t *operation,
+                                axis2_env_t **env,
+                                axis2_wsdl_operation_t *wsdl_operation) 
+{
+    AXIS2_FUNC_PARAM_CHECK(operation, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, wsdl_operation, AXIS2_FAILURE);
+    
+    if(operation->wsdl_operation)
+       AXIS2_WSDL_OPERATION_FREE(operation->wsdl_operation, env);
+    
+    operation->wsdl_operation = wsdl_operation;
+    return AXIS2_SUCCESS;
+}
+
+/**
+ * This method is responsible for finding a MEPContext for an incomming
+ * messages. An incomming message can be of two states.
+ * <p/>
+ * 1)This is a new incomming message of a given MEP. 2)This message is a
+ * part of an MEP which has already begun.
+ * <p/>
+ * The method is special cased for the two MEPs
+ * <p/>
+ * #IN_ONLY #IN_OUT
+ * <p/>
+ * for two reasons. First reason is the wide usage and the second being that
+ * the need for the MEPContext to be saved for further incomming messages.
+ * <p/>
+ * In the event that MEP of this operation is different from the two MEPs
+ * deafulted above the decession of creating a new or this message relates
+ * to a MEP which already in business is decided by looking at the WSA
+ * Relates TO of the incomming message.
+ *
+ * @param msgContext
+ */
+/*OperationContext findOperationContext(MessageContext msgContext, ServiceContext serviceContext) throws AxisFault {
+    OperationContext operationContext ;
+
+    if (null == msgContext.get_RelatesTo()) {
+        //Its a new incomming message so get_ the factory to create a new
+        // one
+       operationContext =  new OperationContext(this,serviceContext);
+    } else {
+        // So this message is part of an ongoing MEP
+        //			operationContext =
+        ConfigurationContext configContext = msgContext.get_SystemContext();
+        operationContext =
+                configContext.get_OperationContext( msgContext.get_RelatesTo().get_Value());
+
+        if (null == operationContext) {
+            throw new AxisFault(Messages.get_Message("cannotCorrelateMsg",
+                    this.get_Name().toString(),msgContext.get_RelatesTo().get_Value()));
+        }
+
+    }
+
+    registerOperationContext(msgContext, operationContext);
+
+    return operationContext;
+
+}
+*/
+
+/**
+ * This will not create a new operation context if there is no one already.
+ * @param msgContext
+ * @return
+ * @throws AxisFault
+ */
+/*axis2_operation_ctx_t *AXIS2_CALL
+OperationContext 
+findForExistingOperationContext(MessageContext msgContext) throws AxisFault {
+    OperationContext operationContext = null;
+
+    if((operationContext = msgContext.get_OperationContext()) != null) {
+        return operationContext;
+    }
+
+    if (null == msgContext.get_RelatesTo()) {
+        return null;
+    } else {
+        // So this message is part of an ongoing MEP
+        //			operationContext =
+        ConfigurationContext configContext = msgContext.get_SystemContext();
+        operationContext = configContext.get_OperationContext(msgContext.get_RelatesTo().get_Value());
+
+        if (null == operationContext) {
+            throw new AxisFault(Messages.get_Message("cannotCorrealteMsg",
+                    this.get_Name().toString(),msgContext.get_RelatesTo().get_Value()));
+        }
+
+    }
+
+
+    return operationContext;
+
+}
+*/
+/*
+axis2_status_t AXIS2_CALL
+registerOperationContext(MessageContext msgContext, OperationContext operationContext) throws AxisFault {
+    msgContext.get_SystemContext().registerOperationContext(
+            msgContext.get_MessageID(), operationContext);
+    operationContext.addMessageContext(msgContext);
+    msgContext.setOperationContext(operationContext);
+    if (operationContext.isComplete()) {
+        operationContext.cleanup();
+    }
 }
+*/

Modified: webservices/axis2/trunk/c/modules/core/description/src/param_container.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/src/param_container.c?rev=345817&r1=345816&r2=345817&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/src/param_container.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/src/param_container.c Sun Nov 20 19:15:08 2005
@@ -143,7 +143,7 @@
 	AXIS2_FUNC_PARAM_CHECK(param_container, env, NULL);
 	
 	return (axis2_param_t *)(axis2_hash_get (AXIS2_INTF_TO_IMPL(param_container)->
-		params, AXIS2_STRDUP(name, env), AXIS2_HASH_KEY_STRING));
+		params, name, AXIS2_HASH_KEY_STRING));
 }
 
 axis2_array_list_t * AXIS2_CALL 
@@ -177,9 +177,10 @@
 	
 	axis2_param_t *param = (axis2_param_t *)
 		(axis2_hash_get (AXIS2_INTF_TO_IMPL(param_container)->params
-			, AXIS2_STRDUP(param_name, env), AXIS2_HASH_KEY_STRING));
+			, param_name, AXIS2_HASH_KEY_STRING));
 	
-    AXIS2_PARAM_CHECK((*env)->error, param, AXIS2_FAILURE);
+    if(NULL == param)
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
 	
 	return AXIS2_PARAM_IS_LOCKED(param, env);
 }

Modified: webservices/axis2/trunk/c/modules/core/description/src/svc_grp.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/src/svc_grp.c?rev=345817&r1=345816&r2=345817&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/src/svc_grp.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/src/svc_grp.c Sun Nov 20 19:15:08 2005
@@ -16,13 +16,13 @@
  
 #include <axis2_svc_grp.h>
 
-typedef struct axis2_svc_grp_impl_s axis2_svc_grp_impl_t;
+typedef struct axis2_svc_grp_impl axis2_svc_grp_impl_t;
 
 /** 
  * @brief Service group struct impl
  * Axis2 Service group impl  
  */  
-struct axis2_svc_grp_impl_s
+struct axis2_svc_grp_impl
 {
 	axis2_svc_grp_t svc_grp;
 	axis2_param_container_t *param_container;



Mime
View raw message