include/axis2_phase_resolver.h

/*
* 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_phase_resolver
 *
 * Engaging modules into axis2 configuration, services and operations are done here. 
 * This is accomplished mainly by following operations respectively.
 * axis2_phase_resolver_engage_module_globally().
 * axis2_phase_resolver_engage_module_to_svc().
 * axis2_phase_resolver_engage_module_to_op().
 * The user normally engage a module programmatically or using configuration files. When an
 * application client engage a module programmatically he can use axis2_op_client_engage_module()
 * function, or axis2_svc_client_engage_module() function. Engaging using configuration files means
 * adding a module_ref parameter into services.xml or axis2.xml.
 * In whatever way engaging a module finally sums upto addding module handlers into each operations flows
 * in the order defined in module.xml. Here flows in operations are actually array lists of user defined
 * phases (See op.c).
 *
 * Above functions in phase resolver add module handlers into operation flows as mentioned above as well
 * as add module handlers into system defined phases. User defined phases are added into each operation
 * at deployment time before handlers are added into them by phase resolver. System define phases
 * are added into axis2_conf_t structure and predefined handlers are added to them before module handlers
 * are added to them by phase resolver.
 *
 * Modules defined in axis2.xml are engaged by call to axis2_conf_engage_module() function. Modules defined in 
 * services xml are engaged by call to axis2_svc_enage_module() or axis2_svc_grp_engage_module(). Modules
 * define in operation tag under services.xml are engaged by call to axis2_op_engage_module() function.
 * These function in tern call one of axis2_phase_resolver_engage_module_globally() or 
 * axis2_phase_resolver_engage_module_to_svc() or axis2_phase_resolver_engage_module_to_op.
 *
 * Also when you add a service programmaticaly into axis2_conf_t you need to build execution chains for that
 * services operations.
 * axis2_phase_resolver_build_execution_chains_for_svc() is the function to be called for that purpose.
 * This will extract the already engaged modules for the configuration and service and add handlers from
 * them into operation phases.
 *
 * @{
 */

/**
 * @file axis2_phase_resolver.h
 */

#include <axis2_const.h>
#include <axutil_error.h>
#include <axis2_defines.h>
#include <axutil_env.h>
#include <axutil_allocator.h>
#include <axutil_qname.h>
#include <axutil_array_list.h>
#include <axutil_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;

    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;

    /**
     * Frees phase resolver.
     * @param phase_resolver pointer to phase resolver
     * @param env pointer to environment struct
     * @return void
     */
    AXIS2_EXTERN void AXIS2_CALL
    axis2_phase_resolver_free(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_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_EXTERN axis2_status_t AXIS2_CALL

    axis2_phase_resolver_engage_module_globally(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env,
        struct axis2_module_desc *module);

    /**
     * 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_EXTERN axis2_status_t AXIS2_CALL

    axis2_phase_resolver_engage_module_to_svc(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_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_EXTERN axis2_status_t AXIS2_CALL
    axis2_phase_resolver_engage_module_to_op(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env,
        struct axis2_op *axis_op,
        struct axis2_module_desc *module_desc);

    /**
     * Builds the execution chains for service. Execution chains are collection of phases that are 
     * invoked in the execution path. Execution chains for system defined phases are created when
     * call to engage_module_globally() function. Here it is created for service operations.
     * @param phase_resolver pointer to phase resolver
     * @param env pointer to environment struct
     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
     */
    AXIS2_EXTERN axis2_status_t AXIS2_CALL
    axis2_phase_resolver_build_execution_chains_for_svc(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env);

    /**
     * Builds execution chains for given module 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_EXTERN axis2_status_t AXIS2_CALL

    axis2_phase_resolver_build_execution_chains_for_module_op(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env,
        struct axis2_op *op);

    /**
     * Disengages the given module from the given service. This means 
     * the given module would be disengaged from 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_EXTERN axis2_status_t AXIS2_CALL
    axis2_phase_resolver_disengage_module_from_svc(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env,
        struct axis2_svc *svc,
        struct axis2_module_desc *module_desc);

    /**
     * Disengages the given module from 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_EXTERN axis2_status_t AXIS2_CALL
    axis2_phase_resolver_disengage_module_from_op(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env,
        struct axis2_op *axis_op,
        struct axis2_module_desc *module_desc);

    /**
     * Builds transport chains. This function is no longer used in Axis2/C and hence
     * marked as deprecated.
     * @deprecated
     * @param phase_resolver pointer to phase resolver
     * @param env pointer to environment struct
     * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
     */
    AXIS2_EXTERN axis2_status_t AXIS2_CALL
    axis2_phase_resolver_build_transport_chains(
        axis2_phase_resolver_t * phase_resolver,
        const axutil_env_t * env);

    /**
     * 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 axutil_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 axutil_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 axutil_env_t * env,
        struct axis2_conf *axis2_config,
        struct axis2_svc *svc);

    /** @} */

#ifdef __cplusplus
}
#endif
#endif                          /* AXIS2_PHASE_RESOLVER_H */