axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r351594 [5/5] - in /webservices/axis2/trunk/c: ./ ides/anjuta/ include/ modules/core/context/src/ modules/core/description/src/ modules/core/engine/src/ modules/core/phaseresolver/src/ modules/core/phaseresolver/src/.deps/ modules/core/tran...
Date Fri, 02 Dec 2005 05:14:51 GMT
Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/src/phase_resolver.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/phaseresolver/src/phase_resolver.c?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/src/phase_resolver.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/src/phase_resolver.c Thu Dec  1 21:13:39 2005
@@ -27,18 +27,17 @@
     /**
      * Field axisConfig
      */
-    private AxisConfiguration axisConfig;
+    struct axis2_engine_config *axis2_config;
 
     /**
      * Field axisService
      */
-    private AxisService axisService;
-
+    struct axis2_svc *svc;
 
     /**
      * Field phaseHolder
      */
-    private PhaseHolder phaseHolder;
+    struct axis2_phase_holder *phase_holder;
     
 } axis2_phase_resolver_impl_t;
 
@@ -51,29 +50,100 @@
                 axis2_phase_resolver_t *phase_resolver,
 				axis2_env_t **env);
 
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_chains(axis2_phase_resolver_t *phase_resolver,
+                                    axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_module_operation(axis2_phase_resolver_t *phase_resolver,
+                                    axis2_env_t **env,
+                                    struct axis2_operation *operation);
+
+/**
+ * this opeartion is used to build all the three cahins ,
+ * so type varible is used to difrenciate them
+ * type = 1 inflow
+ * type = 2 out flow
+ * type = 3 fault flow
+ *
+ * @param type
+ */                                    
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_execution_chains(axis2_phase_resolver_t *phase_resolver,
+                                    axis2_env_t **env,
+                                    int type,
+                                    struct axis2_operation *operation);
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_transport_chains(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env);
+
+
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_in_transport_chains(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_transport_in_desc *transport);
+
+/**
+ * Method buildTransportChains
+ *
+ * @param transport
+ * @throws PhaseException
+ */
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_out_transport_chains(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_transport_out_desc *transport);
+
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_globally(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_module_desc *module);
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_svc_from_global(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_svc *svc,
+                                                struct axis2_module_desc *module_desc);
+
+
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_to_global_chain(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_module_desc *module_desc);
+
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_svc(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_svc *svc,
+                                                struct axis2_module_desc *module_desc);
+                                                    
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_operation(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_operation *axis_operation,
+                                                struct axis2_module_desc *module_desc);
 
 /************************** End of function prototypes ************************/
 
 axis2_phase_resolver_t * AXIS2_CALL 
 axis2_phase_resolver_create (axis2_env_t **env)
 {
+    axis2_phase_resolver_impl_t *phase_resolver_impl = NULL;
+    phase_resolver_impl->phase_resolver.ops = NULL;
+    phase_resolver_impl->axis2_config = NULL;
+    phase_resolver_impl->svc = NULL;
+    phase_resolver_impl->phase_holder = NULL;
 	AXIS2_ENV_CHECK(env, NULL);
 	
-	axis2_phase_resolver_impl_t *phase_resolver_impl = 
-		(axis2_phase_resolver_impl_t *) AXIS2_MALLOC((*env)->allocator,
+	phase_resolver_impl = (axis2_phase_resolver_impl_t *) AXIS2_MALLOC((*env)->allocator,
 			sizeof(axis2_phase_resolver_impl_t));
 	
-	
 	if(NULL == phase_resolver_impl)
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL); 
     
-    phase_resolver_impl->phase_list = axis2_array_list_create(env, 0);
-    if(NULL == phase_resolver_impl->phase_list)
-    {
-        axis2_phase_resolver_free(&(phase_resolver_impl->phase_resolver), env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
-    }
-    
 	phase_resolver_impl->phase_resolver.ops = 
 		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_phase_resolver_ops_t));
 	if(NULL == phase_resolver_impl->phase_resolver.ops)
@@ -85,29 +155,73 @@
     
     phase_resolver_impl->phase_resolver.ops->free =  
         axis2_phase_resolver_free;
-    
-	phase_resolver_impl->phase_resolver.ops->is_phase_exist =  
-        axis2_phase_resolver_is_phase_exist;
-	phase_resolver_impl->phase_resolver.ops->add_handler =  
-        axis2_phase_resolver_add_handler;
-	phase_resolver_impl->phase_resolver.ops->get_phase =  
-        axis2_phase_resolver_get_phase;
-	phase_resolver_impl->phase_resolver.ops->build_transport_handler_chain = 
-        axis2_phase_resolver_build_transport_handler_chain;
 	
+    phase_resolver_impl->phase_resolver.ops->build_chains = 
+        axis2_phase_resolver_build_chains;
+    
+    phase_resolver_impl->phase_resolver.ops->build_module_operation = 
+        axis2_phase_resolver_build_module_operation;
+    
+    phase_resolver_impl->phase_resolver.ops->build_transport_chains =     
+        axis2_phase_resolver_build_transport_chains;
+    
+    phase_resolver_impl->phase_resolver.ops->engage_module_globally = 
+        axis2_phase_resolver_engage_module_globally;
+        
+    phase_resolver_impl->phase_resolver.ops->engage_module_to_svc_from_global = 
+        axis2_phase_resolver_engage_module_to_svc_from_global;
+        
+    phase_resolver_impl->phase_resolver.ops->engage_module_to_svc = 
+        axis2_phase_resolver_engage_module_to_svc;
+        
+    phase_resolver_impl->phase_resolver.ops->engage_module_to_operation = 
+        axis2_phase_resolver_engage_module_to_operation;
+    
+  
 	return &(phase_resolver_impl->phase_resolver);
 }
 
 axis2_phase_resolver_t * AXIS2_CALL 
-axis2_phase_resolver_create_with_phases (axis2_env_t **env, axis2_array_list_t *phases)
+axis2_phase_resolver_create_with_config (axis2_env_t **env, 
+                                         struct axis2_engine_config *axis2_config)
 {
+    axis2_phase_resolver_impl_t *phase_resolver_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, phases, NULL);
+    AXIS2_PARAM_CHECK((*env)->error, axis2_config, NULL);
     
-    axis2_phase_resolver_impl_t *phase_resolver_impl = (axis2_phase_resolver_impl_t *)
+    phase_resolver_impl = (axis2_phase_resolver_impl_t *)
         axis2_phase_resolver_create(env);
-    AXIS2_ARRAY_LIST_FREE(phase_resolver_impl->phase_list, env);
-    phase_resolver_impl->phase_list = phases;
+    AXIS2_ENGINE_CONFIG_FREE(phase_resolver_impl->axis2_config, env);
+    phase_resolver_impl->axis2_config = axis2_config;
+    return &(phase_resolver_impl->phase_resolver);
+}
+
+axis2_phase_resolver_t * AXIS2_CALL 
+axis2_phase_resolver_create_with_config_and_svc (axis2_env_t **env, 
+                                                struct axis2_engine_config *axis2_config,
+                                                struct axis2_svc *svc)
+{
+    axis2_phase_resolver_impl_t *phase_resolver_impl = NULL;
+    AXIS2_ENV_CHECK(env, NULL);
+    AXIS2_PARAM_CHECK((*env)->error, axis2_config, NULL);
+    
+    phase_resolver_impl = (axis2_phase_resolver_impl_t *)
+        axis2_phase_resolver_create(env);
+    
+    if(phase_resolver_impl->axis2_config)
+    {
+        AXIS2_ENGINE_CONFIG_FREE(phase_resolver_impl->axis2_config, env);
+        phase_resolver_impl->axis2_config = NULL;
+    }    
+    phase_resolver_impl->axis2_config = axis2_config;
+    
+    if(phase_resolver_impl->svc)
+    {
+        AXIS2_SVC_FREE(phase_resolver_impl->svc, env);
+        phase_resolver_impl->svc = NULL;
+    }
+    phase_resolver_impl->svc = svc;
+    
     return &(phase_resolver_impl->phase_resolver);
 }
 
@@ -125,9 +239,22 @@
 	if(NULL != phase_resolver->ops)
         AXIS2_FREE((*env)->allocator, phase_resolver->ops);
     
-    if(NULL != phase_resolver_impl->phase_list)
+    if(NULL != phase_resolver_impl->axis2_config)
+    {
+        AXIS2_ENGINE_CONFIG_FREE(phase_resolver_impl->axis2_config, env);
+        phase_resolver_impl->axis2_config = NULL;
+    }
+    
+    if(NULL != phase_resolver_impl->svc)
     {
-        AXIS2_ARRAY_LIST_FREE(phase_resolver_impl->phase_list, env);
+        AXIS2_SVC_FREE(phase_resolver_impl->svc, env);
+        phase_resolver_impl->svc = NULL;
+    }
+    
+    if(NULL != phase_resolver_impl->phase_holder)
+    {
+        AXIS2_PHASE_HOLDER_FREE(phase_resolver_impl->phase_holder, env);
+        phase_resolver_impl->phase_holder = NULL;
     }
     
     AXIS2_FREE((*env)->allocator, phase_resolver_impl);
@@ -135,593 +262,923 @@
 	return AXIS2_SUCCESS;
 }
 
-/**
- * Class PhaseResolver
- */
-public class PhaseResolver {
-    /**
-     * Field axisConfig
-     */
-    private AxisConfiguration axisConfig;
-
-    /**
-     * Field axisService
-     */
-    private AxisService axisService;
-
-
-    /**
-     * Field phaseHolder
-     */
-    private PhaseHolder phaseHolder;
-
-    public PhaseResolver() {
-    }
-
-    /**
-     * default constructor , to obuild chains for GlobalDescription
-     *
-     * @param engineConfig
-     */
-    public PhaseResolver(AxisConfiguration engineConfig) {
-        this.axisConfig = engineConfig;
-    }
-
-    /**
-     * Constructor PhaseResolver
-     *
-     * @param axisConfig
-     * @param serviceContext
-     */
-    public PhaseResolver(AxisConfiguration axisConfig,
-                         AxisService serviceContext) {
-        this.axisConfig = axisConfig;
-        this.axisService = serviceContext;
-    }
-
-    /**
-     * Method buildchains
-     *
-     * @throws PhaseException
-     * @throws AxisFault
-     */
-    public void buildchains() throws PhaseException, AxisFault {
-        HashMap operations = axisService.getOperations();
-        Collection col = operations.values();
-        for (Iterator iterator = col.iterator(); iterator.hasNext();) {
-            AxisOperation axisOperation = (AxisOperation) iterator.next();
-            for (int i = 1; i < 5; i++) {
-                buildExcutionChains(i, axisOperation);
-            }
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_chains(axis2_phase_resolver_t *phase_resolver,
+                                    axis2_env_t **env) 
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    axis2_hash_index_t *index_i = 0;
+    int j = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    void * v = NULL;
+    struct axis2_operation *operation = NULL;
+    axis2_hash_t *operations = NULL;
+    
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    operations = AXIS2_SVC_GET_OPERATIONS(resolver_impl->svc, env);
+    
+    for (index_i = axis2_hash_first (operations, env); index_i; index_i = axis2_hash_next (env, index_i))
+    {
+        axis2_hash_this (index_i, NULL, NULL, &v);
+        operation = (struct axis2_operation *)v;
+        for(j = 1; j < 5; j++)
+        {
+            status = axis2_phase_resolver_build_execution_chains(phase_resolver,
+                env, j, operation );
+            
         }
     }
 
-    /**
-     * To build the opration for the opeartion which the module going to be added
-     *
-     * @param opartion <code>AxisOperation</code>
-     * @throws AxisFault
-     */
-    public void buildModuleOperation(AxisOperation opartion) throws AxisFault {
-        for (int i = 1; i < 5; i++) {
-            buildExcutionChains(i, opartion);
-        }
+    return status;    
+}
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_module_operation(axis2_phase_resolver_t *phase_resolver,
+                                    axis2_env_t **env,
+                                    struct axis2_operation *operation)
+{
+    AXIS2_FUNC_PARAM_CHECK(phase_resolver, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, operation, AXIS2_FAILURE);
+    int i = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    for (i = 1; i < 5; i++) 
+    {
+        status = axis2_phase_resolver_build_execution_chains(phase_resolver, env, 
+                    i, operation);
     }
+    return status;
+}
 
-    /**
-     * this opeartion is used to build all the three cahins ,
-     * so type varible is used to difrenciate them
-     * type = 1 inflow
-     * type = 2 out flow
-     * type = 3 fault flow
-     *
-     * @param type
-     * @throws AxisFault
-     * @throws PhaseException
-     */
-    private void buildExcutionChains(int type, AxisOperation axisOperation)
-            throws AxisFault, PhaseException {
-        ArrayList allHandlers = new ArrayList();
-        ModuleDescription module;
-        Flow flow = null;
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        ////////////////////////// Handlers from   axis2.xml from modules/////////////////////////
-        ArrayList modulqnames = (ArrayList) ((AxisConfigurationImpl) axisConfig).getEngadgedModules();
-        for (int i = 0; i < modulqnames.size(); i++) {
-            QName modulename = (QName) modulqnames.get(i);
-            module = axisConfig.getModule(modulename);
-            if (module != null) {
-                switch (type) {
-                    case PhaseMetadata.IN_FLOW:
-                    {
-                        flow = module.getInFlow();
-                        break;
-                    }
-                    case PhaseMetadata.OUT_FLOW:
-                    {
-                        flow = module.getOutFlow();
-                        break;
-                    }
-                    case PhaseMetadata.FAULT_IN_FLOW:
-                    {
-                        flow = module.getFaultInFlow();
-                        break;
-                    }
-                    case PhaseMetadata.FAULT_OUT_FLOW:
-                    {
-                        flow = module.getFaultOutFlow();
-                        break;
-                    }
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_execution_chains(axis2_phase_resolver_t *phase_resolver,
+                                    axis2_env_t **env,
+                                    int type,
+                                    struct axis2_operation *operation)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    axis2_array_list_t *all_handlers = NULL;
+    struct axis2_module_desc *module_desc = NULL;
+    struct axis2_flow *flow = NULL;
+    axis2_array_list_t *moduleqnames = NULL;
+    int i = 0;
+    int j = 0;
+    int status = AXIS2_FAILURE;
+    axis2_qname_t *modulename = NULL;
+    struct axis2_handler_desc *metadata = NULL;
+    axis2_char_t *phase_name = NULL;
+    struct axis2_phase_rule *phase_rule = NULL;
+        
+    all_handlers = axis2_array_list_create(env, 0);
+    
+    /**************************************************************************/
+    /********************* Handlers from   axis2.xml from modules *************/
+    /**************************************************************************/
+    
+    moduleqnames = (axis2_array_list_t *) AXIS2_ENGINE_CONFIG_GET_ENGAGED_MODULES(
+        resolver_impl->axis2_config, env);
+    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(moduleqnames, env); i++) 
+    {
+        modulename = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(moduleqnames, env, i);
+        module_desc = AXIS2_ENGINE_CONFIG_GET_MODULE(resolver_impl->axis2_config, env, 
+            modulename);
+        if (NULL != module_desc) 
+        {
+            switch (type) 
+            {
+                case AXIS2_INFLOW:
+                {
+                    flow = AXIS2_MODULE_DESC_GET_INFLOW(module_desc, env);
+                    break;
                 }
-                axisService.addToEngagModuleList(module);
-                axisOperation.addToEngageModuleList(module);
-            } else {
-                throw new PhaseException(Messages.getMessage(
-                        DeploymentErrorMsgs.INVALID_MODULE_REF, modulename.getLocalPart()));
-            }
-
-            if (flow != null) {
-                for (int j = 0; j < flow.getHandlerCount(); j++) {
-                    HandlerDescription metadata = flow.getHandler(j);
-
-                    if (!PhaseValidator.isSystemPhases(metadata.getRules().getPhaseName())) {
-                        allHandlers.add(metadata);
-                    } else {
-                        /**
-                         *This handler is trying to added to system pre defined phases , but those handlers
-                         * are already added to global chain which run irrespective of the service
-                         *
-                         */
-                    }
+                case AXIS2_OUTFLOW:
+                {
+                    flow = AXIS2_MODULE_DESC_GET_OUTFLOW(module_desc, env);
+                    break;
+                }
+                case AXIS2_FAULT_INFLOW:
+                {
+                    flow = AXIS2_MODULE_DESC_GET_FAULT_INFLOW(module_desc, env);
+                    break;
+                }
+                case AXIS2_FAULT_OUTFLOW:
+                {
+                    flow = AXIS2_MODULE_DESC_GET_FAULT_OUTFLOW(module_desc, env);
+                    break;
                 }
             }
-
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        ////////////////////////// SERVICE HANDLERS ///////////////////////////////////////////////
-        switch (type) {
-            case PhaseMetadata.IN_FLOW:
-            {
-                flow = axisService.getInFlow();
-                break;
-            }
-            case PhaseMetadata.OUT_FLOW:
-            {
-                flow = axisService.getOutFlow();
-                break;
-            }
-            case PhaseMetadata.FAULT_IN_FLOW:
+            status = AXIS2_SVC_ADD_TO_ENGAGED_MODULE_LIST(resolver_impl->svc, env, module_desc);
+            if(AXIS2_FAILURE == status) 
             {
-                flow = axisService.getFaultInFlow();
-                break;
+                if(all_handlers)            
+                    AXIS2_ARRAY_LIST_FREE(all_handlers, env); 
+                return status;
             }
-            case PhaseMetadata.FAULT_OUT_FLOW:
+            status = AXIS2_OPERATION_ADD_TO_ENGAGE_MODULE_LIST(operation, env, module_desc);
+            if(AXIS2_FAILURE == status) 
             {
-                flow = axisService.getFaultOutFlow();
-                break;
-            }
+                if(all_handlers)            
+                    AXIS2_ARRAY_LIST_FREE(all_handlers, env); 
+                return status;
+            }
+            
+        } else 
+        {
+            if(all_handlers)            
+                    AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+                
+            AXIS2_ERROR_SET((*env)->error, INVALID_MODULE_REF, AXIS2_FAILURE);
+            return AXIS2_FAILURE;
         }
-        if (flow != null) {
-            for (int j = 0; j < flow.getHandlerCount(); j++) {
-                HandlerDescription metadata = flow.getHandler(j);
 
-                // todo change this in properway
-                if (metadata.getRules().getPhaseName().equals("")) {
-                    throw new PhaseException(
-                            Messages.getMessage(DeploymentErrorMsgs.PHASE_DOES_NOT_SPECIFED,
-                                    metadata.getName().getLocalPart()));
-                } else if(PhaseValidator.isSystemPhases(metadata.getRules().getPhaseName())){
-                    throw new PhaseException(Messages.getMessage(
-                            DeploymentErrorMsgs.SERVICE_MODULE_CAN_NOT_REFER_GLOBAL_PHASE,
-                            metadata.getRules().getPhaseName()));
-                } else {
-                    allHandlers.add(metadata);
+        if (NULL != flow) 
+        {
+            for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+            {
+                metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+                phase_rule = AXIS2_HANDLER_DESC_GET_RULES(metadata, env);
+                phase_name = AXIS2_PHASE_RULE_GET_NAME(phase_rule, env);
+                if ((0 != AXIS2_STRCMP(AXIS2_PHASE_TRANSPORTIN, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    status = AXIS2_ARRAY_LIST_ADD(all_handlers, env, metadata);
+                    if(AXIS2_FAILURE == status)
+                    {   
+                        if(all_handlers)            
+                            AXIS2_ARRAY_LIST_FREE(all_handlers, env);                         
+                        return status;
+                    }
+                } else 
+                {
+                    /**
+                     *This handler is trying to added to system pre defined phases , but those handlers
+                     * are already added to global chain which run irrespective of the service
+                     *
+                     */
                 }
             }
         }
-        switch (type) {
-            case PhaseMetadata.IN_FLOW:
-            {
-                phaseHolder =
-                        new PhaseHolder(axisOperation.getRemainingPhasesInFlow());
-                break;
-            }
-            case PhaseMetadata.OUT_FLOW:
+
+    }
+    /**************************************************************************/
+    /************************** SERVICE HANDLERS ******************************/
+    /**************************************************************************/
+    
+    switch (type) 
+    {
+        case AXIS2_INFLOW:
+        {
+            flow = AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(resolver_impl->
+                svc->wsdl_svc->wsdl_component, env, INFLOW_KEY);
+            break;
+        }
+        case AXIS2_OUTFLOW:
+        {
+            flow = AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(resolver_impl->
+                svc->wsdl_svc->wsdl_component, env, OUTFLOW_KEY);
+            break;
+        }
+        case AXIS2_FAULT_INFLOW:
+        {
+            flow = AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(resolver_impl->
+                svc->wsdl_svc->wsdl_component, env, IN_FAULTFLOW_KEY);
+            break;
+        }
+        case AXIS2_FAULT_OUTFLOW:
+        {
+            flow = AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(resolver_impl->
+                svc->wsdl_svc->wsdl_component, env, OUT_FAULTFLOW_KEY);
+            break;
+        }
+    }
+    if (NULL != flow) 
+    {
+        for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+        {
+            if(metadata)
+                AXIS2_HANDLER_DESC_FREE(metadata, env);
+            metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+            phase_name = AXIS2_PHASE_RULE_GET_NAME(AXIS2_HANDLER_DESC_GET_RULES(metadata, 
+                env), env);
+            /* TODO change this in properway */
+            if(0 == AXIS2_STRCMP(phase_name, ""))
             {
-                phaseHolder =
-                        new PhaseHolder(axisOperation.getPhasesOutFlow());
-                break;
-            }
-            case PhaseMetadata.FAULT_IN_FLOW:
+                AXIS2_ERROR_SET((*env)->error, PHASE_IS_NOT_SPECIFED, AXIS2_FAILURE);
+                
+            } else if ((0 != AXIS2_STRCMP(AXIS2_PHASE_TRANSPORTIN, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
             {
-                phaseHolder =
-                        new PhaseHolder(axisOperation.getPhasesInFaultFlow());
-                break;
-            }
-            case PhaseMetadata.FAULT_OUT_FLOW:
+                if(all_handlers)            
+                        AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+                AXIS2_ERROR_SET((*env)->error, 
+                    SERVICE_MODULE_CAN_NOT_REFER_GLOBAL_PHASE, AXIS2_FAILURE);
+                return AXIS2_FAILURE;
+                
+            } else 
             {
-                phaseHolder =
-                        new PhaseHolder(axisOperation.getPhasesOutFaultFlow());
-                break;
+                status = AXIS2_ARRAY_LIST_ADD(all_handlers, env, metadata);
+                if(AXIS2_FAILURE == status) 
+                {
+                    if(all_handlers)            
+                        AXIS2_ARRAY_LIST_FREE(all_handlers, env); 
+                    return status;
+                }
             }
         }
-        for (int i = 0; i < allHandlers.size(); i++) {
-            HandlerDescription handlerMetaData =
-                    (HandlerDescription) allHandlers.get(i);
-            phaseHolder.addHandler(handlerMetaData);
+    }
+    if(resolver_impl->phase_holder)
+    {
+        AXIS2_PHASE_HOLDER_FREE(resolver_impl->phase_holder, env);
+    }
+    switch (type) {
+        case AXIS2_INFLOW:
+        {
+            resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env, 
+                AXIS2_OPERATION_GET_REMAINING_PHASES_INFLOW(operation, env));
+            break;
+        }
+        case AXIS2_OUTFLOW:
+        {
+            resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env, 
+                AXIS2_OPERATION_GET_PHASES_OUTFLOW(operation, env));
+            break;
+        }
+        case AXIS2_FAULT_INFLOW:
+        {
+            resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                AXIS2_OPERATION_GET_PHASES_IN_FAULT_FLOW(operation, env));
+            break;
         }
+        case AXIS2_FAULT_OUTFLOW:
+        {
+            resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                AXIS2_OPERATION_GET_PHASES_OUT_FAULT_FLOW(operation, env));
+            break;
+        }
+    }
+    for (i = 0; i < AXIS2_ARRAY_LIST_SIZE(all_handlers, env); i++) 
+    {
+        metadata = (struct axis2_handler_desc *)
+            AXIS2_ARRAY_LIST_GET(all_handlers, env, i);
+        status = AXIS2_PHASE_HOLDER_ADD_HANDLER(resolver_impl->phase_holder, env, metadata);
+        
     }
 
-    /**
-     * Method buildTranspotsChains
-     *
-     * @throws PhaseException
-     */
-    public void buildTranspotsChains() throws PhaseException {
-        HashMap axisTransportIn = axisConfig.getTransportsIn();
-        HashMap axisTransportOut = axisConfig.getTransportsOut();
+    /* Free the locally created all_handlers list */
+    if(all_handlers)
+        AXIS2_ARRAY_LIST_FREE(all_handlers, env);
+    
+    return status;
+}
 
-        Collection colintrnsport = axisTransportIn.values();
-        for (Iterator iterator = colintrnsport.iterator();
-             iterator.hasNext();) {
-            TransportInDescription transport = (TransportInDescription) iterator.next();
-            buildINTransportChains(transport);
-        }
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_transport_chains(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    axis2_hash_t *transports_in = NULL;
+    axis2_hash_t *transports_out = NULL;
+    axis2_hash_index_t *index_i = 0;
+    struct axis2_transport_in_desc *transport_in = NULL;
+    struct axis2_transport_out_desc *transport_out = NULL;
+    void *v = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    
+    transports_in = AXIS2_ENGINE_CONFIG_GET_TRANSPORTS_IN(
+        resolver_impl->axis2_config, env);
+    
+    transports_out = AXIS2_ENGINE_CONFIG_GET_TRANSPORTS_OUT(
+        resolver_impl->axis2_config, env);
 
-        Collection colouttrnsport = axisTransportOut.values();
-        for (Iterator iterator = colouttrnsport.iterator();
-             iterator.hasNext();) {
-            TransportOutDescription transport = (TransportOutDescription) iterator.next();
-            buildOutTransportChains(transport);
-        }
+    for (index_i = axis2_hash_first (transports_in, env); index_i; index_i = axis2_hash_next (env, index_i))
+    {
+
+        axis2_hash_this (index_i, NULL, NULL, &v);
+        transport_in = (struct axis2_transport_in_desc *) v;
+        status = axis2_phase_resolver_build_in_transport_chains(phase_resolver, env, transport_in);
+        if(AXIS2_FAILURE == status)
+            return status;
     }
+    
+    for (index_i = axis2_hash_first (transports_out, env); index_i; index_i = axis2_hash_next (env, index_i))
+    {
 
+        axis2_hash_this (index_i, NULL, NULL, &v);
+        transport_out = (struct axis2_transport_out_desc *) v;
+        status = axis2_phase_resolver_build_out_transport_chains(phase_resolver, env, transport_out);
 
-    private void buildINTransportChains(TransportInDescription transport)
-            throws PhaseException {
-        Flow flow = null;
-        Phase phase = null;
-        for (int type = 1; type < 4; type++) {
-            switch (type) {
-                case PhaseMetadata.IN_FLOW:
+    }
+    
+    return status;
+}
+
+
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_in_transport_chains(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_transport_in_desc *transport)
+{
+    struct axis2_flow *flow = NULL;
+    struct axis2_phase *phase = NULL;
+    int type = 0;
+    int j = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axis2_array_list_t *handlers = NULL;
+    struct axis2_handler_desc *metadata = NULL;
+    struct axis2_phase_holder *phase_holder = NULL;
+    
+    for (type = 1; type < 4; type++) {
+        switch (type) {
+            case AXIS2_INFLOW:
+            {
+                flow = AXIS2_TRANSPORT_IN_DESC_GET_INFLOW(transport, env);
+                phase = AXIS2_TRANSPORT_IN_DESC_GET_INPHASE(transport, env);
+                break;
+            }
+            case AXIS2_FAULT_INFLOW:
+            {
+                flow = AXIS2_TRANSPORT_IN_DESC_GET_FAULTFLOW(transport, env);
+                phase = AXIS2_TRANSPORT_IN_DESC_GET_FAULTPHASE(transport, env);
+                break;
+            }
+        }
+        if (NULL != flow) 
+        {
+            handlers = axis2_array_list_create(env, 0);
+            for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+            {
+                metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+                status = AXIS2_PHASE_RULE_SET_NAME(AXIS2_HANDLER_DESC_GET_RULES(metadata,
+                    env), env, AXIS2_TRANSPORT_PHASE);
+                
+                if(AXIS2_FAILURE == status)
                 {
-                    flow = transport.getInFlow();
-                    phase = transport.getInPhase();
-                    break;
+                    if(handlers)
+                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                    return status;
                 }
-                case PhaseMetadata.FAULT_IN_FLOW:
+                status = AXIS2_ARRAY_LIST_ADD(handlers, env, metadata);
+                if(AXIS2_FAILURE == status)
                 {
-                    flow = transport.getFaultFlow();
-                    phase = transport.getFaultPhase();
-                    break;
+                    if(handlers)
+                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                    return status;
                 }
             }
-            if (flow != null) {
-                ArrayList handlers = new ArrayList();
-                for (int j = 0; j < flow.getHandlerCount(); j++) {
-                    HandlerDescription metadata = flow.getHandler(j);
-                    metadata.getRules().setPhaseName(PhaseMetadata.TRANSPORT_PHASE);
-                    handlers.add(metadata);
-                }
-                new PhaseHolder().buildTransportHandlerChain(phase, handlers);
-            } else {
-            }
+            phase_holder = axis2_phase_holder_create(env);
+            if(NULL == phase_holder)
+            {
+                if(handlers)
+                    AXIS2_ARRAY_LIST_FREE(handlers, env);
+                AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                return AXIS2_FAILURE;
+            }
+            
+            status = AXIS2_PHASE_HOLDER_BUILD_TRANSPORT_HANDLER_CHAIN(phase_holder, env, 
+                phase, handlers);
+            if(phase_holder)
+                AXIS2_PHASE_HOLDER_FREE(phase_holder, env);
+        } else 
+        {
         }
     }
+    if(handlers)
+        AXIS2_ARRAY_LIST_FREE(handlers, env);
+    return status;
+}
 
-
-    /**
-     * Method buildTransportChains
-     *
-     * @param transport
-     * @throws PhaseException
-     */
-    private void buildOutTransportChains(TransportOutDescription transport)
-            throws PhaseException {
-        Flow flow = null;
-        Phase phase = null;
-        for (int type = 1; type < 5; type++) {
-            switch (type) {
-                case PhaseMetadata.OUT_FLOW:
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_build_out_transport_chains(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_transport_out_desc *transport)
+{
+    struct axis2_flow *flow = NULL;
+    struct axis2_phase *phase = NULL;
+    int type = 0;
+    int j = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+    axis2_array_list_t *handlers = NULL;
+    struct axis2_handler_desc *metadata = NULL;
+    struct axis2_phase_holder *phase_holder = NULL;
+        
+    for (type = 1; type < 5; type++) 
+    {
+        switch (type) {
+            case AXIS2_OUTFLOW:
+            {
+                flow = AXIS2_TRANSPORT_OUT_DESC_GET_OUTFLOW(transport, env);
+                phase = AXIS2_TRANSPORT_OUT_DESC_GET_OUTPHASE(transport, env);
+                break;
+            }
+            case AXIS2_FAULT_OUTFLOW:
+            {
+                flow = AXIS2_TRANSPORT_OUT_DESC_GET_FAULTFLOW(transport, env);
+                phase = AXIS2_TRANSPORT_OUT_DESC_GET_FAULTPHASE(transport, env);
+                break;
+            }
+        }
+        
+        if (NULL != flow) 
+        {
+            handlers = axis2_array_list_create(env, 0);
+            for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+            {
+                metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+                status = AXIS2_PHASE_RULE_SET_NAME(AXIS2_HANDLER_DESC_GET_RULES(metadata,
+                    env), env, AXIS2_TRANSPORT_PHASE);
+                
+                if(AXIS2_FAILURE == status)
                 {
-                    flow = transport.getOutFlow();
-                    phase = transport.getOutPhase();
-                    break;
-                }
-                case PhaseMetadata.FAULT_OUT_FLOW:
+                    if(handlers)
+                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                    return status;
+                }
+                
+                status = AXIS2_ARRAY_LIST_ADD(handlers, env, metadata);
+                if(AXIS2_FAILURE == status)
                 {
-                    flow = transport.getFaultFlow();
-                    phase = transport.getFaultPhase();
-                    break;
-                }
-            }
-            if (flow != null) {
-                ArrayList handlers = new ArrayList();
-                for (int j = 0; j < flow.getHandlerCount(); j++) {
-                    HandlerDescription metadata = flow.getHandler(j);
-                    metadata.getRules().setPhaseName(PhaseMetadata.TRANSPORT_PHASE);
-                    handlers.add(metadata);
+                    if(handlers)
+                        AXIS2_ARRAY_LIST_FREE(handlers, env);
+                    return status;
                 }
-                new PhaseHolder().buildTransportHandlerChain(phase, handlers);
-            } else {
             }
+            phase_holder = axis2_phase_holder_create(env);
+            if(NULL == phase_holder)
+            {
+                if(handlers)
+                    AXIS2_ARRAY_LIST_FREE(handlers, env);
+                AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                return AXIS2_FAILURE;
+            }
+            
+            status = AXIS2_PHASE_HOLDER_BUILD_TRANSPORT_HANDLER_CHAIN(phase_holder, env, 
+                phase, handlers);
+            if(phase_holder)
+                AXIS2_PHASE_HOLDER_FREE(phase_holder, env);
+        } else 
+        {
         }
     }
+    if(handlers)
+        AXIS2_ARRAY_LIST_FREE(handlers, env);
+    return status;
+}
 
 
-    public void engageModuleGlobally(ModuleDescription module) throws AxisFault {
-        enageToGlobalChain(module);
-        Iterator servicegroups = axisConfig.getServiceGroups();
-        while (servicegroups.hasNext()) {
-            AxisServiceGroup sericeGroup = (AxisServiceGroup) servicegroups.next();
-            Iterator services = sericeGroup.getServices();
-            while (services.hasNext()) {
-                AxisService axisService = (AxisService) services.next();
-                axisService.addModuleOperations(module, axisConfig);
-                engageModuleToServiceFromGlobal(axisService, module);
-                axisService.addToEngagModuleList(module);
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_globally(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_module_desc *module)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    axis2_hash_t *svc_grps = NULL;
+    axis2_hash_index_t *index_i = NULL;
+    axis2_hash_index_t *index_j = NULL;
+    void *v = NULL;
+    void *w = NULL;
+    struct axis2_svc_grp *svc_grp = NULL;
+    axis2_hash_t *svcs = NULL;
+    struct axis2_svc *svc = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+        
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    
+    status = axis2_phase_resolver_engage_to_global_chain(phase_resolver, env, module);
+    if(AXIS2_FAILURE == status)
+        return status;
+    svc_grps = AXIS2_ENGINE_CONFIG_GET_SVC_GRPS(resolver_impl->axis2_config, env);
+    index_i = axis2_hash_first (svc_grps, env);
+    do 
+    {
+        axis2_hash_this (index_i, NULL, NULL, &v);
+        svc_grp = (struct axis2_svc_grp *) v;
+        svcs = AXIS2_SVC_GRP_GET_SVCS(svc_grp, env);    
+        
+        index_j = axis2_hash_first (svcs, env);
+        do
+        {
+            axis2_hash_this (index_i, NULL, NULL, &w);
+            svc = (struct axis2_svc *) w;
+                
+            status = AXIS2_SVC_ADD_MODULE_OPERATIONS(svc, env, module, 
+                resolver_impl->axis2_config);
+            if(AXIS2_FAILURE == status)
+            {
+                return status;
             }
-            sericeGroup.addModule(module.getName());
-        }
-    }
-
-    /**
-     * To engage modules come form global
-     *
-     * @param service
-     * @param module
-     * @throws PhaseException
-     */
-    public void engageModuleToServiceFromGlobal(AxisService service,
-                                                ModuleDescription module) throws PhaseException {
-        HashMap opeartions = service.getOperations();
-        Collection opCol = opeartions.values();
-        boolean engaged = false;
-        for (Iterator iterator = opCol.iterator(); iterator.hasNext();) {
-            AxisOperation opDesc = (AxisOperation) iterator.next();
-            Collection modules = opDesc.getModules();
-            for (Iterator iterator1 = modules.iterator();
-                 iterator1.hasNext();) {
-                ModuleDescription description = (ModuleDescription) iterator1.next();
-                if (description.getName().equals(module.getName())) {
-                    engaged = true;
-                    break;
-                }
+            status = axis2_phase_resolver_engage_module_to_svc_from_global(
+                phase_resolver, env, svc, module);
+            
+            if(AXIS2_FAILURE == status)
+            {
+                return status;
             }
-            if (engaged) {
-                continue;
-            }
-            Flow flow = null;
-            for (int type = 1; type < 5; type++) {
-                switch (type) {
-                    case PhaseMetadata.IN_FLOW:
-                    {
-                        phaseHolder =
-                                new PhaseHolder(opDesc.getRemainingPhasesInFlow());
-                        break;
-                    }
-                    case PhaseMetadata.OUT_FLOW:
-                    {
-                        phaseHolder =
-                                new PhaseHolder(opDesc.getPhasesOutFlow());
-                        break;
-                    }
-                    case PhaseMetadata.FAULT_IN_FLOW:
-                    {
-                        phaseHolder =
-                                new PhaseHolder(opDesc.getPhasesInFaultFlow());
-                        break;
-                    }
-                    case PhaseMetadata.FAULT_OUT_FLOW:
-                    {
-                        phaseHolder =
-                                new PhaseHolder(opDesc.getPhasesOutFaultFlow());
-                        break;
-                    }
-                }
-                ////////////////////////////////////////////////////////////////////////////////////
-                /////////////////// Modules refered by axis2.xml //////////////////////////////////
-                ////////////////////////////////////////////////////////////////////////////////////
-                switch (type) {
-                    case PhaseMetadata.IN_FLOW:
-                    {
-                        flow = module.getInFlow();
-                        break;
-                    }
-                    case PhaseMetadata.OUT_FLOW:
-                    {
-                        flow = module.getOutFlow();
-                        break;
-                    }
-                    case PhaseMetadata.FAULT_IN_FLOW:
-                    {
-                        flow = module.getFaultInFlow();
-                        break;
-                    }
-                    case PhaseMetadata.FAULT_OUT_FLOW:
-                    {
-                        flow = module.getFaultOutFlow();
-                        break;
-                    }
-                }
-                if (flow != null) {
-                    for (int j = 0; j < flow.getHandlerCount(); j++) {
-                        HandlerDescription metadata = flow.getHandler(j);
-                        if (!PhaseValidator.isSystemPhases(metadata.getRules().getPhaseName())) {
-                            phaseHolder.addHandler(metadata);
-                        }
-                    }
-                }
+            
+            status = AXIS2_SVC_ADD_TO_ENGAGED_MODULE_LIST(svc, env, module);
+            if(AXIS2_FAILURE == status)
+            {
+                return status;
             }
-            opDesc.addToEngageModuleList(module);
+            index_j = axis2_hash_next (env, index_j);
+            
+        } while(NULL != index_j);
+        
+        axis2_qname_t *mod_name = AXIS2_MODULE_DESC_GET_NAME(module, env);
+        status = AXIS2_SVC_GRP_ADD_MODULE(svc_grp, env, 
+            mod_name);
+        
+        if(AXIS2_FAILURE == status)
+        {
+            return status;
         }
-    }
+        index_i = axis2_hash_next (env, index_i);
+           
+    } while(NULL != index_i);
+    
+    return status;
+}
 
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_svc_from_global(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_svc *svc,
+                                                struct axis2_module_desc *module_desc)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    axis2_hash_t *operations = NULL;
+    axis2_bool_t engaged = AXIS2_FALSE;
+    struct axis2_operation *op_desc = NULL;
+    struct axis2_module_desc *module_desc_l = NULL;
+    struct axis2_handler_desc *metadata = NULL;    
+    axis2_hash_index_t *index_i = NULL;
+    void *v = NULL;
+    axis2_array_list_t *modules = NULL;
+    int j = 0;
+    int type = 0;
+    struct axis2_flow *flow = NULL;
+    axis2_char_t *phase_name = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    
+    operations = AXIS2_SVC_GET_OPERATIONS(svc, env);
+    for (index_i = axis2_hash_first (operations, env); index_i; index_i = axis2_hash_next (env, index_i))
+    {
 
-    private void enageToGlobalChain(ModuleDescription module) throws PhaseException {
-        Flow flow = null;
-        for (int type = 1; type < 5; type++) {
+        axis2_hash_this (index_i, NULL, NULL, &v);
+        op_desc = (struct axis2_operation *) v;
+        modules = AXIS2_OPERATION_GET_MODULES(op_desc, env);
+        for(j = 0; j < AXIS2_ARRAY_LIST_SIZE(modules, env); j++)
+        {
+            module_desc_l = (struct axis2_module_desc *) 
+                AXIS2_ARRAY_LIST_GET(modules, env, j);
+            if(AXIS2_QNAME_EQUALS(AXIS2_MODULE_DESC_GET_NAME(module_desc_l, env),
+                env, AXIS2_MODULE_DESC_GET_NAME(module_desc, env)))
+            {
+                engaged = AXIS2_TRUE;
+                break;
+            }
+        }
+        if(AXIS2_TRUE == engaged)
+        {
+            continue;
+        }
+        for(type = 1; type < 5; type++)
+        {
             switch (type) {
-                case PhaseMetadata.IN_FLOW:
+                case AXIS2_INFLOW:
                 {
-                    phaseHolder =
-                            new PhaseHolder(axisConfig.
-                                    getInPhasesUptoAndIncludingPostDispatch());
+                    resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                        AXIS2_OPERATION_GET_REMAINING_PHASES_INFLOW(op_desc, env));
                     break;
                 }
-                case PhaseMetadata.OUT_FLOW:
+                case AXIS2_OUTFLOW:
                 {
-                    phaseHolder =
-                            new PhaseHolder(((AxisConfigurationImpl) axisConfig).getOutFlow());
+                    resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                        AXIS2_OPERATION_GET_PHASES_OUTFLOW(op_desc, env));
                     break;
                 }
-                case PhaseMetadata.FAULT_IN_FLOW:
+                case AXIS2_FAULT_INFLOW:
                 {
-                    phaseHolder =
-                            new PhaseHolder(axisConfig.getInFaultFlow());
+                    resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                        AXIS2_OPERATION_GET_PHASES_IN_FAULT_FLOW(op_desc, env));
                     break;
                 }
-                case PhaseMetadata.FAULT_OUT_FLOW:
+                case AXIS2_FAULT_OUTFLOW:
                 {
-                    phaseHolder =
-                            new PhaseHolder(((AxisConfigurationImpl) axisConfig).getOutFaultFlow());
+                    resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                        AXIS2_OPERATION_GET_PHASES_OUT_FAULT_FLOW(op_desc, env));
                     break;
                 }
             }
-            ////////////////////////////////////////////////////////////////////////////////////
-            /////////////////// Modules refered by axis2.xml //////////////////////////////////
-            ////////////////////////////////////////////////////////////////////////////////////
-            switch (type) {
-                case PhaseMetadata.IN_FLOW:
+            /******************************************************************/
+            /******************* Modules refered by axis2.xml *****************/
+            /******************************************************************/
+            switch (type) 
+            {
+                case AXIS2_INFLOW:
                 {
-                    flow = module.getInFlow();
+                    flow = AXIS2_MODULE_DESC_GET_INFLOW(module_desc, env);
                     break;
                 }
-                case PhaseMetadata.OUT_FLOW:
+                case AXIS2_OUTFLOW:
                 {
-                    flow = module.getOutFlow();
+                    flow = AXIS2_MODULE_DESC_GET_OUTFLOW(module_desc, env);
                     break;
                 }
-                case PhaseMetadata.FAULT_IN_FLOW:
+                case AXIS2_FAULT_INFLOW:
                 {
-                    flow = module.getFaultInFlow();
+                    flow = AXIS2_MODULE_DESC_GET_FAULT_INFLOW(module_desc, env);
                     break;
                 }
-                case PhaseMetadata.FAULT_OUT_FLOW:
+                case AXIS2_FAULT_OUTFLOW:
                 {
-                    flow = module.getFaultOutFlow();
+                    flow = AXIS2_MODULE_DESC_GET_FAULT_OUTFLOW(module_desc, env);
                     break;
                 }
             }
-            if (flow != null) {
-                for (int j = 0; j < flow.getHandlerCount(); j++) {
-                    HandlerDescription metadata = flow.getHandler(j);
-                    if (PhaseValidator.isSystemPhases(metadata.getRules().getPhaseName())) {
-                        phaseHolder.addHandler(metadata);
-                    } else {
-                        /**
-                         * These handlers will go to operation's handler chains , since the module
-                         * try to add handlres to both sytem predefined phases and user defined phase
-                         * so global module can do that. here the global module are the module which are
-                         * reffred by axis2.xml
-                         */
+            if (NULL != flow) 
+            {
+                for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+                {
+                    metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+                    phase_name = AXIS2_PHASE_RULE_GET_NAME(
+                        AXIS2_HANDLER_DESC_GET_RULES(metadata, env), env);
+                    if ((0 != AXIS2_STRCMP(AXIS2_PHASE_TRANSPORTIN, phase_name)) &&
+                        (0 != AXIS2_STRCMP(AXIS2_PHASE_DISPATCH, phase_name)) &&
+                        (0 != AXIS2_STRCMP(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
+                        (0 != AXIS2_STRCMP(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                    {
+                        status = AXIS2_PHASE_HOLDER_ADD_HANDLER(resolver_impl->phase_holder,
+                            env, metadata);
+                        if(AXIS2_FAILURE == status)
+                        {
+                            return status;
+                        }
                     }
                 }
             }
         }
+        status = AXIS2_OPERATION_ADD_TO_ENGAGE_MODULE_LIST(op_desc, env, module_desc);
     }
+    
+    return status;
+}
 
 
-    public void engageModuleToService(AxisService service,
-                                      ModuleDescription module) throws AxisFault {
-        HashMap opeartions = service.getOperations();
-        Collection opCol = opeartions.values();
-        boolean engaged = false;
-        service.addModuleOperations(module, axisConfig);
-        for (Iterator iterator = opCol.iterator(); iterator.hasNext();) {
-            AxisOperation opDesc = (AxisOperation) iterator.next();
-            Collection modules = opDesc.getModules();
-            for (Iterator iterator1 = modules.iterator();
-                 iterator1.hasNext();) {
-                ModuleDescription description = (ModuleDescription) iterator1.next();
-                if (description.getName().equals(module.getName())) {
-                    engaged = true;
-                    break;
+static axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_to_global_chain(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_module_desc *module_desc)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    struct axis2_flow *flow = NULL;
+    int type = 0;
+    int j = 0;
+    struct axis2_handler_desc *metadata = NULL;
+    axis2_char_t *phase_name = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    
+    for (type = 1; type < 5; type++) 
+    {
+        switch (type) 
+        {
+            case AXIS2_INFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_ENGINE_CONFIG_GET_IN_PHASES_UPTO_AND_INCLUDING_POST_DISPATCH(
+                        resolver_impl->axis2_config, env));
+                break;
+            }
+            case AXIS2_OUTFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_ENGINE_CONFIG_GET_OUTFLOW(resolver_impl->axis2_config,
+                        env));
+                break;
+            }
+            case AXIS2_FAULT_INFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_ENGINE_CONFIG_GET_IN_FAULT_FLOW(resolver_impl->axis2_config,
+                        env));
+                break;
+            }
+            case AXIS2_FAULT_OUTFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_ENGINE_CONFIG_GET_OUT_FAULT_FLOW(resolver_impl->axis2_config,
+                        env));
+                break;
+            }
+        }
+        /**********************************************************************/
+        /****************** Modules refered by axis2.xml **********************/
+        /**********************************************************************/
+        switch (type) 
+        {
+            case AXIS2_INFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_INFLOW(module_desc, env);
+                break;
+            }
+            case AXIS2_OUTFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_OUTFLOW(module_desc, env);
+                break;
+            }
+            case AXIS2_FAULT_INFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_FAULT_INFLOW(module_desc, env);
+                break;
+            }
+            case AXIS2_FAULT_OUTFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_FAULT_OUTFLOW(module_desc, env);
+                break;
+            }
+        }
+        if (NULL != flow) 
+        {
+            for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+            {
+                metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+                phase_name = AXIS2_PHASE_RULE_GET_NAME(
+                        AXIS2_HANDLER_DESC_GET_RULES(metadata, env), env);
+                if ((0 != AXIS2_STRCMP(AXIS2_PHASE_TRANSPORTIN, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
+                {
+                    status = AXIS2_PHASE_HOLDER_ADD_HANDLER(resolver_impl->phase_holder,
+                        env, metadata);
+          
+                } else 
+                {
+                    /**
+                     * These handlers will go to operation's handler chains , since the module
+                     * try to add handlres to both sytem predefined phases and user defined phase
+                     * so global module can do that. here the global module are the module which are
+                     * reffred by axis2.xml
+                     */
                 }
             }
-            if (!engaged) {
-                engageModuleToOperation(opDesc, module);
-                opDesc.addToEngageModuleList(module);
+        }
+    }
+    
+    return status;
+}
+
+
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_svc(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_svc *svc,
+                                                struct axis2_module_desc *module_desc)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    axis2_hash_t *operations = NULL;
+    axis2_bool_t engaged = AXIS2_FALSE;
+    struct axis2_operation *op_desc = NULL;
+    axis2_array_list_t *modules = NULL;
+    struct axis2_module_desc *module_desc_l = NULL;
+    axis2_hash_index_t *index_i = NULL;
+    void *v = NULL;
+    int j = 0;
+    axis2_status_t status = AXIS2_FAILURE;
+        
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    
+    operations = AXIS2_SVC_GET_OPERATIONS(resolver_impl->svc, env);
+    AXIS2_SVC_ADD_MODULE_OPERATIONS(resolver_impl->svc, env, module_desc, 
+        resolver_impl->axis2_config);
+    for (index_i = axis2_hash_first (operations, env); index_i; index_i = axis2_hash_next (env, index_i))
+    {
+
+        axis2_hash_this (index_i, NULL, NULL, &v);
+        op_desc = (struct axis2_operation *) v;
+        modules = AXIS2_OPERATION_GET_MODULES(op_desc, env);
+        for(j = 0; j < AXIS2_ARRAY_LIST_SIZE(modules, env); j++)
+        {
+            module_desc_l = AXIS2_ARRAY_LIST_GET(modules, env, j);
+            if(0 == AXIS2_QNAME_EQUALS(AXIS2_MODULE_DESC_GET_NAME(module_desc, env),
+                    env, AXIS2_MODULE_DESC_GET_NAME(module_desc_l, env)))
+            {
+                engaged = AXIS2_TRUE;
+                break;
+            }
+            if(AXIS2_FALSE == engaged)
+            {
+                status = axis2_phase_resolver_engage_module_to_operation(phase_resolver, 
+                    env, op_desc, module_desc);
+                if(AXIS2_FAILURE == status)
+                    return status;
+                
+                status = AXIS2_OPERATION_ADD_TO_ENGAGE_MODULE_LIST(op_desc, env, module_desc);
             }
         }
+
     }
+    return status;
+}
 
 
-    public void engageModuleToOperation(AxisOperation axisOperation,
-                                        ModuleDescription module) throws PhaseException {
-        Flow flow = null;
-        for (int type = 1; type < 5; type++) {
-            switch (type) {
-                case PhaseMetadata.IN_FLOW:
-                {
-                    phaseHolder =
-                            new PhaseHolder(axisOperation.getRemainingPhasesInFlow());
-                    break;
-                }
-                case PhaseMetadata.OUT_FLOW:
-                {
-                    phaseHolder =
-                            new PhaseHolder(axisOperation.getPhasesOutFlow());
-                    break;
-                }
-                case PhaseMetadata.FAULT_IN_FLOW:
-                {
-                    phaseHolder =
-                            new PhaseHolder(axisOperation.getPhasesInFaultFlow());
-                    break;
-                }
-                case PhaseMetadata.FAULT_OUT_FLOW:
-                {
-                    phaseHolder =
-                            new PhaseHolder(axisOperation.getPhasesOutFaultFlow());
-                    break;
-                }
+axis2_status_t AXIS2_CALL
+axis2_phase_resolver_engage_module_to_operation(axis2_phase_resolver_t *phase_resolver,
+                                                axis2_env_t **env,
+                                                struct axis2_operation *axis_operation,
+                                                struct axis2_module_desc *module_desc)
+{
+    axis2_phase_resolver_impl_t *resolver_impl = NULL;
+    struct axis2_flow *flow = NULL;
+    int type = 0;
+    int j = 0;
+    struct axis2_handler_desc *metadata = NULL;
+    axis2_status_t status = AXIS2_FALSE;
+    axis2_char_t *phase_name = NULL;
+    
+    resolver_impl = AXIS2_INTF_TO_IMPL(phase_resolver);
+    
+    for (type = 1; type < 5; type++) 
+    {
+        switch (type) {
+            case AXIS2_INFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env, 
+                    AXIS2_OPERATION_GET_REMAINING_PHASES_INFLOW(axis_operation, env));
+                break;
             }
+            case AXIS2_OUTFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_OPERATION_GET_PHASES_OUTFLOW(axis_operation, env));
+                break;
+            }
+            case AXIS2_FAULT_INFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_OPERATION_GET_PHASES_IN_FAULT_FLOW(axis_operation, env));
+                break;
+            }
+            case AXIS2_FAULT_OUTFLOW:
+            {
+                resolver_impl->phase_holder = axis2_phase_holder_create_with_phases(env,
+                    AXIS2_OPERATION_GET_PHASES_OUT_FAULT_FLOW(axis_operation, env));
+                break;
+            }
+        }
 
-            switch (type) {
-                case PhaseMetadata.IN_FLOW:
-                {
-                    flow = module.getInFlow();
-                    break;
-                }
-                case PhaseMetadata.OUT_FLOW:
-                {
-                    flow = module.getOutFlow();
-                    break;
-                }
-                case PhaseMetadata.FAULT_IN_FLOW:
+        switch (type) {
+            case AXIS2_INFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_INFLOW(module_desc, env);
+                break;
+            }
+            case AXIS2_OUTFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_OUTFLOW(module_desc, env);
+                break;
+            }
+            case AXIS2_FAULT_INFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_FAULT_INFLOW(module_desc, env);
+                break;
+            }
+            case AXIS2_FAULT_OUTFLOW:
+            {
+                flow = AXIS2_MODULE_DESC_GET_FAULT_OUTFLOW(module_desc, env);
+                break;
+            }
+        }
+        if (NULL != flow) {
+            for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++) 
+            {
+                metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+                phase_name = AXIS2_PHASE_RULE_GET_NAME(
+                        AXIS2_HANDLER_DESC_GET_RULES(metadata, env), env);
+                if ((0 != AXIS2_STRCMP(AXIS2_PHASE_TRANSPORTIN, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_POST_DISPATCH, phase_name)) &&
+                    (0 != AXIS2_STRCMP(AXIS2_PHASE_PRE_DISPATCH, phase_name)))
                 {
-                    flow = module.getFaultInFlow();
-                    break;
-                }
-                case PhaseMetadata.FAULT_OUT_FLOW:
+                    status = AXIS2_PHASE_HOLDER_ADD_HANDLER(resolver_impl->phase_holder,
+                        env, metadata);
+           
+                } else 
                 {
-                    flow = module.getFaultOutFlow();
-                    break;
-                }
-            }
-            if (flow != null) {
-                for (int j = 0; j < flow.getHandlerCount(); j++) {
-                    HandlerDescription metadata = flow.getHandler(j);
-                    if (!PhaseValidator.isSystemPhases(metadata.getRules().getPhaseName())) {
-                        phaseHolder.addHandler(metadata);
-                    } else {
-                        throw new PhaseException(Messages.getMessage(DeploymentErrorMsgs.SERVICE_MODULE_CAN_NOT_REFER_GLOBAL_PHASE,
-                                metadata.getRules().getPhaseName()));
-                    }
+                    AXIS2_ERROR_SET((*env)->error, 
+                        SERVICE_MODULE_CAN_NOT_REFER_GLOBAL_PHASE, AXIS2_FAILURE);
+                    
                 }
             }
         }
     }
+    return status;
 }

Modified: webservices/axis2/trunk/c/modules/core/transport/axis2_transport_listener.h
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/transport/axis2_transport_listener.h?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/axis2_transport_listener.h (original)
+++ webservices/axis2/trunk/c/modules/core/transport/axis2_transport_listener.h Thu Dec  1 21:13:39 2005
@@ -28,9 +28,9 @@
 #include <axis2_env.h>
 #include <axis2_allocator.h>
 /*#include <axis2_endpoint_ref.h>*/
-#include <axis2_engine_config.h>
+#include <axis2_ctx.h>
 
-#include <wsdl.h>
+#include <axis2_wsdl.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -38,6 +38,7 @@
 #endif
 
 struct axis2_transport_listener;
+struct axis2_ctx;    
 typedef struct axis2_transport_listener axis2_transport_listener_t;
 typedef struct axis2_transport_listener_ops axis2_transport_listener_ops_t;
 

Modified: webservices/axis2/trunk/c/modules/test/om/src/test_om.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/test/om/src/test_om.c?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/test/om/src/test_om.c (original)
+++ webservices/axis2/trunk/c/modules/test/om/src/test_om.c Thu Dec  1 21:13:39 2005
@@ -272,3 +272,4 @@
     
     return 0;
  }
+

Modified: webservices/axis2/trunk/c/modules/wsdl/src/Makefile.am
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/wsdl/src/Makefile.am?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/wsdl/src/Makefile.am (original)
+++ webservices/axis2/trunk/c/modules/wsdl/src/Makefile.am Thu Dec  1 21:13:39 2005
@@ -21,4 +21,5 @@
 INCLUDES = -I$(top_builddir)/include \
             -I${CUTEST_HOME}/include \
             -I$(top_builddir)/modules/util/src \
-            -I$(top_builddir)/modules/core/description/src
+            -I$(top_builddir)/modules/core/description/src \
+            -I$(top_builddir)/modules/core/transport

Modified: webservices/axis2/trunk/c/modules/wsdl/src/Makefile.in
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/wsdl/src/Makefile.in?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/wsdl/src/Makefile.in (original)
+++ webservices/axis2/trunk/c/modules/wsdl/src/Makefile.in Thu Dec  1 21:13:39 2005
@@ -216,7 +216,8 @@
 INCLUDES = -I$(top_builddir)/include \
             -I${CUTEST_HOME}/include \
             -I$(top_builddir)/modules/util/src \
-            -I$(top_builddir)/modules/core/description/src
+            -I$(top_builddir)/modules/core/description/src \
+            -I$(top_builddir)/modules/core/transport
 
 all: all-am
 

Modified: webservices/axis2/trunk/c/modules/wsdl/src/wsdl.h
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/wsdl/src/wsdl.h?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/wsdl/src/wsdl.h (original)
+++ webservices/axis2/trunk/c/modules/wsdl/src/wsdl.h Thu Dec  1 21:13:39 2005
@@ -18,7 +18,7 @@
 #define AXIS2_WSDL_H
 
 /**
- * @file axis2_description.h
+ * @file axis2_axis2_description.h
  * @brief axis2 DESCRIPTION
  */
  

Modified: webservices/axis2/trunk/c/modules/wsdl/src/wsdl_binding_operation.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/wsdl/src/wsdl_binding_operation.c?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/wsdl/src/wsdl_binding_operation.c (original)
+++ webservices/axis2/trunk/c/modules/wsdl/src/wsdl_binding_operation.c Thu Dec  1 21:13:39 2005
@@ -27,7 +27,7 @@
     /**
      * Field operation
      */
-    axis2_wsdl_operation_t *operation;
+    void *operation;
 
     /**
      * Field input
@@ -59,14 +59,14 @@
                                         axis2_env_t **env,
                                         struct axis2_wsdl_binding_msg_ref *input);
 
-axis2_wsdl_operation_t *AXIS2_CALL
+void *AXIS2_CALL
 axis2_wsdl_binding_operation_get_operation(axis2_wsdl_binding_operation_t *binding_operation,
                                     axis2_env_t **env);
 
 axis2_status_t AXIS2_CALL
 axis2_wsdl_binding_operation_set_operation(axis2_wsdl_binding_operation_t *binding_operation,
                                             axis2_env_t **env,
-                                            axis2_wsdl_operation_t *operation);
+                                            void *operation);
 
 struct axis2_wsdl_binding_msg_ref * AXIS2_CALL
 axis2_wsdl_binding_operation_get_output(axis2_wsdl_binding_operation_t *binding_operation,
@@ -130,6 +130,11 @@
 	{
 		AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
 	}
+    
+    binding_operation_impl->qname = NULL;
+    binding_operation_impl->operation = NULL;
+    binding_operation_impl->input = NULL;
+    binding_operation_impl->output = NULL;
 	
     binding_operation_impl->infaults = axis2_linked_list_create (env);
     
@@ -216,12 +221,6 @@
     binding_operation_impl->binding_operation.ops->set_outfaults =
         axis2_wsdl_binding_operation_set_outfaults; 
     
-    
-	binding_operation_impl->qname = NULL;
-    binding_operation_impl->operation = NULL;
-    binding_operation_impl->input = NULL;
-    binding_operation_impl->output = NULL;
-	
 	return &(binding_operation_impl->binding_operation);
 }
 
@@ -231,33 +230,25 @@
 axis2_wsdl_binding_operation_free (axis2_wsdl_binding_operation_t *binding_operation, 
                             axis2_env_t **env)
 {
+    axis2_wsdl_binding_operation_impl_t *binding_operation_impl = NULL;
     AXIS2_FUNC_PARAM_CHECK(binding_operation, env, AXIS2_FAILURE);
-	if(NULL != binding_operation->ops)
-        AXIS2_FREE((*env)->allocator, binding_operation->ops);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(binding_operation)->qname)
-       AXIS2_QNAME_FREE(AXIS2_INTF_TO_IMPL(binding_operation)->qname, env);
+    binding_operation_impl = AXIS2_INTF_TO_IMPL(binding_operation);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(binding_operation)->infaults)
-       AXIS2_LINKED_LIST_FREE(AXIS2_INTF_TO_IMPL(binding_operation)->infaults, env);
-    
-    if(NULL != AXIS2_INTF_TO_IMPL(binding_operation)->outfaults)
-       AXIS2_LINKED_LIST_FREE(AXIS2_INTF_TO_IMPL(binding_operation)->outfaults, env);
+	if(NULL != binding_operation->ops)
+        AXIS2_FREE((*env)->allocator, binding_operation->ops);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(binding_operation)->operation)
-       AXIS2_WSDL_OPERATION_FREE(AXIS2_INTF_TO_IMPL(binding_operation)->operation, env);
+    if(NULL != binding_operation_impl->infaults)
+       AXIS2_LINKED_LIST_FREE(binding_operation_impl->infaults, env);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(binding_operation)->input)
-       AXIS2_WSDL_BINDING_MSG_REF_FREE(AXIS2_INTF_TO_IMPL(binding_operation)->input, env);
+    if(NULL != binding_operation_impl->outfaults)
+       AXIS2_LINKED_LIST_FREE(binding_operation_impl->outfaults, env);
     
     if(NULL != binding_operation->extensible_component)
         AXIS2_WSDL_EXTENSIBLE_COMPONENT_FREE(binding_operation->
             extensible_component, env);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(binding_operation)->output)
-       AXIS2_WSDL_BINDING_MSG_REF_FREE(AXIS2_INTF_TO_IMPL(binding_operation)->output, env);
-    
-    AXIS2_FREE((*env)->allocator, AXIS2_INTF_TO_IMPL(binding_operation));
+    AXIS2_FREE((*env)->allocator, binding_operation_impl);
     
 	return AXIS2_SUCCESS;
 }
@@ -281,7 +272,7 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_wsdl_operation_t *AXIS2_CALL
+void *AXIS2_CALL
 axis2_wsdl_binding_operation_get_operation(axis2_wsdl_binding_operation_t *binding_operation,
                                     axis2_env_t **env) 
 {
@@ -292,11 +283,22 @@
 axis2_status_t AXIS2_CALL
 axis2_wsdl_binding_operation_set_operation(axis2_wsdl_binding_operation_t *binding_operation,
                                             axis2_env_t **env,
-                                            axis2_wsdl_operation_t *operation) 
+                                            void *operation) 
 {
+    struct axis2_operation *ops = NULL;
+    axis2_wsdl_binding_operation_impl_t *binding_operation_impl = NULL;
     AXIS2_FUNC_PARAM_CHECK(binding_operation, env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, operation, AXIS2_FAILURE);
-    AXIS2_INTF_TO_IMPL(binding_operation)->operation = operation;
+    
+    binding_operation_impl = AXIS2_INTF_TO_IMPL(binding_operation);
+    
+    if(NULL != binding_operation_impl->operation)
+    {
+        ops = (struct axis2_operation *) (binding_operation_impl->operation);
+        AXIS2_OPERATION_FREE(ops, env);
+        binding_operation_impl->operation = NULL;
+    }
+    binding_operation_impl->operation = operation;
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/modules/wsdl/src/wsdl_component.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/wsdl/src/wsdl_component.c?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/wsdl/src/wsdl_component.c (original)
+++ webservices/axis2/trunk/c/modules/wsdl/src/wsdl_component.c Thu Dec  1 21:13:39 2005
@@ -9,6 +9,17 @@
 {
 	axis2_wsdl_component_t wsdl_component;
 	axis2_hash_t *component_properties;
+    /**
+     * Field Namespace Qualified elements that can be sticked in the component.
+     */
+    axis2_linked_list_t *elements;
+    
+    /**
+     * Field Namespace Qualified attrebutes that can be sticked int eh
+     * component.
+     */
+    axis2_linked_list_t *attributes;
+    
 } axis2_wsdl_component_impl_t;
 
 #define AXIS2_INTF_TO_IMPL(wsdl_component) \
@@ -43,7 +54,18 @@
 		                                axis2_wsdl_component_t *wsdl_component,
                                         axis2_env_t **env,
                                         const void *key);
-		
+
+
+                                        
+axis2_status_t AXIS2_CALL
+axis2_wsdl_component_add_extensibility_element(axis2_wsdl_component_t *wsdl_component,
+                                                axis2_env_t **env,
+                                                void *element);
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_wsdl_component_get_extensibility_elements(axis2_wsdl_component_t *wsdl_component,
+                                                axis2_env_t **env);
+                                                
 /***************************** End of function headers ************************/
 
 axis2_wsdl_component_t * AXIS2_CALL 
@@ -51,41 +73,56 @@
 {
     AXIS2_ENV_CHECK(env, NULL);
     
-	axis2_wsdl_component_impl_t *wsdl_impl_component = 
+	axis2_wsdl_component_impl_t *wsdl_component_impl = 
         (axis2_wsdl_component_impl_t *) AXIS2_MALLOC ((*env)->allocator, 
         sizeof(axis2_wsdl_component_impl_t));
     
-	if(NULL == wsdl_impl_component)
+	if(NULL == wsdl_component_impl)
 	{
 		AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);
 	}
+    
+    wsdl_component_impl->component_properties = NULL;
+    wsdl_component_impl->elements = NULL;
+    wsdl_component_impl->attributes = NULL;
 	
-	wsdl_impl_component->wsdl_component.ops = (axis2_wsdl_component_ops_t *)
+    wsdl_component_impl->component_properties = axis2_hash_make (env);
+    if(NULL == wsdl_component_impl->component_properties)
+    {
+        AXIS2_FREE ((*env)->allocator, wsdl_component_impl);
+		AXIS2_ERROR_SET ((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);   
+    }
+    
+	wsdl_component_impl->wsdl_component.ops = (axis2_wsdl_component_ops_t *)
 		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_wsdl_component_ops_t));
     
-	if(NULL == wsdl_impl_component->wsdl_component.ops)
+	if(NULL == wsdl_component_impl->wsdl_component.ops)
 	{
-		AXIS2_FREE ((*env)->allocator, wsdl_impl_component);
+		AXIS2_FREE ((*env)->allocator, wsdl_component_impl);
 		AXIS2_ERROR_SET ((*env)->error, AXIS2_ERROR_NO_MEMORY, NULL);	
 	}
     
-	wsdl_impl_component->wsdl_component.ops->free = axis2_wsdl_component_free;
+	wsdl_component_impl->wsdl_component.ops->free = axis2_wsdl_component_free;
     
-	wsdl_impl_component->wsdl_component.ops->set_component_properties =
+	wsdl_component_impl->wsdl_component.ops->set_component_properties =
         axis2_wsdl_component_set_component_properties;
     
-    wsdl_impl_component->wsdl_component.ops->get_component_properties =
+    wsdl_component_impl->wsdl_component.ops->get_component_properties =
         axis2_wsdl_component_get_component_properties;
     
-    wsdl_impl_component->wsdl_component.ops->set_component_property =
+    wsdl_component_impl->wsdl_component.ops->set_component_property =
         axis2_wsdl_component_set_component_property;
     
-    wsdl_impl_component->wsdl_component.ops->get_component_property =
+    wsdl_component_impl->wsdl_component.ops->get_component_property =
         axis2_wsdl_component_get_component_property;
     
-	wsdl_impl_component->component_properties = axis2_hash_make (env);
+    wsdl_component_impl->wsdl_component.ops->add_extensibility_element = 
+            axis2_wsdl_component_add_extensibility_element;
+    
+    wsdl_component_impl->wsdl_component.ops->get_extensibility_elements = 
+            axis2_wsdl_component_get_extensibility_elements;
 	
-	return &(wsdl_impl_component->wsdl_component);
+	return &(wsdl_component_impl->wsdl_component);
 }
 
 /******************************************************************************/
@@ -94,15 +131,23 @@
 axis2_wsdl_component_free (axis2_wsdl_component_t *wsdl_component, 
                             axis2_env_t **env)
 {
+    axis2_wsdl_component_impl_t *component_impl = NULL;
     AXIS2_FUNC_PARAM_CHECK(wsdl_component, env, AXIS2_FAILURE);
+    component_impl = AXIS2_INTF_TO_IMPL(wsdl_component);
+    
 	if(NULL != wsdl_component->ops)
         AXIS2_FREE((*env)->allocator, wsdl_component->ops);
     
-    if(NULL != AXIS2_INTF_TO_IMPL(wsdl_component)->component_properties)
-        axis2_hash_free(AXIS2_INTF_TO_IMPL(wsdl_component)->
-            component_properties, env);
+    if(NULL != component_impl->component_properties)
+        axis2_hash_free(component_impl->component_properties, env);
     
-    AXIS2_FREE((*env)->allocator, AXIS2_INTF_TO_IMPL(wsdl_component));
+    if(NULL != component_impl->attributes)
+        AXIS2_LINKED_LIST_FREE(component_impl->attributes, env);
+    
+    if(NULL != component_impl->elements)
+        AXIS2_LINKED_LIST_FREE(component_impl->elements, env);
+    
+    AXIS2_FREE((*env)->allocator, component_impl);
     
 	return AXIS2_SUCCESS;
 }
@@ -158,3 +203,77 @@
 	return (void *)(axis2_hash_get (AXIS2_INTF_TO_IMPL(wsdl_component)->
         component_properties, key, sizeof(key)));
 }
+
+axis2_status_t AXIS2_CALL
+axis2_wsdl_component_add_extensibility_element(axis2_wsdl_component_t *wsdl_component,
+                                                axis2_env_t **env,
+                                                void *element) 
+{
+    axis2_wsdl_component_impl_t *component_impl = NULL;
+    
+    AXIS2_FUNC_PARAM_CHECK(wsdl_component, env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, element, AXIS2_FAILURE);
+    component_impl = AXIS2_INTF_TO_IMPL(wsdl_component);
+    
+    if (NULL == component_impl->elements) 
+    {
+        component_impl->elements = axis2_linked_list_create(env);
+    }
+    
+    return AXIS2_LINKED_LIST_ADD(component_impl->elements, env, element);
+}
+
+axis2_linked_list_t *AXIS2_CALL
+axis2_wsdl_component_get_extensibility_elements(axis2_wsdl_component_t *wsdl_component,
+                                                axis2_env_t **env) 
+{
+    axis2_wsdl_component_impl_t *component_impl = NULL;
+    
+    AXIS2_FUNC_PARAM_CHECK(wsdl_component, env, NULL);
+    component_impl = AXIS2_INTF_TO_IMPL(wsdl_component);
+    
+    if (NULL == component_impl->elements) 
+    {
+        component_impl->elements = axis2_linked_list_create(env);
+    }
+    return component_impl->elements;
+}
+
+/**
+ * Adds the <code>ExtensibilityAttribute</code> as a attrebute of this
+ * Component.
+ *
+ * @param attribute <code>ExtensibilityAttribute</code>
+ */
+/*axis2_status_t AXIS2_CALL
+axis2_wsdl_component_add_extensible_attributes(WSDLExtensibilityAttribute attribute) {
+    if (NULL == this.attributes) {
+        this.attributes = new LinkedList();
+    }
+    if (null == attribute)
+        return;
+    this.attributes.add(attribute);
+}
+*/
+
+/**
+ * Returns a <code>List</code> of ExtensibleAttributes of this component.
+ *
+ * @return <code>List</code>
+ */
+/*axis2_array_list_t *AXIS2_CALL
+axis2_wsdl_component_get_extensibility_attributes(axis2_wsdl_component_t *wsdl_component,
+                                                    axis2_env_t **env) 
+{
+    axis2_wsdl_component_impl_t *component_impl = NULL;
+    
+    AXIS2_FUNC_PARAM_CHECK(wsdl_component, env, NULL);
+    component_impl = AXIS2_INTF_TO_IMPL(wsdl_component);
+    
+    if (NULL == component_impl->attributes) 
+    {
+        component_impl->attributes = axis2_linked_list_create(env);
+    }
+    return component_impl->attributes;
+}
+*/

Modified: webservices/axis2/trunk/c/modules/wsdl/src/wsdl_interface.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/wsdl/src/wsdl_interface.c?rev=351594&r1=351593&r2=351594&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/wsdl/src/wsdl_interface.c (original)
+++ webservices/axis2/trunk/c/modules/wsdl/src/wsdl_interface.c Thu Dec  1 21:13:39 2005
@@ -75,8 +75,8 @@
 axis2_wsdl_interface_get_operations(axis2_wsdl_interface_t *wsdl_interface,
                                     axis2_env_t **env);
 
-struct axis2_operation *AXIS2_CALL
-axis2_interface_get_operation(axis2_wsdl_interface_t *wsdl_interface,
+void *AXIS2_CALL
+axis2_wsdl_interface_get_operation(axis2_wsdl_interface_t *wsdl_interface,
                                 axis2_env_t **env,
                                 axis2_char_t *nc_name);
 
@@ -111,7 +111,7 @@
 axis2_status_t AXIS2_CALL
 axis2_wsdl_interface_set_operation(axis2_wsdl_interface_t *wsdl_interface,
                                     axis2_env_t **env,
-                                    struct axis2_operation *operation);
+                                    void *operation);
 
 axis2_status_t AXIS2_CALL
 axis2_wsdl_interface_set_super_interfaces(axis2_wsdl_interface_t *wsdl_interface,
@@ -208,6 +208,9 @@
 	wsdl_interface_impl->wsdl_interface.ops->get_operations = 
         axis2_wsdl_interface_get_operations;
     
+    wsdl_interface_impl->wsdl_interface.ops->get_operation =
+        axis2_wsdl_interface_get_operation;
+    
 	wsdl_interface_impl->wsdl_interface.ops->get_super_interfaces = 
         axis2_wsdl_interface_get_super_interfaces;
   
@@ -325,8 +328,8 @@
     return AXIS2_INTF_TO_IMPL(wsdl_interface)->operations;
 }
 
-struct axis2_operation *AXIS2_CALL
-axis2_interface_get_operation(axis2_wsdl_interface_t *wsdl_interface,
+void *AXIS2_CALL
+axis2_wsdl_interface_get_operation(axis2_wsdl_interface_t *wsdl_interface,
                                 axis2_env_t **env,
                                 axis2_char_t *nc_name) 
 {
@@ -387,17 +390,19 @@
 axis2_status_t AXIS2_CALL
 axis2_wsdl_interface_set_operation(axis2_wsdl_interface_t *wsdl_interface,
                                     axis2_env_t **env,
-                                    struct axis2_operation *operation) 
+                                    void *operation) 
 {
-    
-    if (NULL == AXIS2_WSDL_OPERATION_GET_NAME(operation->wsdl_operation, env)) 
+    struct axis2_operation *operation_l = NULL;
+    operation_l = (struct axis2_operation *) operation;
+    if (NULL == AXIS2_WSDL_OPERATION_GET_NAME(operation_l->wsdl_operation, env)) 
     {
         /* The Operation name cannot be null (required) */
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_WSDL_OPERATION, 
             AXIS2_FAILURE);
+        return AXIS2_FAILURE;
     }
     axis2_char_t *op_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_WSDL_OPERATION_GET_NAME(
-        operation->wsdl_operation, env), env);
+        operation_l->wsdl_operation, env), env);
     axis2_hash_set(AXIS2_INTF_TO_IMPL(wsdl_interface)->operations, op_name,  
         AXIS2_HASH_KEY_STRING, operation);
     



Mime
View raw message