/*
* 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_H
#define AXIS2_PHASE_H

/**
 * @defgroup axis2_phase phases
 * @ingroup axis2_engine
 * phase is a logical unit of execution in the Axis2 engine's execution flows.
 * A phase encapsulates one or more handlers in a given sequence to be invoked. 
 * The sequencing of handlers within a phase are often defined by module 
 * configuration which specifies where in the phase's handler chain a given 
 * handler should be placed.
 * Calling invoke on phase triggers invoke on the handlers stored within the 
 * phase in the sequence they are ordered. 
 * @{
 */

/**
 * @file axis2_phase.h
 */

#include <axis2_defines.h>
#include <axis2_env.h>
#include <axis2_handler.h>
#include <axis2_handler_desc.h>
#include <axis2_array_list.h>
#include <axis2_qname.h>

/** 
 * A given handler's location within the list of handlers is before a particular
 * handler and after another particular handler. 
 */
#define AXIS2_PHASE_BOTH_BEFORE_AFTER  0

/** 
 * A given handler's location within the list of handlers is before another 
 * given handler.
 */
#define AXIS2_PHASE_BEFORE  1

/** 
 * A given handler's location within the list of handlers is after another 
 * given handler.
 */
#define AXIS2_PHASE_AFTER  2

/** 
 * A given handler's location within the list of handlers could be anywhere in
 * the list.
 */
#define AXIS2_PHASE_ANYWHERE  3

#ifdef __cplusplus
extern "C"
{
#endif

    /** Type name for axis2_phase_ops */
    typedef struct axis2_phase_ops axis2_phase_ops_t;
    /** Type name for axis2_phase */
    typedef struct axis2_phase axis2_phase_t;
        
    struct axis2_msg_ctx;

    /**
     * phase ops struct.
     * Encapsulator struct for operations of axis2_phase.
     */
    struct axis2_phase_ops
    {
        /**
         * Adds given handler to the specified position in the handler array list.
         * @param phase pointer to phase struct
         * @param env pointer to environment struct
         * @param index index
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                add_handler_at)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    const int index,
                    axis2_handler_t *handler);
        
        /**
         * Adds the given handler to the end of the handler list.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler 
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                add_handler)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_t *handler);
                    
         /**
          * Invokes the phase. This function will in turn call invoke method of
          * each handler in the handler list, in sequence, starting from the 
          * beginning of the list to the end of the list.
          * @param phase pointer to phase
          * @param env pointer to environment struct
          * @param msg_ctx pointer to message context
          * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
          */
        axis2_status_t (AXIS2_CALL *
                invoke)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    struct axis2_msg_ctx *msg_ctx);
        /**
         * Gets phase name.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @return returns name of phase
         */
        const axis2_char_t *(AXIS2_CALL *
                get_name)(
                    const axis2_phase_t *phase,
                    const axis2_env_t *env);

        /**
         * Gets handler count in the handler list.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @return the number of handlers in the handler list
         */
        int (AXIS2_CALL *
                get_handler_count)( 
                    const axis2_phase_t *phase,
                    const axis2_env_t *env);

        /**
         * Sets the first handler in the handler list.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                set_first_handler)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_t *handler);
                    
        /**
         * Sets the last handler in the handler list.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                set_last_handler)(  
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_t *handler);
                    
        /**
         * Adds handler within the handler description to the list of handlers 
         * in the phase.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler_desc pointer to handler description, phase does not 
         * assume the ownership of neither the handler description not the handler
         * within the handler description
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                add_handler_desc)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_desc_t *handler_desc);
                    
        /**
         * Inserts the handler into handler list of the phase based on the phase
         * rules associated with the handler. This function takes into account 
         * the before rules of the handler. Before rules specify the location
         * of a current handler in the handler list, before which the given 
         * handler is to be placed.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                insert_before)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_t *handler);

        /**
         * Inserts the handler into handler list of the phase based on the phase
         * rules associated with the handler. This function takes into account 
         * the after rules of the handler. After rules specify the location
         * of a current handler in the handler list, after which the given 
         * handler is to be placed.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                insert_after)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_t *handler);

        /**
         * Inserts the handler into handler list of the phase based on both 
         * before and after phase rules associated with the handler. 
         * This method assume that both the before and after cannot be the same 
         * handler . That condition is not checked by this function. 
         * It should be checked before calling this function
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler pointer to handler, phase does not assume the 
         * ownership of the handler
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                insert_before_and_after)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_t *handler);

        /**
         * Inserts the handler to the correct location in the handler list of 
         * the phase. Location is evaluated based on the phase rules.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param handler_desc pointer to handler description, phase does not 
         * assume the ownership of neither the handler description not the handler
         * within the handler description
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                insert_handler_desc)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    axis2_handler_desc_t *handler_desc);

        /**
         * Gets all the handlers in the phase.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @return pointer to array list containing the list of handlers
         */
        axis2_array_list_t *(AXIS2_CALL *
                get_all_handlers)(
                    const axis2_phase_t *phase,
                    const axis2_env_t *env);

        /**
         * Invokes handlers starting from the given handler index.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @param paused_handler_index index of the handler to start the 
         * invocation from
         * @param msg_ctx pointer to message context
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                invoke_start_from_handler)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env,
                    const int paused_handler_index,
                    struct axis2_msg_ctx *msg_ctx);

        /**
         * Frees phase struct.
         * @param phase pointer to phase
         * @param env pointer to environment struct
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE 
         */
        axis2_status_t (AXIS2_CALL *
                free)(
                    axis2_phase_t *phase,
                    const axis2_env_t *env);

    };

    /**
     * phase struct.
     */
    struct axis2_phase
    {
        /** operations of phase */
        axis2_phase_ops_t *ops;
    };


    /**
     * creates phase struct instance.
     * @param env pointer to environment struct
     * @param phase_name name of the phase to be created
     * @return pointer to newly created phase
     */
    AXIS2_EXTERN axis2_phase_t *AXIS2_CALL
    axis2_phase_create(
            const axis2_env_t *env,
            const axis2_char_t *phase_name);

/** Add handler at a given location to the phase's list of handlers.
    @sa axis2_phase_ops#add_handler_at */
#define AXIS2_PHASE_ADD_HANDLER_AT(phase, env, index, handler) \
      ((phase)->ops->add_handler_at(phase, env, index, handler))

/** Adds the given handler to the end of the handler list.
    @sa axis2_phase_ops#add_handler */
#define AXIS2_PHASE_ADD_HANDLER(phase, env, handler) \
      ((phase)->ops->add_handler(phase, env, handler))

/** Adds the handler within given handler description to the handler list.
    @sa axis2_phase_ops#add_handler_desc */
#define AXIS2_PHASE_ADD_HANDLER_DESC(phase, env, handler_desc) \
      ((phase)->ops->add_handler_desc(phase, env, handler_desc))

/** 
 * Invokes phase, this method will call invoke of all the handlers in the list 
 * in sequence.
 * @sa axis2_phase_ops#invoke */
#define AXIS2_PHASE_INVOKE(phase, env, msg_ctx) \
       ((phase)->ops->invoke(phase, env, msg_ctx))

/** Gets phase name.
    @sa axis2_phase_ops#set_name */
#define AXIS2_PHASE_GET_NAME(phase, env) \
      ((phase)->ops->get_name(phase, env))

/** Gets handler count.
    @sa axis2_phase_ops#get_handler_count */
#define AXIS2_PHASE_GET_HANDLER_COUNT(phase, env) \
      ((phase)->ops->get_handler_count(phase, env))

/** Sets the first handler.
    @sa axis2_phase_ops#set_first_handler */
#define AXIS2_PHASE_SET_FIRST_HANDLER(phase, env, handler) \
      ((phase)->ops->set_first_handler(phase, env, handler))

/** Sets the last handler of the handler list.
    @sa axis2_phase_ops#set_last_handler */
#define AXIS2_PHASE_SET_LAST_HANDLER(phase, env, handler) \
      ((phase)->ops->set_last_handler(phase, env, handler))

/** Inserts given handler based on the before phase rules of the handler.
    @sa axis2_phase_ops#insert_before */
#define AXIS2_PHASE_INSERT_BEFORE(phase, env, handler) \
      ((phase)->ops->insert_before(phase, env, handler))

/** Inserts given handler based on the after phase rules of the handler.
    @sa axis2_phase_ops#insert_after */
#define AXIS2_PHASE_INSERT_AFTER(phase, env, handler) \
      ((phase)->ops->insert_after(phase, env, handler))

/** Inserts given handler based on the both before and after  phase rules of 
    the handler. 
    @sa axis2_phase_ops#insert_before_and_after */
#define AXIS2_PHASE_INSERT_BEFORE_AND_AFTER(phase, env, handler) \
      ((phase)->ops->insert_before_and_after(phase, env, handler))

/** Inserts the handler within given handler description to the handler list. 
    @sa axis2_phase_ops#insert_handler_desc */
#define AXIS2_PHASE_INSERT_HANDLER_DESC(phase, env, handler_desc) \
      ((phase)->ops->insert_handler_desc(phase, env, handler_desc))

/** Gets all handlers as an array list.
    @sa axis2_phase_ops#get_all_handlers */
#define AXIS2_PHASE_GET_ALL_HANDLERS(phase, env) \
      ((phase)->ops->get_all_handlers(phase, env))

/** Invoke phase starting from given handler.
    @sa axis2_phase_ops#invoke_start_from_handler */
#define AXIS2_PHASE_INVOKE_START_FROM_HANDLER(phase, env, paused_handler_index, \
        msg_ctx) \
      ((phase)->ops->invoke_start_from_handler(phase, env, paused_handler_index, \
        msg_ctx))

/** Frees phase struct.
    @sa axis2_phase_ops#free */
#define AXIS2_PHASE_FREE(phase, env) \
      ((phase)->ops->free(phase, env))

    /** @} */

#ifdef __cplusplus
}
#endif

#endif    /* AXIS2_PHASE_H */