| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef AXIS2_PHASE_RESOLVER_H |
| #define AXIS2_PHASE_RESOLVER_H |
| |
| /** |
| * @defgroup axis2_phase_resolver phase resolver |
| * @ingroup axis2 |
| * @{ |
| * @} |
| */ |
| |
| /** |
| * @defgroup axis2_phase_res phase resolver |
| * @ingroup axis2_phase_resolver |
| * holds phase information in relation to a given service. Encapsulates a |
| * reference to axis configuration, the service the phase resolver related to |
| * and a phase holder instance that holds the list of phases. |
| * @{ |
| */ |
| |
| /** |
| * @file axis2_phase_resolver.h |
| */ |
| |
| #include <axis2_const.h> |
| #include <axis2_error.h> |
| #include <axis2_defines.h> |
| #include <axis2_env.h> |
| #include <axis2_allocator.h> |
| #include <axis2_qname.h> |
| #include <axis2_array_list.h> |
| #include <axis2_hash.h> |
| #include <axis2_handler_desc.h> |
| #include <axis2_phase.h> |
| #include <axis2_phase_rule.h> |
| #include <axis2_handler.h> |
| #include <axis2_handler_desc.h> |
| #include <axis2_flow.h> |
| #include <axis2_module_desc.h> |
| #include <axis2_phase_holder.h> |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| /** Type name for axis2_phase_resolver */ |
| typedef struct axis2_phase_resolver axis2_phase_resolver_t; |
| /** Type name for axis2_phase_resolver_ops */ |
| typedef struct axis2_phase_resolver_ops axis2_phase_resolver_ops_t; |
| |
| struct axis2_phase; |
| struct axis2_handler_desc; |
| struct axis2_module_desc; |
| struct axis2_handler; |
| struct axis2_phase_rule; |
| struct axis2_svc; |
| struct axis2_conf; |
| struct axis2_op; |
| struct axis2_phase_holder; |
| |
| /** |
| * phase resolver ops struct. |
| * Encapsulator struct for ops of axis2_phase_resolver. |
| */ |
| struct axis2_phase_resolver_ops |
| { |
| /** |
| * Frees phase resolver. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| free)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env); |
| |
| /** |
| * Builds the execution chains. Execution chains are collection of |
| * phases that are invoked in the execution path. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| build_chains)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env); |
| |
| /** |
| * Builds execution chains for given operation. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @param op pointer to operation |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| build_module_op)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env, |
| struct axis2_op *op); |
| |
| /** |
| * Builds transport chains. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| build_transport_chains)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env); |
| |
| |
| /** |
| * Engages the given module globally. Engaging a module globally means |
| * that the given module would be engaged to all operations in all |
| * services. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @param module pointer to module |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| engage_module_globally)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env, |
| struct axis2_module_desc *module); |
| |
| /** |
| * Engages the given global module to the given service. This means |
| * the given module would be engaged to all operations of the given |
| * service. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @param svc pointer to service |
| * @param module_desc pointer to module description |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| engage_module_to_svc_from_global)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env, |
| struct axis2_svc *svc, |
| struct axis2_module_desc *module_desc); |
| |
| /** |
| * Engages the given module to the given service. This means |
| * the given module would be engaged to all operations of the given |
| * service. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @param svc pointer to service |
| * @param module_desc pointer to module description |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| engage_module_to_svc)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env, |
| struct axis2_svc *svc, |
| struct axis2_module_desc *module_desc); |
| |
| /** |
| * Engages the given module to the given operation. |
| * @param phase_resolver pointer to phase resolver |
| * @param env pointer to environment struct |
| * @param axis_op pointer to axis operation |
| * @param pointer to module description |
| * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE |
| */ |
| axis2_status_t (AXIS2_CALL * |
| engage_module_to_op)( |
| axis2_phase_resolver_t *phase_resolver, |
| const axis2_env_t *env, |
| struct axis2_op *axis_op, |
| struct axis2_module_desc *module_desc); |
| |
| |
| }; |
| |
| /** |
| * phase resolver struct. |
| */ |
| struct axis2_phase_resolver |
| { |
| /** operations of phase resolver */ |
| axis2_phase_resolver_ops_t *ops; |
| }; |
| |
| /** |
| * Creates phase resolver struct. |
| * @param env pointer to environment struct |
| * @return pointer to newly created phase resolver |
| */ |
| AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL |
| axis2_phase_resolver_create ( |
| const axis2_env_t *env); |
| |
| /** |
| * Creates phase resolver struct with given configuration. |
| * @param env pointer to environment struct |
| * @param axis2_config pointer to aixs2 configuration, phase resolver |
| * created would not assume ownership of configuration |
| * @return pointer to newly created phase resolver |
| */ |
| AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL |
| axis2_phase_resolver_create_with_config ( |
| const axis2_env_t *env, |
| struct axis2_conf *axis2_config); |
| |
| /** |
| * Creates phase resolver struct with given configuration and service. |
| * @param env pointer to environment struct |
| * @param aixs2_config pointer to aixs2 configuration, phase resolver |
| * created would not assume ownership of configuration |
| * @param svc pointer to service, phase resolver |
| * created would not assume ownership of service |
| * @return pointer to newly created phase resolver |
| */ |
| AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL |
| axis2_phase_resolver_create_with_config_and_svc ( |
| const axis2_env_t *env, |
| struct axis2_conf *axis2_config, |
| struct axis2_svc *svc); |
| |
| /** Frees phase resolver. |
| @sa axis2_phase_resolver_ops#free */ |
| #define AXIS2_PHASE_RESOLVER_FREE(phase_resolver, env) \ |
| ((phase_resolver)->ops->free (phase_resolver, env)) |
| |
| /** Builds execution chains. |
| @sa axis2_phase_resolver_ops#build_chains */ |
| #define AXIS2_PHASE_RESOLVER_BUILD_CHAINS(phase_resolver, env) \ |
| ((phase_resolver)->ops->build_chains (phase_resolver, env)) |
| |
| /** Builds module operations. |
| @sa axis2_phase_resolver_ops#build_module_op */ |
| #define AXIS2_PHASE_RESOLVER_BUILD_MODULE_OP(phase_resolver, env, op) \ |
| ((phase_resolver)->ops->build_module_op (phase_resolver, env, op)) |
| |
| /** Builds transport chains. |
| @sa axis2_phase_resolver_ops#build_transport_chains */ |
| #define AXIS2_PHASE_RESOLVER_BUILD_TRANSPORT_CHAINS(phase_resolver, env) \ |
| ((phase_resolver)->ops->build_transport_chains (phase_resolver, env)) |
| |
| /** Engages module globally. |
| @sa axis2_phase_resolver_ops#engage_module_globally */ |
| #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_GLOBALLY(phase_resolver, env, module) \ |
| ((phase_resolver)->ops->engage_module_globally (phase_resolver, env, module)) |
| |
| /** Engages module to service from global module. |
| @sa axis2_phase_resolver_ops#engage_module_to_svc_from_global */ |
| #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_TO_SVC_FROM_GLOBAL(phase_resolver, env, svc, module_desc) \ |
| ((phase_resolver)->ops->engage_module_to_svc_from_global (phase_resolver, env, svc, module_desc)) |
| |
| /** Engage module to service. |
| @sa axis2_phase_resolver_ops#engage_module_to_svc */ |
| #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_TO_SVC(phase_resolver, env, svc, module_desc) \ |
| ((phase_resolver)->ops->engage_module_to_svc (phase_resolver, env, svc, module_desc)) |
| |
| /** Engage module to operation. |
| @sa axis2_phase_resolver_ops#engage_module_to_op */ |
| #define AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_TO_OP(phase_resolver, env, axis_op, module_desc) \ |
| ((phase_resolver)->ops->engage_module_to_op (phase_resolver, env, axis_op, module_desc)) |
| |
| |
| /** @} */ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif /* AXIS2_PHASE_RESOLVER_H */ |