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 --- src/core/description/handler_desc.c | 333 ++++++++++++++++++++++++++++++++++++ 1 file changed, 333 insertions(+) create mode 100644 src/core/description/handler_desc.c (limited to 'src/core/description/handler_desc.c') diff --git a/src/core/description/handler_desc.c b/src/core/description/handler_desc.c new file mode 100644 index 0000000..c3281f5 --- /dev/null +++ b/src/core/description/handler_desc.c @@ -0,0 +1,333 @@ +/* + * 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. + */ + +#include +#include +#include +#include + +struct axis2_handler_desc +{ + + /** name */ + axutil_string_t *name; + + /** phase rules */ + axis2_phase_rule_t *rules; + + /** handler represented by meta information*/ + axis2_handler_t *handler; + + /** class name */ + axis2_char_t *class_name; + + /** parent param container */ + axutil_param_container_t *parent; + + /** parameter container */ + axutil_param_container_t *param_container; +}; + +AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL +axis2_handler_desc_create( + const axutil_env_t * env, + axutil_string_t * name) +{ + axis2_handler_desc_t *handler_desc = NULL; + + handler_desc = AXIS2_MALLOC(env->allocator, sizeof(axis2_handler_desc_t)); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + handler_desc->param_container = NULL; + handler_desc->name = NULL; + handler_desc->rules = NULL; + handler_desc->handler = NULL; + handler_desc->class_name = NULL; + handler_desc->parent = NULL; + + handler_desc->param_container = axutil_param_container_create(env); + if(!handler_desc->param_container) + { + + /** error code is already set by last param container create */ + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + handler_desc->rules = axis2_phase_rule_create(env, NULL); + if(!handler_desc->rules) + { + + /** error code is already set by last param container create */ + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + if(name) + { + handler_desc->name = axutil_string_clone(name, env); + } + + return handler_desc; +} + +AXIS2_EXTERN const axutil_string_t *AXIS2_CALL +axis2_handler_desc_get_name( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_desc_set_name( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axutil_string_t * name) +{ + if(handler_desc->name) + { + axutil_string_free(handler_desc->name, env); + handler_desc->name = NULL; + } + + if(name) + { + handler_desc->name = axutil_string_clone(name, env); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL +axis2_handler_desc_get_rules( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->rules; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_desc_set_rules( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axis2_phase_rule_t * phase_rule) +{ + const axutil_string_t *str_name = axis2_handler_desc_get_name(handler_desc, env); + const axis2_char_t *name = axutil_string_get_buffer(str_name, env); + if(handler_desc->rules) + { + axis2_phase_rule_free(handler_desc->rules, env); + } + + if(phase_rule) + { + handler_desc->rules = axis2_phase_rule_clone(phase_rule, env); + if(!(handler_desc->rules)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Phase rule cloning failed for handler description %s", name); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_param_t *AXIS2_CALL +axis2_handler_desc_get_param( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + const axis2_char_t * name) +{ + return axutil_param_container_get_param(handler_desc->param_container, env, name); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_desc_add_param( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axutil_param_t * param) +{ + const axutil_string_t *str_name = axis2_handler_desc_get_name(handler_desc, env); + const axis2_char_t *name = axutil_string_get_buffer(str_name, env); + axis2_char_t *param_name = axutil_param_get_name(param, env); + if(axutil_param_container_is_param_locked(handler_desc->parent, env, param_name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for handler %s", + param_name, name); + return AXIS2_FAILURE; + } + + return axutil_param_container_add_param(handler_desc->param_container, env, param); +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_handler_desc_get_all_params( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return axutil_param_container_get_params(handler_desc->param_container, env); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_handler_desc_is_param_locked( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + const axis2_char_t * param_name) +{ + /* See if it is locked in parent */ + if(axutil_param_container_is_param_locked(handler_desc->parent, env, param_name)) + { + return AXIS2_TRUE; + } + + return axutil_param_container_is_param_locked(handler_desc->param_container, env, param_name); +} + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axis2_handler_desc_get_handler( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->handler; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_desc_set_handler( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + /* Handler description is the place where the handler really lives. + Hence this is a deep copy and should be freed by the free function. */ + + if(handler_desc->handler && (handler_desc->handler != handler)) + { + axis2_handler_free(handler_desc->handler, env); + } + + if(handler) + handler_desc->handler = handler; /* Shallow copy, but free method + should free this */ + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_handler_desc_get_class_name( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->class_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_desc_set_class_name( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + const axis2_char_t * class_name) +{ + if(handler_desc->class_name) + { + AXIS2_FREE(env->allocator, handler_desc->class_name); + } + + if(class_name) + { + handler_desc->class_name = axutil_strdup(env, class_name); + if(!handler_desc->class_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL +axis2_handler_desc_get_parent( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->parent; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_desc_set_parent( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axutil_param_container_t * parent) +{ + handler_desc->parent = parent; /* Shallow copy, because + the parent lives somewhere else */ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_handler_desc_free( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + if(handler_desc->param_container) + { + axutil_param_container_free(handler_desc->param_container, env); + } + + if(handler_desc->name) + { + axutil_string_free(handler_desc->name, env); + } + + if(handler_desc->rules) + { + axis2_phase_rule_free(handler_desc->rules, env); + } + + if(handler_desc->handler) + { + axis2_handler_free(handler_desc->handler, env); + } + + if(handler_desc->class_name) + { + AXIS2_FREE(env->allocator, handler_desc->class_name); + } + if(handler_desc) + { + AXIS2_FREE(env->allocator, handler_desc); + } + + return; +} + +AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL +axis2_handler_desc_get_param_container( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->param_container; +} + -- cgit v1.1-32-gdbae