You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/03/05 05:11:57 UTC
svn commit: r514539 [5/8] - in /webservices/axis2/trunk/c: include/
modules/core/deployment/ modules/core/description/ modules/core/engine/
modules/core/transport/http/receiver/ modules/core/transport/http/sender/
Modified: webservices/axis2/trunk/c/modules/core/description/desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/desc.c?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/desc.c Sun Mar 4 20:11:56 2007
@@ -18,149 +18,67 @@
#include <axis2_desc.h>
#include <axis2_property.h>
#include <axis2_msg.h>
-/**
- * @brief Message struct impl
- * Axis2 Messages
- */
-typedef struct axis2_desc_impl
-{
- axis2_desc_t desc;
+struct axis2_desc
+{
/** parameter container */
axis2_param_container_t *param_container;
/** children of this description */
axis2_hash_t *children;
-}
-axis2_desc_impl_t;
-
-#define AXIS2_INTF_TO_IMPL(desc) ((axis2_desc_impl_t *)desc)
-
-axis2_status_t AXIS2_CALL
-axis2_desc_free(
- axis2_desc_t *desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_desc_add_param(
- axis2_desc_t *desc,
- const axis2_env_t *env,
- axis2_param_t *param);
-
-axis2_param_t *AXIS2_CALL
-axis2_desc_get_param(
- const axis2_desc_t *desc,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
-axis2_array_list_t *AXIS2_CALL
-axis2_desc_get_all_params(
- const axis2_desc_t *desc,
- const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_desc_is_param_locked(
- const axis2_desc_t *desc,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
-axis2_status_t AXIS2_CALL
-axis2_desc_add_child(
- const axis2_desc_t *desc,
- const axis2_env_t *env,
- const axis2_char_t *key,
- const void* child);
-
-axis2_hash_t *AXIS2_CALL
-axis2_desc_get_all_children(
- const axis2_desc_t *desc,
- const axis2_env_t *env);
-
-void *AXIS2_CALL
-axis2_desc_get_child(
- const axis2_desc_t *desc,
- const axis2_env_t *env,
- const axis2_char_t *key);
-
-axis2_status_t AXIS2_CALL
-axis2_desc_remove_child(
- const axis2_desc_t *desc,
- const axis2_env_t *env,
- const axis2_char_t *key);
+};
AXIS2_EXTERN axis2_desc_t *AXIS2_CALL
axis2_desc_create(
const axis2_env_t *env)
{
- axis2_desc_impl_t *desc_impl = NULL;
+ axis2_desc_t *desc = NULL;
AXIS2_ENV_CHECK(env, NULL);
- desc_impl = (axis2_desc_impl_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axis2_desc_impl_t));
+ desc = (axis2_desc_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_desc_t));
- if (NULL == desc_impl)
+ if (NULL == desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- desc_impl->param_container = NULL;
- desc_impl->children = NULL;
- desc_impl->desc.ops = NULL;
+ desc->param_container = NULL;
+ desc->children = NULL;
- desc_impl->param_container = (axis2_param_container_t *)
+ desc->param_container = (axis2_param_container_t *)
axis2_param_container_create(env);
- if (NULL == desc_impl->param_container)
- {
- axis2_desc_free(&(desc_impl->desc), env);
- return NULL;
- }
-
- desc_impl->children = axis2_hash_make(env);
- if (NULL == desc_impl->children)
+ if (NULL == desc->param_container)
{
- axis2_desc_free(&(desc_impl->desc), env);
+ axis2_desc_free(desc, env);
return NULL;
}
- desc_impl->desc.ops = AXIS2_MALLOC(env->allocator, sizeof(axis2_desc_ops_t));
- if (NULL == desc_impl->desc.ops)
+ desc->children = axis2_hash_make(env);
+ if (NULL == desc->children)
{
- axis2_desc_free(&(desc_impl->desc), env);
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ axis2_desc_free(desc, env);
return NULL;
}
- desc_impl->desc.ops->free = axis2_desc_free;
- desc_impl->desc.ops->add_param = axis2_desc_add_param;
- desc_impl->desc.ops->get_param = axis2_desc_get_param;
- desc_impl->desc.ops->get_all_params = axis2_desc_get_all_params;
- desc_impl->desc.ops->is_param_locked = axis2_desc_is_param_locked;
- desc_impl->desc.ops->add_child = axis2_desc_add_child;
- desc_impl->desc.ops->get_all_children = axis2_desc_get_all_children;
- desc_impl->desc.ops->get_child = axis2_desc_get_child;
- desc_impl->desc.ops->remove_child = axis2_desc_remove_child;
-
-
- return &(desc_impl->desc);
+ return desc;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_free(
axis2_desc_t *desc,
const axis2_env_t *env)
{
- axis2_desc_impl_t *desc_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- if (desc_impl->children)
+ if (desc->children)
{
axis2_hash_index_t *hi = NULL;
void *val = NULL;
- for (hi = axis2_hash_first(desc_impl->children, env); hi;
+ for (hi = axis2_hash_first(desc->children, env); hi;
hi = axis2_hash_next(env, hi))
{
axis2_hash_this(hi, NULL, NULL, &val);
@@ -172,74 +90,60 @@
}
}
- axis2_hash_free(desc_impl->children, env);
- desc_impl->children = NULL;
+ axis2_hash_free(desc->children, env);
+ desc->children = NULL;
}
- if (desc_impl->param_container)
+ if (desc->param_container)
{
- AXIS2_PARAM_CONTAINER_FREE(desc_impl->param_container, env);
- desc_impl->param_container = NULL;
+ AXIS2_PARAM_CONTAINER_FREE(desc->param_container, env);
+ desc->param_container = NULL;
}
- if (desc_impl->desc.ops)
+ if (desc)
{
- AXIS2_FREE(env->allocator, desc_impl->desc.ops);
- desc_impl->desc.ops = NULL;
- }
-
- if (desc_impl)
- {
- AXIS2_FREE(env->allocator, desc_impl);
- desc_impl = NULL;
+ AXIS2_FREE(env->allocator, desc);
+ desc = NULL;
}
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_add_param(
axis2_desc_t *desc,
const axis2_env_t *env,
axis2_param_t *param)
{
- axis2_desc_impl_t *desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- return AXIS2_PARAM_CONTAINER_ADD_PARAM(desc_impl->param_container, env, param);
+ return AXIS2_PARAM_CONTAINER_ADD_PARAM(desc->param_container, env, param);
}
-axis2_param_t *AXIS2_CALL
+AXIS2_EXTERN axis2_param_t *AXIS2_CALL
axis2_desc_get_param(
const axis2_desc_t *desc,
const axis2_env_t *env,
const axis2_char_t *param_name)
{
- axis2_desc_impl_t *desc_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
AXIS2_PARAM_CHECK(env->error, param_name, NULL);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- return AXIS2_PARAM_CONTAINER_GET_PARAM(desc_impl->param_container, env, param_name);
+ return AXIS2_PARAM_CONTAINER_GET_PARAM(desc->param_container, env, param_name);
}
-axis2_array_list_t *AXIS2_CALL
+AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
axis2_desc_get_all_params(
const axis2_desc_t *desc,
const axis2_env_t *env)
{
- axis2_desc_impl_t *desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- AXIS2_PARAM_CHECK(env->error, desc_impl->param_container, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, desc->param_container, AXIS2_FALSE);
- return AXIS2_PARAM_CONTAINER_GET_PARAMS(desc_impl->param_container, env);
+ return AXIS2_PARAM_CONTAINER_GET_PARAMS(desc->param_container, env);
}
-axis2_bool_t AXIS2_CALL
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_desc_is_param_locked(
const axis2_desc_t *desc,
const axis2_env_t *env,
@@ -255,64 +159,55 @@
return (param_l && AXIS2_PARAM_IS_LOCKED(param_l, env));
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_add_child(
const axis2_desc_t *desc,
const axis2_env_t *env,
const axis2_char_t *key,
const void *child)
{
- axis2_desc_impl_t *desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- if (desc_impl->children)
+ if (desc->children)
{
- axis2_hash_set(desc_impl->children, key,
+ axis2_hash_set(desc->children, key,
AXIS2_HASH_KEY_STRING, child);
return AXIS2_SUCCESS;
}
return AXIS2_FAILURE;
}
-axis2_hash_t *AXIS2_CALL
+AXIS2_EXTERN axis2_hash_t *AXIS2_CALL
axis2_desc_get_all_children(
const axis2_desc_t *desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- return AXIS2_INTF_TO_IMPL(desc)->children;
+ return desc->children;
}
-void *AXIS2_CALL
+AXIS2_EXTERN void *AXIS2_CALL
axis2_desc_get_child(
const axis2_desc_t *desc,
const axis2_env_t *env,
const axis2_char_t *key)
{
- axis2_desc_impl_t *desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- return axis2_hash_get(desc_impl->children, key, AXIS2_HASH_KEY_STRING);
+ return axis2_hash_get(desc->children, key, AXIS2_HASH_KEY_STRING);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_desc_remove_child(
const axis2_desc_t *desc,
const axis2_env_t *env,
const axis2_char_t *key)
{
- axis2_desc_impl_t *desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- desc_impl = AXIS2_INTF_TO_IMPL(desc);
- if (desc_impl->children)
+ if (desc->children)
{
- axis2_hash_set(desc_impl->children, key,
+ axis2_hash_set(desc->children, key,
AXIS2_HASH_KEY_STRING, NULL);
return AXIS2_SUCCESS;
}
Modified: webservices/axis2/trunk/c/modules/core/description/flow.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/flow.c?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/flow.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/flow.c Sun Mar 4 20:11:56 2007
@@ -17,126 +17,75 @@
#include <axis2_flow.h>
-typedef struct axis2_flow_impl
+struct axis2_flow
{
- axis2_flow_t flow;
-
axis2_array_list_t *list;
-}
-axis2_flow_impl_t;
-
-#define AXIS2_INTF_TO_IMPL(flow) ((axis2_flow_impl_t *)(flow))
-
-axis2_status_t AXIS2_CALL
-axis2_flow_free(
- axis2_flow_t *flow,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_flow_add_handler(
- axis2_flow_t *flow,
- const axis2_env_t *env,
- axis2_handler_desc_t *handler);
-
-axis2_handler_desc_t *AXIS2_CALL
-axis2_flow_get_handler(
- const axis2_flow_t *flow,
- const axis2_env_t *env,
- const int index);
-
-int AXIS2_CALL
-axis2_flow_get_handler_count(
- const axis2_flow_t *flow,
- const axis2_env_t *env);
+};
AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_flow_create(
const axis2_env_t *env)
{
- axis2_flow_impl_t *flow_impl = NULL;
+ axis2_flow_t *flow = NULL;
AXIS2_ENV_CHECK(env, NULL);
- flow_impl = (axis2_flow_impl_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axis2_flow_impl_t));
+ flow = (axis2_flow_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_flow_t));
- if (NULL == flow_impl)
+ if (NULL == flow)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- flow_impl->list = NULL;
- flow_impl->flow.ops = NULL;
-
- flow_impl->list = axis2_array_list_create(env, 20);
- if (NULL == flow_impl->list)
- {
- axis2_flow_free(&(flow_impl->flow), env);
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
- }
+ flow->list = NULL;
- flow_impl->flow.ops = AXIS2_MALLOC(env->allocator,
- sizeof(axis2_flow_ops_t));
- if (NULL == flow_impl->flow.ops)
+ flow->list = axis2_array_list_create(env, 20);
+ if (NULL == flow->list)
{
- axis2_flow_free(&(flow_impl->flow), env);
+ axis2_flow_free(flow, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- flow_impl->flow.ops->free = axis2_flow_free;
- flow_impl->flow.ops->add_handler = axis2_flow_add_handler;
- flow_impl->flow.ops->get_handler = axis2_flow_get_handler;
- flow_impl->flow.ops->get_handler_count = axis2_flow_get_handler_count;
-
- return &(flow_impl->flow);
+ return flow;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_free(
axis2_flow_t *flow,
const axis2_env_t *env)
{
- axis2_flow_impl_t *flow_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- flow_impl = AXIS2_INTF_TO_IMPL(flow);
- if (flow_impl->list)
+ if (flow->list)
{
int i = 0;
int size = 0;
- size = AXIS2_ARRAY_LIST_SIZE(flow_impl->list, env);
+ size = AXIS2_ARRAY_LIST_SIZE(flow->list, env);
for (i = 0; i < size; i++)
{
axis2_handler_desc_t *handler_desc = NULL;
handler_desc = (axis2_handler_desc_t *) AXIS2_ARRAY_LIST_GET(
- flow_impl->list, env, i);
+ flow->list, env, i);
AXIS2_HANDLER_DESC_FREE(handler_desc, env);
}
- AXIS2_ARRAY_LIST_FREE(flow_impl->list, env);
- flow_impl->list = NULL;
- }
-
- if (flow->ops)
- {
- AXIS2_FREE(env->allocator, flow->ops);
- flow->ops = NULL;
+ AXIS2_ARRAY_LIST_FREE(flow->list, env);
+ flow->list = NULL;
}
- if (flow_impl)
+ if (flow)
{
- AXIS2_FREE(env->allocator, flow_impl);
- flow_impl = NULL;
+ AXIS2_FREE(env->allocator, flow);
+ flow = NULL;
}
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_free_void_arg(
void *flow,
const axis2_env_t *env)
@@ -148,33 +97,29 @@
return axis2_flow_free(flow_l, env);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_add_handler(
axis2_flow_t *flow,
const axis2_env_t *env,
axis2_handler_desc_t *handler)
{
- axis2_flow_impl_t *flow_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE);
- flow_impl = AXIS2_INTF_TO_IMPL(flow);
-
- if (!flow_impl->list)
+ if (!flow->list)
{
- flow_impl->list = axis2_array_list_create(env, 0);
- if (NULL == flow_impl->list)
+ flow->list = axis2_array_list_create(env, 0);
+ if (NULL == flow->list)
{
- axis2_flow_free(&(flow_impl->flow), env);
+ axis2_flow_free(flow, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
- return AXIS2_ARRAY_LIST_ADD(AXIS2_INTF_TO_IMPL(flow)->list, env, handler);
+ return AXIS2_ARRAY_LIST_ADD(flow->list, env, handler);
}
-axis2_handler_desc_t *AXIS2_CALL
+AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL
axis2_flow_get_handler(
const axis2_flow_t *flow,
const axis2_env_t *env,
@@ -182,15 +127,16 @@
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_ARRAY_LIST_GET(AXIS2_INTF_TO_IMPL(flow)->list, env, index);
+ return AXIS2_ARRAY_LIST_GET(flow->list, env, index);
}
-int AXIS2_CALL
+AXIS2_EXTERN int AXIS2_CALL
axis2_flow_get_handler_count(
const axis2_flow_t *flow,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return AXIS2_ARRAY_LIST_SIZE(AXIS2_INTF_TO_IMPL(flow)->list, env);
+ return AXIS2_ARRAY_LIST_SIZE(flow->list, env);
}
+
Modified: webservices/axis2/trunk/c/modules/core/description/flow_container.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/flow_container.c?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/flow_container.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/flow_container.c Sun Mar 4 20:11:56 2007
@@ -15,288 +15,183 @@
* limitations under the License.
*/
+#include <axis2_flow.h>
#include <axis2_flow_container.h>
-/**
- * @brief Flow container struct impl
- * Container for flows
- */
-typedef struct axis2_flow_container_impl
+struct axis2_flow_container
{
- axis2_flow_container_t flow_container;
axis2_flow_t *in;
axis2_flow_t *out;
axis2_flow_t *in_fault;
axis2_flow_t *out_fault;
-}
-axis2_flow_container_impl_t;
-
-#define AXIS2_INTF_TO_IMPL(flow_container) \
- ((axis2_flow_container_impl_t *)flow_container)
-
-/************************* Function prototypes ********************************/
-
-axis2_status_t AXIS2_CALL
-axis2_flow_container_free(
- axis2_flow_container_t *flow_container,
- const axis2_env_t *env);
-
-axis2_flow_t *AXIS2_CALL
-axis2_flow_container_get_in_flow(
- const axis2_flow_container_t *flow_container,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_flow_container_set_in_flow(
- axis2_flow_container_t *flow_container,
- const axis2_env_t *env,
- axis2_flow_t *in_flow);
-
-axis2_flow_t *AXIS2_CALL
-axis2_flow_container_get_out_flow(
- const axis2_flow_container_t *flow_container,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_flow_container_set_out_flow(
- axis2_flow_container_t *flow_container,
- const axis2_env_t *env,
- axis2_flow_t *out_flow);
-
-axis2_flow_t *AXIS2_CALL
-axis2_flow_container_get_fault_in_flow(
- const axis2_flow_container_t *flow_container,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_flow_container_set_fault_in_flow(
- axis2_flow_container_t *flow_container,
- const axis2_env_t *env,
- axis2_flow_t *falut_in_flow);
-
-axis2_flow_t *AXIS2_CALL
-axis2_flow_container_get_fault_out_flow(
- const axis2_flow_container_t *flow_container,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_flow_container_set_fault_out_flow(
- axis2_flow_container_t *flow_container,
- const axis2_env_t *env,
- axis2_flow_t *fault_out_flow);
-
+};
AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL
axis2_flow_container_create(
const axis2_env_t *env)
{
- axis2_flow_container_impl_t *flow_container_impl = NULL;
+ axis2_flow_container_t *flow_container = NULL;
AXIS2_ENV_CHECK(env, NULL);
- flow_container_impl = (axis2_flow_container_impl_t *) AXIS2_MALLOC(env->
- allocator, sizeof(axis2_flow_container_impl_t));
-
+ flow_container = (axis2_flow_container_t *) AXIS2_MALLOC(env->
+ allocator, sizeof(axis2_flow_container_t));
- if (NULL == flow_container_impl)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
- }
- flow_container_impl->flow_container.ops = NULL;
- flow_container_impl->in = NULL;
- flow_container_impl->out = NULL;
- flow_container_impl->in_fault = NULL;
- flow_container_impl->out_fault = NULL;
-
- flow_container_impl->flow_container.ops =
- AXIS2_MALLOC(env->allocator, sizeof(axis2_flow_container_ops_t));
- if (NULL == flow_container_impl->flow_container.ops)
+ if (NULL == flow_container)
{
- axis2_flow_container_free(&(flow_container_impl->flow_container), env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- flow_container_impl->flow_container.ops->free = axis2_flow_container_free;
- flow_container_impl->flow_container.ops->get_in_flow =
- axis2_flow_container_get_in_flow;
- flow_container_impl->flow_container.ops->set_in_flow =
- axis2_flow_container_set_in_flow;
- flow_container_impl->flow_container.ops->get_out_flow =
- axis2_flow_container_get_out_flow;
- flow_container_impl->flow_container.ops->set_out_flow =
- axis2_flow_container_set_out_flow;
- flow_container_impl->flow_container.ops->get_fault_in_flow =
- axis2_flow_container_get_fault_in_flow;
- flow_container_impl->flow_container.ops->set_fault_in_flow =
- axis2_flow_container_set_fault_in_flow;
- flow_container_impl->flow_container.ops->get_fault_out_flow =
- axis2_flow_container_get_fault_out_flow;
- flow_container_impl->flow_container.ops->set_fault_out_flow =
- axis2_flow_container_set_fault_out_flow;
+ flow_container->in = NULL;
+ flow_container->out = NULL;
+ flow_container->in_fault = NULL;
+ flow_container->out_fault = NULL;
- return &(flow_container_impl->flow_container);
+ return flow_container;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_container_free(
axis2_flow_container_t *flow_container,
const axis2_env_t *env)
{
- axis2_flow_container_impl_t *container_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- container_impl = AXIS2_INTF_TO_IMPL(flow_container);
- if (container_impl->in)
+ if (flow_container->in)
{
- AXIS2_FLOW_FREE(container_impl->in, env);
- container_impl->in = NULL;
+ AXIS2_FLOW_FREE(flow_container->in, env);
+ flow_container->in = NULL;
}
- if (container_impl->out)
+ if (flow_container->out)
{
- AXIS2_FLOW_FREE(container_impl->out, env);
- container_impl->out = NULL;
+ AXIS2_FLOW_FREE(flow_container->out, env);
+ flow_container->out = NULL;
}
- if (container_impl->in_fault)
+ if (flow_container->in_fault)
{
- AXIS2_FLOW_FREE(container_impl->in_fault, env);
- container_impl->in_fault = NULL;
+ AXIS2_FLOW_FREE(flow_container->in_fault, env);
+ flow_container->in_fault = NULL;
}
- if (container_impl->out_fault)
+ if (flow_container->out_fault)
{
- AXIS2_FLOW_FREE(container_impl->out_fault, env);
- container_impl->out_fault = NULL;
+ AXIS2_FLOW_FREE(flow_container->out_fault, env);
+ flow_container->out_fault = NULL;
}
- if (flow_container->ops)
- AXIS2_FREE(env->allocator, flow_container->ops);
-
- if (container_impl)
+ if (flow_container)
{
- AXIS2_FREE(env->allocator, container_impl);
- container_impl = NULL;
+ AXIS2_FREE(env->allocator, flow_container);
+ flow_container = NULL;
}
return AXIS2_SUCCESS;
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_flow_container_get_in_flow(
const axis2_flow_container_t *flow_container,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(flow_container)->in;
+ return flow_container->in;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_container_set_in_flow(
axis2_flow_container_t *flow_container,
const axis2_env_t *env,
axis2_flow_t *in_flow)
{
- axis2_flow_container_impl_t *container_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- container_impl = AXIS2_INTF_TO_IMPL(flow_container);
- if (container_impl->in)
+ if (flow_container->in)
{
- AXIS2_FLOW_FREE(container_impl->in, env);
- container_impl->in = NULL;
+ AXIS2_FLOW_FREE(flow_container->in, env);
+ flow_container->in = NULL;
}
- container_impl->in = in_flow;
+ flow_container->in = in_flow;
return AXIS2_SUCCESS;
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_flow_container_get_out_flow(
const axis2_flow_container_t *flow_container,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(flow_container)->out;
+ return flow_container->out;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_container_set_out_flow(
axis2_flow_container_t *flow_container,
const axis2_env_t *env,
axis2_flow_t *out_flow)
{
- axis2_flow_container_impl_t *container_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- container_impl = AXIS2_INTF_TO_IMPL(flow_container);
- if (container_impl->out)
+ if (flow_container->out)
{
- AXIS2_FLOW_FREE(container_impl->out, env);
- container_impl->out = NULL;
+ AXIS2_FLOW_FREE(flow_container->out, env);
+ flow_container->out = NULL;
}
- container_impl->out = out_flow;
+ flow_container->out = out_flow;
return AXIS2_SUCCESS;
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_flow_container_get_fault_in_flow(
const axis2_flow_container_t *flow_container,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(flow_container)->in_fault;
+ return flow_container->in_fault;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_container_set_fault_in_flow(
axis2_flow_container_t *flow_container,
const axis2_env_t *env,
axis2_flow_t *falut_in_flow)
{
- axis2_flow_container_impl_t *container_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- container_impl = AXIS2_INTF_TO_IMPL(flow_container);
- if (container_impl->in_fault)
+ if (flow_container->in_fault)
{
- AXIS2_FLOW_FREE(container_impl->in_fault, env);
- container_impl->in_fault = NULL;
+ AXIS2_FLOW_FREE(flow_container->in_fault, env);
+ flow_container->in_fault = NULL;
}
- container_impl->in_fault = falut_in_flow;
+ flow_container->in_fault = falut_in_flow;
return AXIS2_SUCCESS;
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_flow_container_get_fault_out_flow(
const axis2_flow_container_t *flow_container,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(flow_container)->out_fault;
+ return flow_container->out_fault;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_flow_container_set_fault_out_flow(
axis2_flow_container_t *flow_container,
const axis2_env_t *env,
axis2_flow_t *fault_out_flow)
{
- axis2_flow_container_impl_t *container_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE);
- container_impl = AXIS2_INTF_TO_IMPL(flow_container);
- if (container_impl->out_fault)
+ if (flow_container->out_fault)
{
- AXIS2_FLOW_FREE(container_impl->out_fault, env);
- container_impl->out_fault = NULL;
+ AXIS2_FLOW_FREE(flow_container->out_fault, env);
+ flow_container->out_fault = NULL;
}
- container_impl->out_fault = fault_out_flow;
+ flow_container->out_fault = fault_out_flow;
return AXIS2_SUCCESS;
}
Modified: webservices/axis2/trunk/c/modules/core/description/handler_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/handler_desc.c?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/handler_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/handler_desc.c Sun Mar 4 20:11:56 2007
@@ -20,11 +20,8 @@
#include <axis2_string.h>
#include <axis2_handler.h>
-typedef struct axis2_handler_desc_impl
+struct axis2_handler_desc
{
- /** handler description */
- axis2_handler_desc_t handler_desc;
-
/** name */
axis2_string_t *name;
/** phase rules */
@@ -35,270 +32,142 @@
axis2_char_t *class_name;
/** parent param container */
axis2_param_container_t *parent;
-
-}
-axis2_handler_desc_impl_t;
-
-/** Interface to implementation conversion macro */
-#define AXIS2_INTF_TO_IMPL(handler_desc) \
- ((axis2_handler_desc_impl_t *)handler_desc)
-
-const axis2_string_t *AXIS2_CALL
-axis2_handler_desc_get_name(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_set_name(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- axis2_string_t *name);
-
-axis2_phase_rule_t *AXIS2_CALL
-axis2_handler_desc_get_rules(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_set_rules(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- axis2_phase_rule_t *phase_rule);
-
-axis2_param_t *AXIS2_CALL
-axis2_handler_desc_get_param(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_add_param(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- axis2_param_t *param);
-
-axis2_array_list_t *AXIS2_CALL
-axis2_handler_desc_get_all_params(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_handler_desc_is_param_locked(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
-axis2_handler_t *AXIS2_CALL
-axis2_handler_desc_get_handler(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_set_handler(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- axis2_handler_t *handler);
-
-const axis2_char_t *AXIS2_CALL
-axis2_handler_desc_get_class_name(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_set_class_name(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- const axis2_char_t *class_name);
-
-axis2_param_container_t *AXIS2_CALL
-axis2_handler_desc_get_parent(
- const axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_set_parent(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env,
- axis2_param_container_t *parent);
-
-axis2_status_t AXIS2_CALL
-axis2_handler_desc_free(
- axis2_handler_desc_t *handler_desc,
- const axis2_env_t *env);
+ /** parameter container */
+ axis2_param_container_t *param_container;
+};
AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL
axis2_handler_desc_create(
const axis2_env_t *env,
axis2_string_t *name)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
+ axis2_handler_desc_t *handler_desc = NULL;
AXIS2_ENV_CHECK(env, NULL);
- handler_desc_impl = AXIS2_MALLOC(env->allocator,
- sizeof(axis2_handler_desc_impl_t));
- if (!handler_desc_impl)
+ 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);
return NULL;
}
- handler_desc_impl->handler_desc.param_container = NULL;
- handler_desc_impl->name = NULL;
- handler_desc_impl->rules = NULL;
- handler_desc_impl->handler = NULL;
- handler_desc_impl->class_name = NULL;
- handler_desc_impl->parent = NULL;
- handler_desc_impl->handler_desc.ops = 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_impl->handler_desc.param_container =
+ handler_desc->param_container =
axis2_param_container_create(env);
- if (!handler_desc_impl->handler_desc.param_container)
+ if (!handler_desc->param_container)
{
/** error code is already set by last param container create */
- axis2_handler_desc_free(&(handler_desc_impl->handler_desc), env);
+ axis2_handler_desc_free(handler_desc, env);
return NULL;
}
- handler_desc_impl->rules = axis2_phase_rule_create(env, NULL);
- if (!handler_desc_impl->rules)
+ 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_impl->handler_desc), env);
+ axis2_handler_desc_free(handler_desc, env);
return NULL;
}
if (name)
{
- handler_desc_impl->name = axis2_string_clone(name, env);
+ handler_desc->name = axis2_string_clone(name, env);
}
- /* initialize ops */
-
- handler_desc_impl->handler_desc.ops = AXIS2_MALLOC(env->allocator,
- sizeof(axis2_handler_desc_ops_t));
- if (!handler_desc_impl->handler_desc.ops)
- {
- axis2_handler_desc_free(&(handler_desc_impl->handler_desc), env);
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
- }
-
- handler_desc_impl->handler_desc.ops->get_name = axis2_handler_desc_get_name;
- handler_desc_impl->handler_desc.ops->set_name = axis2_handler_desc_set_name;
- handler_desc_impl->handler_desc.ops->get_rules = axis2_handler_desc_get_rules;
- handler_desc_impl->handler_desc.ops->set_rules = axis2_handler_desc_set_rules;
- handler_desc_impl->handler_desc.ops->get_param = axis2_handler_desc_get_param;
- handler_desc_impl->handler_desc.ops->add_param = axis2_handler_desc_add_param;
- handler_desc_impl->handler_desc.ops->get_all_params = axis2_handler_desc_get_all_params;
- handler_desc_impl->handler_desc.ops->is_param_locked = axis2_handler_desc_is_param_locked;
- handler_desc_impl->handler_desc.ops->get_handler = axis2_handler_desc_get_handler;
- handler_desc_impl->handler_desc.ops->set_handler = axis2_handler_desc_set_handler;
- handler_desc_impl->handler_desc.ops->get_class_name = axis2_handler_desc_get_class_name;
- handler_desc_impl->handler_desc.ops->set_class_name = axis2_handler_desc_set_class_name;
- handler_desc_impl->handler_desc.ops->get_parent = axis2_handler_desc_get_parent;
- handler_desc_impl->handler_desc.ops->set_parent = axis2_handler_desc_set_parent;
- handler_desc_impl->handler_desc.ops->free = axis2_handler_desc_free;
-
- return &(handler_desc_impl->handler_desc);
+ return handler_desc;
}
-const axis2_string_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_string_t *AXIS2_CALL
axis2_handler_desc_get_name(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(handler_desc)->name;
+ return handler_desc->name;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_set_name(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
axis2_string_t *name)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if (AXIS2_INTF_TO_IMPL(handler_desc)->name)
+ if (handler_desc->name)
{
- axis2_string_free(AXIS2_INTF_TO_IMPL(handler_desc)->name, env);
- AXIS2_INTF_TO_IMPL(handler_desc)->name = NULL;
+ axis2_string_free(handler_desc->name, env);
+ handler_desc->name = NULL;
}
if (name)
{
- AXIS2_INTF_TO_IMPL(handler_desc)->name = axis2_string_clone(name, env);
+ handler_desc->name = axis2_string_clone(name, env);
}
return AXIS2_SUCCESS;
}
-axis2_phase_rule_t *AXIS2_CALL
+AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
axis2_handler_desc_get_rules(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(handler_desc)->rules;
+ return handler_desc->rules;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_set_rules(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
axis2_phase_rule_t *phase_rule)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
- if (handler_desc_impl->rules)
+ if (handler_desc->rules)
{
- AXIS2_PHASE_RULE_FREE(handler_desc_impl->rules, env);
- handler_desc_impl->rules = NULL;
+ AXIS2_PHASE_RULE_FREE(handler_desc->rules, env);
+ handler_desc->rules = NULL;
}
if (phase_rule)
{
- handler_desc_impl->rules = AXIS2_PHASE_RULE_CLONE(phase_rule, env);
- if (!(handler_desc_impl->rules))
+ handler_desc->rules = AXIS2_PHASE_RULE_CLONE(phase_rule, env);
+ if (!(handler_desc->rules))
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
-axis2_param_t *AXIS2_CALL
+AXIS2_EXTERN axis2_param_t *AXIS2_CALL
axis2_handler_desc_get_param(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
const axis2_char_t *name)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, NULL);
-
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
return AXIS2_PARAM_CONTAINER_GET_PARAM(handler_desc->param_container, env, name);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_add_param(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
axis2_param_t *param)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
- if (AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(handler_desc_impl->parent, env,
+ if (AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(handler_desc->parent, env,
AXIS2_PARAM_GET_NAME(param, env)))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE,
@@ -309,34 +178,25 @@
return AXIS2_PARAM_CONTAINER_ADD_PARAM(handler_desc->param_container, env, param);
}
-axis2_array_list_t *AXIS2_CALL
+AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
axis2_handler_desc_get_all_params(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, NULL);
-
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
return AXIS2_PARAM_CONTAINER_GET_PARAMS(handler_desc->param_container, env);
}
-axis2_bool_t AXIS2_CALL
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_handler_desc_is_param_locked(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
const axis2_char_t *param_name)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
/* see if it is locked in parent */
- if (AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(handler_desc_impl->parent, env,
+ if (AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(handler_desc->parent, env,
param_name))
return AXIS2_TRUE;
@@ -344,16 +204,16 @@
env, param_name);
}
-axis2_handler_t *AXIS2_CALL
+AXIS2_EXTERN axis2_handler_t *AXIS2_CALL
axis2_handler_desc_get_handler(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(handler_desc)->handler;
+ return handler_desc->handler;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_set_handler(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
@@ -361,55 +221,48 @@
{
/* handler description is the place where the handler really lives.
Hence this is a deep copy and should be freed by the free method. */
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
- if (handler_desc_impl->handler && (handler_desc_impl->handler != handler))
+ if (handler_desc->handler && (handler_desc->handler != handler))
{
- AXIS2_HANDLER_FREE(handler_desc_impl->handler, env);
- handler_desc_impl->handler = NULL;
+ AXIS2_HANDLER_FREE(handler_desc->handler, env);
+ handler_desc->handler = NULL;
}
if (handler)
- handler_desc_impl->handler = handler; /* Shallow copy, but free method
+ handler_desc->handler = handler; /* Shallow copy, but free method
should free this */
return AXIS2_SUCCESS;
}
-const axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axis2_handler_desc_get_class_name(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(handler_desc)->class_name;
+ return handler_desc->class_name;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_set_class_name(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
const axis2_char_t *class_name)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
- if (handler_desc_impl->class_name)
+ if (handler_desc->class_name)
{
- AXIS2_FREE(env->allocator, handler_desc_impl->class_name);
- handler_desc_impl->class_name = NULL;
+ AXIS2_FREE(env->allocator, handler_desc->class_name);
+ handler_desc->class_name = NULL;
}
if (class_name)
{
- handler_desc_impl->class_name = AXIS2_STRDUP(class_name, env);
- if (!handler_desc_impl->class_name)
+ handler_desc->class_name = AXIS2_STRDUP(class_name, env);
+ if (!handler_desc->class_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
@@ -419,80 +272,79 @@
return AXIS2_SUCCESS;
}
-axis2_param_container_t *AXIS2_CALL
+AXIS2_EXTERN axis2_param_container_t *AXIS2_CALL
axis2_handler_desc_get_parent(
const axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(handler_desc)->parent;
+ return handler_desc->parent;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_set_parent(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env,
axis2_param_container_t *parent)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(handler_desc)->parent = parent; /* shallow copy, because
+ handler_desc->parent = parent; /* shallow copy, because
the parent lives
somewhere else*/
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_handler_desc_free(
axis2_handler_desc_t *handler_desc,
const axis2_env_t *env)
{
- axis2_handler_desc_impl_t *handler_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- handler_desc_impl = AXIS2_INTF_TO_IMPL(handler_desc);
-
- if (handler_desc_impl->handler_desc.ops)
- {
- AXIS2_FREE(env->allocator, handler_desc_impl->handler_desc.ops);
- handler_desc_impl->handler_desc.ops = NULL;
- }
-
- if (handler_desc_impl->handler_desc.param_container)
+ if (handler_desc->param_container)
{
- AXIS2_PARAM_CONTAINER_FREE(handler_desc_impl->handler_desc.
- param_container, env);
- handler_desc_impl->handler_desc.param_container = NULL;
+ AXIS2_PARAM_CONTAINER_FREE(handler_desc-> param_container, env);
+ handler_desc->param_container = NULL;
}
- if (handler_desc_impl->name)
+ if (handler_desc->name)
{
- axis2_string_free(handler_desc_impl->name, env);
- handler_desc_impl->name = NULL;
+ axis2_string_free(handler_desc->name, env);
+ handler_desc->name = NULL;
}
- if (handler_desc_impl->rules)
+ if (handler_desc->rules)
{
- AXIS2_PHASE_RULE_FREE(handler_desc_impl->rules, env);
- handler_desc_impl->rules = NULL;
+ AXIS2_PHASE_RULE_FREE(handler_desc->rules, env);
+ handler_desc->rules = NULL;
}
- if (handler_desc_impl->handler)
+ if (handler_desc->handler)
{
- AXIS2_HANDLER_FREE(handler_desc_impl->handler, env);
- handler_desc_impl->handler = NULL;
+ AXIS2_HANDLER_FREE(handler_desc->handler, env);
+ handler_desc->handler = NULL;
}
- if (handler_desc_impl->class_name)
+ if (handler_desc->class_name)
{
- AXIS2_FREE(env->allocator, handler_desc_impl->class_name);
- handler_desc_impl->class_name = NULL;
+ AXIS2_FREE(env->allocator, handler_desc->class_name);
+ handler_desc->class_name = NULL;
}
- if (handler_desc_impl)
+ if (handler_desc)
{
- AXIS2_FREE(env->allocator, handler_desc_impl);
- handler_desc_impl = NULL;
+ AXIS2_FREE(env->allocator, handler_desc);
+ handler_desc = NULL;
}
return AXIS2_SUCCESS;
}
+
+
+AXIS2_EXTERN axis2_param_container_t *AXIS2_CALL
+axis2_handler_desc_get_param_container(const axis2_handler_desc_t *handler_desc,
+ const axis2_env_t *env)
+{
+ return handler_desc->param_container;
+}
+
+
Modified: webservices/axis2/trunk/c/modules/core/description/module_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/module_desc.c?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/module_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/module_desc.c Sun Mar 4 20:11:56 2007
@@ -18,9 +18,8 @@
#include <axis2_module_desc.h>
#include <axis2_module.h>
-typedef struct axis2_module_desc_impl
+struct axis2_module_desc
{
- axis2_module_desc_t module_desc;
axis2_module_t *module;
axis2_qname_t *qname;
axis2_conf_t *parent;
@@ -29,215 +28,67 @@
* the module is engaged to a service
*/
axis2_hash_t *ops;
+ /**
+ * flow container that encapsulates the flows associated with the
+ * module
+ */
+ axis2_flow_container_t *flow_container;
+ /**
+ * parameter container that stores all the parameters associated with
+ * the module
+ */
+ axis2_param_container_t *params;
+};
-}
-axis2_module_desc_impl_t;
-
-#define AXIS2_INTF_TO_IMPL(module_desc) ((axis2_module_desc_impl_t *)module_desc)
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_free(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_flow_t *AXIS2_CALL
-axis2_module_desc_get_in_flow(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_in_flow(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_flow_t *in_flow);
-
-axis2_flow_t *AXIS2_CALL
-axis2_module_desc_get_out_flow(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_out_flow(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_flow_t *out_flow);
-
-axis2_flow_t *AXIS2_CALL
-axis2_module_desc_get_fault_in_flow(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_fault_in_flow(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_flow_t *falut_in_flow);
-
-axis2_flow_t *AXIS2_CALL
-axis2_module_desc_get_fault_out_flow(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_fault_out_flow(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_flow_t *fault_out_flow);
-
-const axis2_qname_t *AXIS2_CALL
-axis2_module_desc_get_qname(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_qname(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- const axis2_qname_t *qname);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_add_op(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_op_t *op);
-
-axis2_hash_t *AXIS2_CALL
-axis2_module_desc_get_all_ops(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_conf_t *AXIS2_CALL
-axis2_module_desc_get_parent(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_parent(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_conf_t *parent);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_add_param(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_param_t *param);
-
-axis2_param_t *AXIS2_CALL
-axis2_module_desc_get_param(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
-axis2_array_list_t *AXIS2_CALL
-axis2_module_desc_get_all_params(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_module_desc_is_param_locked(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
-axis2_module_t *AXIS2_CALL
-axis2_module_desc_get_module(
- const axis2_module_desc_t *module_desc,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_module_desc_set_module(
- axis2_module_desc_t *module_desc,
- const axis2_env_t *env,
- axis2_module_t *module);
-
-axis2_module_desc_t *AXIS2_CALL
+AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL
axis2_module_desc_create(
const axis2_env_t *env)
{
- axis2_module_desc_impl_t *module_desc_impl = NULL;
+ axis2_module_desc_t *module_desc = NULL;
AXIS2_ENV_CHECK(env, NULL);
- module_desc_impl = (axis2_module_desc_impl_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axis2_module_desc_impl_t));
+ module_desc = (axis2_module_desc_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_module_desc_t));
- if (NULL == module_desc_impl)
+ if (NULL == module_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- module_desc_impl->qname = NULL;
- module_desc_impl->module = NULL;
- module_desc_impl->parent = NULL;
- module_desc_impl->module_desc.params = NULL;
- module_desc_impl->module_desc.flow_container = NULL;
- module_desc_impl->ops = NULL;
+ module_desc->qname = NULL;
+ module_desc->module = NULL;
+ module_desc->parent = NULL;
+ module_desc->params = NULL;
+ module_desc->flow_container = NULL;
+ module_desc->ops = NULL;
- module_desc_impl->module_desc.params = axis2_param_container_create(env);
- if (NULL == module_desc_impl->module_desc.params)
+ module_desc->params = axis2_param_container_create(env);
+ if (NULL == module_desc->params)
{
- axis2_module_desc_free(&(module_desc_impl->module_desc), env);
+ axis2_module_desc_free(module_desc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- module_desc_impl->module_desc.flow_container = axis2_flow_container_create(env);
- if (NULL == module_desc_impl->module_desc.flow_container)
+ module_desc->flow_container = axis2_flow_container_create(env);
+ if (NULL == module_desc->flow_container)
{
- axis2_module_desc_free(&(module_desc_impl->module_desc), env);
+ axis2_module_desc_free(module_desc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE)
return NULL;
}
- module_desc_impl->ops = axis2_hash_make(env);
- if (NULL == module_desc_impl->ops)
- {
- axis2_module_desc_free(&(module_desc_impl->module_desc), env);
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
- }
-
- module_desc_impl->module_desc.ops =
- AXIS2_MALLOC(env->allocator, sizeof(axis2_module_desc_ops_t));
- if (NULL == module_desc_impl->module_desc.ops)
+ module_desc->ops = axis2_hash_make(env);
+ if (NULL == module_desc->ops)
{
- axis2_module_desc_free(&(module_desc_impl->module_desc), env);
+ axis2_module_desc_free(module_desc, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- module_desc_impl->module_desc.ops->free = axis2_module_desc_free;
- module_desc_impl->module_desc.ops->get_in_flow = axis2_module_desc_get_in_flow;
- module_desc_impl->module_desc.ops->set_in_flow = axis2_module_desc_set_in_flow;
- module_desc_impl->module_desc.ops->get_out_flow = axis2_module_desc_get_out_flow;
- module_desc_impl->module_desc.ops->set_out_flow = axis2_module_desc_set_out_flow;
- module_desc_impl->module_desc.ops->get_module = axis2_module_desc_get_module;
- module_desc_impl->module_desc.ops->set_module = axis2_module_desc_set_module;
- module_desc_impl->module_desc.ops->get_fault_in_flow =
- axis2_module_desc_get_fault_in_flow;
- module_desc_impl->module_desc.ops->set_fault_in_flow =
- axis2_module_desc_set_fault_in_flow;
- module_desc_impl->module_desc.ops->get_fault_out_flow =
- axis2_module_desc_get_fault_out_flow;
- module_desc_impl->module_desc.ops->set_fault_out_flow =
- axis2_module_desc_set_fault_out_flow;
- module_desc_impl->module_desc.ops->get_qname = axis2_module_desc_get_qname;
- module_desc_impl->module_desc.ops->set_qname = axis2_module_desc_set_qname;
- module_desc_impl->module_desc.ops->add_op =
- axis2_module_desc_add_op;
- module_desc_impl->module_desc.ops->get_all_ops =
- axis2_module_desc_get_all_ops;
- module_desc_impl->module_desc.ops->get_parent = axis2_module_desc_get_parent;
- module_desc_impl->module_desc.ops->set_parent = axis2_module_desc_set_parent;
- module_desc_impl->module_desc.ops->add_param = axis2_module_desc_add_param;
- module_desc_impl->module_desc.ops->get_param = axis2_module_desc_get_param;
- module_desc_impl->module_desc.ops->get_all_params = axis2_module_desc_get_all_params;
- module_desc_impl->module_desc.ops->is_param_locked =
- axis2_module_desc_is_param_locked;
-
- return &(module_desc_impl->module_desc);
+ return module_desc;
}
AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL
@@ -245,37 +96,33 @@
const axis2_env_t *env,
const axis2_qname_t *qname)
{
- axis2_module_desc_impl_t *module_desc_impl = NULL;
+ axis2_module_desc_t *module_desc = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, qname, NULL);
- module_desc_impl = AXIS2_INTF_TO_IMPL(axis2_module_desc_create(env));
- if (NULL == module_desc_impl)
+ module_desc = axis2_module_desc_create(env);
+ if (NULL == module_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- module_desc_impl->qname = (axis2_qname_t *)qname;
+ module_desc->qname = (axis2_qname_t *)qname;
- return &(module_desc_impl->module_desc);
+ return module_desc;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_free(
axis2_module_desc_t *module_desc,
const axis2_env_t *env)
{
- axis2_module_desc_impl_t *module_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- module_desc_impl = AXIS2_INTF_TO_IMPL(module_desc);
-
- if (module_desc_impl->module)
+ if (module_desc->module)
{
- AXIS2_MODULE_SHUTDOWN(module_desc_impl->module, env);
- module_desc_impl->module = NULL;
+ AXIS2_MODULE_SHUTDOWN(module_desc->module, env);
+ module_desc->module = NULL;
}
if (module_desc->params)
@@ -290,19 +137,19 @@
module_desc->flow_container = NULL;
}
- module_desc_impl->parent = NULL;
+ module_desc->parent = NULL;
- if (module_desc_impl->qname)
+ if (module_desc->qname)
{
- AXIS2_QNAME_FREE(module_desc_impl->qname, env);
- module_desc_impl->qname = NULL;
+ AXIS2_QNAME_FREE(module_desc->qname, env);
+ module_desc->qname = NULL;
}
- if (module_desc_impl->ops)
+ if (module_desc->ops)
{
axis2_hash_index_t *hi = NULL;
void *val = NULL;
- for (hi = axis2_hash_first(module_desc_impl->ops, env); hi;
+ for (hi = axis2_hash_first(module_desc->ops, env); hi;
hi = axis2_hash_next(env, hi))
{
struct axis2_op * op = NULL;
@@ -314,26 +161,20 @@
op = NULL;
}
- axis2_hash_free(module_desc_impl->ops, env);
- module_desc_impl->ops = NULL;
- }
-
- if (module_desc->ops)
- {
- AXIS2_FREE(env->allocator, module_desc->ops);
+ axis2_hash_free(module_desc->ops, env);
module_desc->ops = NULL;
}
- if (module_desc_impl)
+ if (module_desc)
{
- AXIS2_FREE(env->allocator, module_desc_impl);
- module_desc_impl = NULL;
+ AXIS2_FREE(env->allocator, module_desc);
+ module_desc = NULL;
}
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_free_void_arg(
void *module_desc,
const axis2_env_t *env)
@@ -345,7 +186,7 @@
return axis2_module_desc_free(module_desc_l, env);
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_module_desc_get_in_flow(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
@@ -355,7 +196,7 @@
return AXIS2_FLOW_CONTAINER_GET_IN_FLOW(module_desc->flow_container, env);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_in_flow(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -368,7 +209,7 @@
in_flow);
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_module_desc_get_out_flow(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
@@ -378,7 +219,7 @@
return AXIS2_FLOW_CONTAINER_GET_OUT_FLOW(module_desc->flow_container, env);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_out_flow(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -391,7 +232,7 @@
out_flow);
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_module_desc_get_fault_in_flow(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
@@ -401,7 +242,7 @@
return AXIS2_FLOW_CONTAINER_GET_FAULT_IN_FLOW(module_desc->flow_container, env);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_fault_in_flow(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -414,7 +255,7 @@
env, falut_in_flow);
}
-axis2_flow_t *AXIS2_CALL
+AXIS2_EXTERN axis2_flow_t *AXIS2_CALL
axis2_module_desc_get_fault_out_flow(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
@@ -423,7 +264,7 @@
return AXIS2_FLOW_CONTAINER_GET_FAULT_OUT_FLOW(module_desc->flow_container, env);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_fault_out_flow(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -436,57 +277,52 @@
env, fault_out_flow);
}
-const axis2_qname_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_qname_t *AXIS2_CALL
axis2_module_desc_get_qname(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(module_desc)->qname;
+ return module_desc->qname;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_qname(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
const axis2_qname_t *qname)
{
- axis2_module_desc_impl_t *module_desc_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
- module_desc_impl = AXIS2_INTF_TO_IMPL(module_desc);
- if (module_desc_impl->qname)
+ if (module_desc->qname)
{
- AXIS2_QNAME_FREE(module_desc_impl->qname, env);
- module_desc_impl->qname = NULL;
+ AXIS2_QNAME_FREE(module_desc->qname, env);
+ module_desc->qname = NULL;
}
- module_desc_impl->qname = AXIS2_QNAME_CLONE((axis2_qname_t *)qname, env);
+ module_desc->qname = AXIS2_QNAME_CLONE((axis2_qname_t *)qname, env);
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_add_op(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
axis2_op_t *op)
{
- axis2_module_desc_impl_t *module_desc_impl = NULL;
const axis2_qname_t *op_qname = NULL;
axis2_char_t *op_name = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
- module_desc_impl = AXIS2_INTF_TO_IMPL(module_desc);
- if (NULL == (module_desc_impl->ops))
+ if (NULL == (module_desc->ops))
{
- module_desc_impl->ops = axis2_hash_make(env);
- if (!module_desc_impl->ops)
+ module_desc->ops = axis2_hash_make(env);
+ if (!module_desc->ops)
return AXIS2_FAILURE;
}
@@ -497,30 +333,30 @@
return AXIS2_FAILURE;
}
op_name = AXIS2_QNAME_TO_STRING((axis2_qname_t *)op_qname, env);
- axis2_hash_set(module_desc_impl->ops, op_name, AXIS2_HASH_KEY_STRING, op);
+ axis2_hash_set(module_desc->ops, op_name, AXIS2_HASH_KEY_STRING, op);
return AXIS2_SUCCESS;
}
-axis2_hash_t *AXIS2_CALL
+AXIS2_EXTERN axis2_hash_t *AXIS2_CALL
axis2_module_desc_get_all_ops(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(module_desc)->ops;
+ return module_desc->ops;
}
-axis2_conf_t *AXIS2_CALL
+AXIS2_EXTERN axis2_conf_t *AXIS2_CALL
axis2_module_desc_get_parent(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(module_desc)->parent;
+ return module_desc->parent;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_parent(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -529,11 +365,11 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(module_desc)->parent = parent;
+ module_desc->parent = parent;
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_add_param(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -564,7 +400,7 @@
return ret_status;
}
-axis2_param_t *AXIS2_CALL
+AXIS2_EXTERN axis2_param_t *AXIS2_CALL
axis2_module_desc_get_param(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -576,7 +412,7 @@
return AXIS2_PARAM_CONTAINER_GET_PARAM(module_desc->params, env, name);
}
-axis2_array_list_t *AXIS2_CALL
+AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
axis2_module_desc_get_all_params(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
@@ -586,13 +422,12 @@
return AXIS2_PARAM_CONTAINER_GET_PARAMS(module_desc->params, env);
}
-axis2_bool_t AXIS2_CALL
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_module_desc_is_param_locked(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env,
const axis2_char_t *param_name)
{
- axis2_module_desc_impl_t *module_desc_impl = NULL;
axis2_bool_t locked = AXIS2_FALSE;
axis2_bool_t ret_state = AXIS2_FALSE;
axis2_param_t *param_l = NULL;
@@ -600,14 +435,13 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);
- module_desc_impl = AXIS2_INTF_TO_IMPL(module_desc);
/* checking the locked value of parent*/
- if (NULL == module_desc_impl->parent)
+ if (NULL == module_desc->parent)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MODULE_DESC, AXIS2_FAILURE);
return AXIS2_FALSE;
}
- locked = AXIS2_CONF_IS_PARAM_LOCKED(module_desc_impl->parent, env, param_name);
+ locked = AXIS2_CONF_IS_PARAM_LOCKED(module_desc->parent, env, param_name);
if (AXIS2_TRUE == locked)
{
@@ -626,16 +460,16 @@
return ret_state;
}
-axis2_module_t *AXIS2_CALL
+AXIS2_EXTERN axis2_module_t *AXIS2_CALL
axis2_module_desc_get_module(
const axis2_module_desc_t *module_desc,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(module_desc)->module;
+ return module_desc->module;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_module_desc_set_module(
axis2_module_desc_t *module_desc,
const axis2_env_t *env,
@@ -643,6 +477,21 @@
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, module, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(module_desc)->module = module;
+ module_desc->module = module;
return AXIS2_SUCCESS;
}
+
+AXIS2_EXTERN axis2_param_container_t *AXIS2_CALL
+axis2_module_desc_get_param_container(const axis2_module_desc_t *module_desc,
+ const axis2_env_t *env)
+{
+ return module_desc->params;
+}
+
+AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL
+axis2_module_desc_get_flow_container(const axis2_module_desc_t *module_desc,
+ const axis2_env_t *env)
+{
+ return module_desc->flow_container;
+}
+
Modified: webservices/axis2/trunk/c/modules/core/description/msg.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/msg.c?view=diff&rev=514539&r1=514538&r2=514539
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/msg.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/msg.c Sun Mar 4 20:11:56 2007
@@ -18,9 +18,8 @@
#include <axis2_msg.h>
#include <axis2_property.h>
-typedef struct axis2_msg_impl
+struct axis2_msg
{
- axis2_msg_t msg;
/** parent operation */
axis2_op_t *parent;
/** list of phases that represent the flow */
@@ -31,200 +30,82 @@
axis2_qname_t *element_qname;
/** direction of message */
axis2_char_t *direction;
-}
-axis2_msg_impl_t;
-
-#define AXIS2_INTF_TO_IMPL(msg) ((axis2_msg_impl_t *)msg)
-
-axis2_status_t AXIS2_CALL
-axis2_msg_free(
- axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_add_param(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- axis2_param_t *param);
-
-axis2_param_t *AXIS2_CALL
-axis2_msg_get_param(
- const axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
-axis2_array_list_t *AXIS2_CALL
-axis2_msg_get_all_params(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_bool_t AXIS2_CALL
-axis2_msg_is_param_locked(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *param_name);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_set_parent(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- axis2_op_t *op);
-
-axis2_op_t *AXIS2_CALL
-axis2_msg_get_parent(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_array_list_t *AXIS2_CALL
-axis2_msg_get_flow(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_set_flow(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- axis2_array_list_t *flow);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_get_direction(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_set_direction(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *direction);
-
-const axis2_qname_t *AXIS2_CALL
-axis2_msg_get_element_qname(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_set_element_qname(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_qname_t *element_qname);
-
-const axis2_char_t *AXIS2_CALL
-axis2_msg_get_name(
- const axis2_msg_t *msg,
- const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_msg_set_name(
- axis2_msg_t *msg,
- const axis2_env_t *env,
- const axis2_char_t *name);
-
-/*xml_schema_element_t *AXIS2_CALL
-axis2_msg_get_schema_element(
- const axis2_msg_t *msg,
- const axis2_env_t *env);*/
-
+ /** parameter container to hold message parameters */
+ struct axis2_param_container *param_container;
+};
AXIS2_EXTERN axis2_msg_t *AXIS2_CALL
axis2_msg_create(
const axis2_env_t *env)
{
- axis2_msg_impl_t *msg_impl = NULL;
+ axis2_msg_t *msg = NULL;
AXIS2_ENV_CHECK(env, NULL);
- msg_impl = (axis2_msg_impl_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axis2_msg_impl_t));
+ msg = (axis2_msg_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_msg_t));
- if (NULL == msg_impl)
+ if (NULL == msg)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- msg_impl->msg.param_container = NULL;
- msg_impl->parent = NULL;
- msg_impl->flow = NULL;
- msg_impl->name = NULL;
- msg_impl->element_qname = NULL;
- msg_impl->direction = NULL;
- msg_impl->msg.ops = NULL;
+ msg->param_container = NULL;
+ msg->parent = NULL;
+ msg->flow = NULL;
+ msg->name = NULL;
+ msg->element_qname = NULL;
+ msg->direction = NULL;
- msg_impl->msg.param_container = (axis2_param_container_t *)
+ msg->param_container = (axis2_param_container_t *)
axis2_param_container_create(env);
- if (NULL == msg_impl->msg.param_container)
+ if (NULL == msg->param_container)
{
- axis2_msg_free(&(msg_impl->msg), env);
+ axis2_msg_free(msg, env);
return NULL;
}
- msg_impl->flow = axis2_array_list_create(env, 0);
- if (NULL == msg_impl->flow)
+ msg->flow = axis2_array_list_create(env, 0);
+ if (NULL == msg->flow)
{
- axis2_msg_free(&(msg_impl->msg), env);
+ axis2_msg_free(msg, env);
return NULL;
}
- msg_impl->msg.ops = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_ops_t));
- if (NULL == msg_impl->msg.ops)
- {
- axis2_msg_free(&(msg_impl->msg), env);
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
- }
-
- msg_impl->msg.ops->free = axis2_msg_free;
- msg_impl->msg.ops->add_param = axis2_msg_add_param;
- msg_impl->msg.ops->get_param = axis2_msg_get_param;
- msg_impl->msg.ops->get_all_params = axis2_msg_get_all_params;
- msg_impl->msg.ops->is_param_locked = axis2_msg_is_param_locked;
- msg_impl->msg.ops->set_parent = axis2_msg_set_parent;
- msg_impl->msg.ops->get_parent = axis2_msg_get_parent;
- msg_impl->msg.ops->get_flow = axis2_msg_get_flow;
- msg_impl->msg.ops->set_flow = axis2_msg_set_flow;
- msg_impl->msg.ops->get_direction = axis2_msg_get_direction;
- msg_impl->msg.ops->set_direction = axis2_msg_set_direction;
- msg_impl->msg.ops->get_element_qname = axis2_msg_get_element_qname;
- msg_impl->msg.ops->set_element_qname = axis2_msg_set_element_qname;
- msg_impl->msg.ops->get_name = axis2_msg_get_name;
- msg_impl->msg.ops->set_name = axis2_msg_set_name;
- /*msg_impl->msg.ops->get_schema_element = axis2_msg_get_schema_element;*/
-
- return &(msg_impl->msg);
+ return msg;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_free(
axis2_msg_t *msg,
const axis2_env_t *env)
{
- axis2_msg_impl_t *msg_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
- if (msg_impl->flow)
+ if (msg->flow)
{
- AXIS2_ARRAY_LIST_FREE(msg_impl->flow, env);
- msg_impl->flow = NULL;
+ AXIS2_ARRAY_LIST_FREE(msg->flow, env);
+ msg->flow = NULL;
}
- if (msg_impl->name)
+ if (msg->name)
{
- AXIS2_FREE(env->allocator, msg_impl->name);
- msg_impl->name = NULL;
+ AXIS2_FREE(env->allocator, msg->name);
+ msg->name = NULL;
}
- if (msg_impl->element_qname)
+ if (msg->element_qname)
{
- AXIS2_QNAME_FREE(msg_impl->element_qname, env);
- msg_impl->element_qname = NULL;
+ AXIS2_QNAME_FREE(msg->element_qname, env);
+ msg->element_qname = NULL;
}
- if (msg_impl->direction)
+ if (msg->direction)
{
- AXIS2_FREE(env->allocator, msg_impl->direction);
- msg_impl->direction = NULL;
+ AXIS2_FREE(env->allocator, msg->direction);
+ msg->direction = NULL;
}
if (msg->param_container)
@@ -233,35 +114,27 @@
msg->param_container = NULL;
}
- msg_impl->parent = NULL;
+ msg->parent = NULL;
- if (msg_impl->msg.ops)
+ if (msg)
{
- AXIS2_FREE(env->allocator, msg_impl->msg.ops);
- msg_impl->msg.ops = NULL;
- }
-
- if (msg_impl)
- {
- AXIS2_FREE(env->allocator, msg_impl);
- msg_impl = NULL;
+ AXIS2_FREE(env->allocator, msg);
+ msg = NULL;
}
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_add_param(
axis2_msg_t *msg,
const axis2_env_t *env,
axis2_param_t *param)
{
- axis2_msg_impl_t *msg_impl = NULL;
axis2_char_t *param_name = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
param_name = AXIS2_PARAM_GET_NAME(param, env);
if (AXIS2_TRUE == axis2_msg_is_param_locked(msg, env, param_name))
@@ -278,7 +151,7 @@
return AXIS2_SUCCESS;
}
-axis2_param_t *AXIS2_CALL
+AXIS2_EXTERN axis2_param_t *AXIS2_CALL
axis2_msg_get_param(
const axis2_msg_t *msg,
const axis2_env_t *env,
@@ -290,51 +163,48 @@
return AXIS2_PARAM_CONTAINER_GET_PARAM(msg->param_container, env, param_name);
}
-axis2_array_list_t *AXIS2_CALL
+AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
axis2_msg_get_all_params(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
- axis2_msg_impl_t *msg_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
AXIS2_PARAM_CHECK(env->error, msg->param_container, AXIS2_FALSE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
return AXIS2_PARAM_CONTAINER_GET_PARAMS(msg->param_container, env);
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_set_parent(
axis2_msg_t *msg,
const axis2_env_t *env,
axis2_op_t *op)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(msg)->parent = op;
+ msg->parent = op;
return AXIS2_SUCCESS;
}
-axis2_op_t *AXIS2_CALL
+AXIS2_EXTERN axis2_op_t *AXIS2_CALL
axis2_msg_get_parent(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(msg)->parent;
+ return msg->parent;
}
-axis2_array_list_t *AXIS2_CALL
+AXIS2_EXTERN axis2_array_list_t *AXIS2_CALL
axis2_msg_get_flow(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- return AXIS2_INTF_TO_IMPL(msg)->flow;
+ return msg->flow;
}
-axis2_bool_t AXIS2_CALL
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_msg_is_param_locked(
axis2_msg_t *msg,
const axis2_env_t *env,
@@ -364,95 +234,85 @@
return (param_l && AXIS2_PARAM_IS_LOCKED(param_l, env));
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_set_flow(
axis2_msg_t *msg,
const axis2_env_t *env,
axis2_array_list_t *flow)
{
- axis2_msg_impl_t *msg_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
-
- if (msg_impl->flow)
+ if (msg->flow)
{
- AXIS2_ARRAY_LIST_FREE(msg_impl->flow, env);
- msg_impl->flow = NULL;
+ AXIS2_ARRAY_LIST_FREE(msg->flow, env);
+ msg->flow = NULL;
}
if (flow)
{
- msg_impl->flow = flow;
+ msg->flow = flow;
}
return AXIS2_SUCCESS;
}
-const axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axis2_msg_get_direction(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return AXIS2_INTF_TO_IMPL(msg)->direction;
+ return msg->direction;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_set_direction(
axis2_msg_t *msg,
const axis2_env_t *env,
const axis2_char_t *direction)
{
- axis2_msg_impl_t *msg_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
- if (msg_impl->direction)
+ if (msg->direction)
{
- AXIS2_FREE(env->allocator, msg_impl->direction);
- msg_impl->direction = NULL;
+ AXIS2_FREE(env->allocator, msg->direction);
+ msg->direction = NULL;
}
if (direction)
{
- msg_impl->direction = AXIS2_STRDUP(direction, env);
- if (!(msg_impl->direction))
+ msg->direction = AXIS2_STRDUP(direction, env);
+ if (!(msg->direction))
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
-const axis2_qname_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_qname_t *AXIS2_CALL
axis2_msg_get_element_qname(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return AXIS2_INTF_TO_IMPL(msg)->element_qname;
+ return msg->element_qname;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_set_element_qname(
axis2_msg_t *msg,
const axis2_env_t *env,
const axis2_qname_t *element_qname)
{
- axis2_msg_impl_t *msg_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
- if (msg_impl->element_qname)
+ if (msg->element_qname)
{
- AXIS2_QNAME_FREE(msg_impl->element_qname, env);
- msg_impl->element_qname = NULL;
+ AXIS2_QNAME_FREE(msg->element_qname, env);
+ msg->element_qname = NULL;
}
if (element_qname)
{
- msg_impl->element_qname = AXIS2_QNAME_CLONE((axis2_qname_t *)element_qname, env);
- if (!(msg_impl->element_qname))
+ msg->element_qname = AXIS2_QNAME_CLONE((axis2_qname_t *)element_qname, env);
+ if (!(msg->element_qname))
return AXIS2_FAILURE;
}
@@ -460,12 +320,11 @@
}
-/*xml_schema_element_t *AXIS2_CALL
+/*AXIS2_EXTERN xml_schema_element_t *AXIS2_CALL
axis2_msg_get_schema_element(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
- axis2_msg_impl_t *msg_impl = NULL;
axis2_op_t *operation = NULL;
axis2_svc_t *svc = NULL;
axis2_array_list_t *schemas = NULL;
@@ -474,7 +333,6 @@
AXIS2_ENV_CHECK(env, NULL);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
operation = axis2_msg_get_parent(msg, env);
svc = AXIS2_OP_GET_PARENT(operation, env);
schemas = AXIS2_SVC_GET_ALL_SCHEMAS(svc, env);
@@ -502,8 +360,8 @@
{
axis2_qname_t *schema_qname = NULL;
schema_qname = XML_SCHEMA_ELEMENT_GET_QNAME(schema_obj, env);
- if (msg_impl->element_qname && AXIS2_TRUE ==
- AXIS2_QNAME_EQUALS(msg_impl->element_qname, env,
+ if (msg->element_qname && AXIS2_TRUE ==
+ AXIS2_QNAME_EQUALS(msg->element_qname, env,
schema_qname))
{
return (xml_schema_element_t*)schema_obj;
@@ -515,36 +373,33 @@
return NULL;
}*/
-const axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axis2_msg_get_name(
const axis2_msg_t *msg,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return AXIS2_INTF_TO_IMPL(msg)->name;
+ return msg->name;
}
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_msg_set_name(
axis2_msg_t *msg,
const axis2_env_t *env,
const axis2_char_t *name)
{
- axis2_msg_impl_t *msg_impl = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- msg_impl = AXIS2_INTF_TO_IMPL(msg);
- if (msg_impl->name)
+ if (msg->name)
{
- AXIS2_FREE(env->allocator, msg_impl->name);
- msg_impl->name = NULL;
+ AXIS2_FREE(env->allocator, msg->name);
+ msg->name = NULL;
}
if (name)
{
- msg_impl->name = AXIS2_STRDUP(name, env);
- if (!(msg_impl->name))
+ msg->name = AXIS2_STRDUP(name, env);
+ if (!(msg->name))
{
return AXIS2_FAILURE;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org