From 0425aadc78680e53000fd0108b540d6eca048516 Mon Sep 17 00:00:00 2001 From: gmcdonald Date: Sat, 13 Feb 2010 01:32:03 +0000 Subject: Moving axis svn, part of TLP move INFRA-2441 git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68 --- include/axis2_op_ctx.h | 307 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 include/axis2_op_ctx.h (limited to 'include/axis2_op_ctx.h') diff --git a/include/axis2_op_ctx.h b/include/axis2_op_ctx.h new file mode 100644 index 0000000..f29ec60 --- /dev/null +++ b/include/axis2_op_ctx.h @@ -0,0 +1,307 @@ + +/* +* 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_OP_CTX_H +#define AXIS2_OP_CTX_H + +/** + * @defgroup axis2_op_ctx operation context + * @ingroup axis2_context + * operation context represents a running "instance" of an operation. + * operation context allows messages to be grouped into operations as in + * WSDL 2.0 specification. operations are essentially arbitrary message exchange + * patterns (MEP). So as messages are being exchanged, operation context remembers + * the state of message exchange pattern specifics. + * The implementation of operation context supports MEPs which have one input + * message and/or one output message. In order to support other MEPs one must + * extend this struct. + * @{ + */ + +/** + * @file axis2_op_ctx.h + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_op_ctx */ + typedef struct axis2_op_ctx axis2_op_ctx_t; + + struct axis2_svc_ctx; + + /** + * Creates an operation context struct instance. + * @param env pointer to environment struct + * @param op pointer to operation that is related to operation context. + * operation context does not assume the ownership of the struct + * @param svc_ctx pointer to parent service context + * @return pointer to newly created operation context + */ + AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL + axis2_op_ctx_create( + const axutil_env_t * env, + struct axis2_op *op, + struct axis2_svc_ctx *svc_ctx); + + /** + * Gets base which is of context type. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to base context + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_op_ctx_get_base( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Frees operation context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_ctx_free( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env); + + /** + * Initializes operation context. This method traverses through all the + * message contexts stored within it and initialize them all. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param conf pointer to conf configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_init( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets operation the operation context is related to. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to operation + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_op_ctx_get_op( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Gets parent which is of service context type. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to service context within which this operation + * context lives + */ + AXIS2_EXTERN struct axis2_svc_ctx *AXIS2_CALL + axis2_op_ctx_get_parent( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Adds a message context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * does not assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_add_msg_ctx( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets message context with the given message ID. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param message_id message label of type axis2_wsdl_msg_labels_t. + * This can be one of AXIS2_WSDL_MESSAGE_LABEL_IN or AXIS2_WSDL_MESSAGE_LABEL_OUT + * from the axis2_wsdl_msg_labels enum. + * @return pointer to message context with given ID + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_op_ctx_get_msg_ctx( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env, + const axis2_wsdl_msg_labels_t message_id); + + /** + * Gets the bool value indicating if the MEP is complete. + * MEP is considered complete when all the messages that + * are associated with the MEP has arrived. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if MEP invocation is complete, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_ctx_get_is_complete( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating if the MEP is complete. + * MEP is considered complete when all the messages that + * are associated with the MEP has arrived. + * @param op_ctx pointer to operating context + * @param env pointer to environment struct + * @param is_complete AXIS2_TRUE if MEP invocation is complete, else + * AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_complete( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + axis2_bool_t is_complete); + + /** + * Cleans up the operation context. Clean up includes removing all + * message context references recorded in operation context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_cleanup( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env); + + /** + * Sets parent service context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param svc_ctx pointer to service context, message context does not + * assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_parent( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + struct axis2_svc_ctx *svc_ctx); + + /** + * Gets the message context map. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to hash table containing message contexts + */ + AXIS2_EXTERN axis2_msg_ctx_t **AXIS2_CALL + axis2_op_ctx_get_msg_ctx_map( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating the status of response. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param response_written AXIS2_TRUE if response is written, else + * AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_response_written( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env, + const axis2_bool_t response_written); + + /** + * Checks the response status, whether it is written or not. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if response is already written, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_ctx_get_response_written( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Destroys mutex used to synchronize the read/write operations + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return returns void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_ctx_destroy_mutex( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env); + + /** + * Checks whether op_ctx is in use. This is necessary when destroying the + * thread mutex at the http_worker to check whether the operation context + * is still in use + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_ctx_is_in_use( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Set operation context's is_in_use attribute. This is necessary when + * destroying the thread mutex at the http_worker to check whether the + * operation context is still in use + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param is_in_use AXIS2_TRUE if still in use, else AXIS2_FALSE + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_in_use( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + axis2_bool_t is_in_use); + + /** + * Incrementing the op_ctx ref count. This is necessary when + * prevent freeing op_ctx through op_client when it is in use + * as in sandesha where the msg_cts is stored. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_increment_ref( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_OP_CTX_H */ -- cgit v1.1-32-gdbae