You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by sa...@apache.org on 2006/08/24 17:41:43 UTC
svn commit: r434404 - in /webservices/axis2/trunk/c: include/
modules/core/deployment/ modules/core/description/ modules/core/engine/
modules/core/phaseresolver/
Author: samisa
Date: Thu Aug 24 08:41:40 2006
New Revision: 434404
URL: http://svn.apache.org/viewvc?rev=434404&view=rev
Log:
Fixed API and doc comments in phase rule
Modified:
webservices/axis2/trunk/c/include/axis2_phase_holder.h
webservices/axis2/trunk/c/include/axis2_phase_rule.h
webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
webservices/axis2/trunk/c/modules/core/description/phase_rule.c
webservices/axis2/trunk/c/modules/core/engine/phase.c
webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c
webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c
Modified: webservices/axis2/trunk/c/include/axis2_phase_holder.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phase_holder.h?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_phase_holder.h (original)
+++ webservices/axis2/trunk/c/include/axis2_phase_holder.h Thu Aug 24 08:41:40 2006
@@ -82,7 +82,7 @@
is_phase_exist)(
axis2_phase_holder_t *phase_holder,
const axis2_env_t *env,
- axis2_char_t *phase_name);
+ const axis2_char_t *phase_name);
/**
* @param phase_holder pointer to phase holder
@@ -107,7 +107,7 @@
get_phase)(
const axis2_phase_holder_t *phase_holder,
const axis2_env_t *env,
- axis2_char_t *phase_name);
+ const axis2_char_t *phase_name);
/**
* This method is to build the transport phase , here load the corresponding
Modified: webservices/axis2/trunk/c/include/axis2_phase_rule.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/include/axis2_phase_rule.h?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/include/axis2_phase_rule.h (original)
+++ webservices/axis2/trunk/c/include/axis2_phase_rule.h Thu Aug 24 08:41:40 2006
@@ -18,14 +18,18 @@
#define AXIS2_PHASE_RULE_H
/**
- * @defgroup axis2_phase_rule phase rules
+ * @defgroup axis2_phase_rule phase rule
* @ingroup axis2_desc
+ * phase rule encapsulates data and operations related to phase rules for a
+ * given handler. phase rule lives within a handler.
+ * phase rules of a handler specify the relative location of the
+ * handler within the phase to which it belongs, with respect to other handlers
+ * in the phase or first and last positions of the handler chain of the phase.
* @{
*/
/**
* @file axis2_phase_rule.h
- * @brief Axis2 phase_rule interface
*/
#include <axis2_defines.h>
@@ -44,206 +48,244 @@
/**
- * Phase Rule ops struct
+ * phase rule ops struct.
+ * Encapsulator struct for ops of axis2_phase_rule.
*/
struct axis2_phase_rule_ops
{
/**
+ * Gets the name of the handler before which the handler associated with
+ * this rule should be placed.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return name of handler before which the handler should be placed
*/
- axis2_char_t *(AXIS2_CALL *
+ const axis2_char_t *(AXIS2_CALL *
get_before)(
const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
/**
+ * Sets the name of the handler before which the handler associated with
+ * this rule should be placed.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
- * @param before before
+ * @param before name of handler before which the handler should be placed
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
set_before)(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env,
const axis2_char_t *before);
/**
+ * Gets the name of the handler after which the handler associated with
+ * this rule should be placed.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return name of handler after which the handler should be placed
*/
- axis2_char_t *(AXIS2_CALL *
+ const axis2_char_t *(AXIS2_CALL *
get_after)(
const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
/**
+ * Sets the name of the handler after which the handler associated with
+ * this rule should be placed.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
- * @param after after
+ * @param after name of handler after which the handler should be placed
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
set_after)(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env,
const axis2_char_t *after);
/**
+ * Gets name.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return name string
*/
- axis2_char_t *(AXIS2_CALL *
+ const axis2_char_t *(AXIS2_CALL *
get_name)(
const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
/**
+ * Sets name.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
- * @param name pointer to name
+ * @param name name string
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
set_name)(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env,
const axis2_char_t *name);
/**
+ * Checks if the handler is the first in phase.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return AXIS2_TRUE if the handler associated with this rule is the
+ * first in phase, else AXIS2_FALSE
*/
axis2_bool_t (AXIS2_CALL *
- is_phase_first)(
- struct axis2_phase_rule *phase_rule,
+ is_first)(
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
/**
+ * Sets handler to be the first in phase.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
- * @param phase_first phase first
+ * @param first AXIS2_TRUE if the handler associated with this rule is the
+ * first in phase, else AXIS2_FALSE
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
- set_phase_first)(
- struct axis2_phase_rule *phase_rule,
+ set_first)(
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env,
- axis2_bool_t phase_first);
+ axis2_bool_t first);
/**
+ * Checks if the handler is the last in phase.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return AXIS2_TRUE if the handler associated with this rule is the
+ * last in phase, else AXIS2_FALSE
*/
axis2_bool_t (AXIS2_CALL *
- is_phase_last)(
- struct axis2_phase_rule *phase_rule,
+ is_last)(
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
/**
+ * Sets handler to be the last in phase.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
- * @param phase_last phsae last
+ * @param last AXIS2_TRUE if the handler associated with this rule is the
+ * last in phase, else AXIS2_FALSE
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
- set_phase_last)(
- struct axis2_phase_rule *phase_rule,
+ set_last)(
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env,
- axis2_bool_t phase_last);
+ axis2_bool_t last);
/**
+ * Frees phase rule.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
*/
axis2_status_t (AXIS2_CALL *
free)(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
/**
+ * Clones phase rule.
* @param phase_rule pointer to phase rule
* @param env pointer to environment struct
+ * @return pointer to newly cloned phase rule
*/
- struct axis2_phase_rule *(AXIS2_CALL *
+ axis2_phase_rule_t *(AXIS2_CALL *
clone)(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
};
/**
- * Phase Rule struct
+ * phase rule struct.
*/
struct axis2_phase_rule
{
- /** Phase Rule related ops */
+ /** phase rule related ops */
axis2_phase_rule_ops_t *ops;
};
/**
- * creates phase_rule struct
+ * Creates a phase rule struct instance.
* @param env pointer to environment struct
- * @param phase_name pointer to phase name
+ * @param phase_name name of the phase rule
+ * @return pointer to newly created phase rule
*/
AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
axis2_phase_rule_create(
const axis2_env_t *env,
- const axis2_char_t *phase_name);
+ const axis2_char_t *name);
-/** Get before.
+/** Gets name of the handler before which the handler associated with this rule
+ is to be placed.
@sa axis2_phase_rule_ops#get_before */
#define AXIS2_PHASE_RULE_GET_BEFORE(phase_rule, env) \
((phase_rule)->ops->get_before(phase_rule, env))
-/** Set before.
+/** Sets name of the handler before which the handler associated with this rule
+ is to be placed.
@sa axis2_phase_rule_ops#set_before */
#define AXIS2_PHASE_RULE_SET_BEFORE(phase_rule, env, before) \
((phase_rule)->ops->set_before(phase_rule, env, before))
-/** Get after.
+/** Gets name of the handler after which the handler associated with this rule
+ is to be placed.
@sa axis2_phase_rule_ops#get_after */
#define AXIS2_PHASE_RULE_GET_AFTER(phase_rule, env) \
((phase_rule)->ops->get_after(phase_rule, env))
-/** Set after.
+/** Sets name of the handler after which the handler associated with this rule
+ is to be placed.
@sa axis2_phase_rule_ops#set_after */
#define AXIS2_PHASE_RULE_SET_AFTER(phase_rule, env, after) \
((phase_rule)->ops->set_after(phase_rule, env, after))
-/** Get name.
+/** Gets name.
@sa axis2_phase_rule_ops#get_name */
#define AXIS2_PHASE_RULE_GET_NAME(phase_rule, env) \
((phase_rule)->ops->get_name(phase_rule, env))
-/** Set name.
+/** Sets name.
@sa axis2_phase_rule_ops#set_name */
#define AXIS2_PHASE_RULE_SET_NAME(phase_rule, env, name)\
((phase_rule)->ops->set_name(phase_rule, env, name))
-/** Is phase first.
- @sa axis2_phase_rule_ops#is_phase_first */
-#define AXIS2_PHASE_RULE_IS_PHASE_FIRST(phase_rule, env) \
- ((phase_rule)->ops->is_phase_first(phase_rule, env))
-
-/** Set phase first.
- @sa axis2_phase_rule_ops#set_phase_first */
-#define AXIS2_PHASE_RULE_SET_PHASE_FIRST(phase_rule, env, phase_first) \
- ((phase_rule)->ops->set_phase_first(phase_rule, env, phase_first))
-
-/** Is phase last.
- @sa axis2_phase_rule_ops#is_phase_last */
-#define AXIS2_PHASE_RULE_IS_PHASE_LAST(phase_rule, env) \
- ((phase_rule)->ops->is_phase_last(phase_rule, env))
-
-/** Set phase last.
- @sa axis2_phase_rule_ops#set_phase_last */
-#define AXIS2_PHASE_RULE_SET_PHASE_LAST(phase_rule, env, phase_last) \
- ((phase_rule)->ops->set_phase_last(phase_rule, env, phase_last))
+/** Checks if the associated handler is the first in phase.
+ @sa axis2_phase_rule_ops#is_first */
+#define AXIS2_PHASE_RULE_IS_FIRST(phase_rule, env) \
+ ((phase_rule)->ops->is_first(phase_rule, env))
+
+/** Sets the associated handler to be the first in phase.
+ @sa axis2_phase_rule_ops#set_first */
+#define AXIS2_PHASE_RULE_SET_FIRST(phase_rule, env, first) \
+ ((phase_rule)->ops->set_first(phase_rule, env, first))
+
+/** Checks if the associated handler is the last in phase.
+ @sa axis2_phase_rule_ops#is_last */
+#define AXIS2_PHASE_RULE_IS_LAST(phase_rule, env) \
+ ((phase_rule)->ops->is_last(phase_rule, env))
+
+/** Sets the associated handler to be the last in phase.
+ @sa axis2_phase_rule_ops#set_last */
+#define AXIS2_PHASE_RULE_SET_LAST(phase_rule, env, last) \
+ ((phase_rule)->ops->set_last(phase_rule, env, last))
-/** Frees the phase rule.
+/** Frees phase rule.
@sa axis2_phase_rule_ops#free */
#define AXIS2_PHASE_RULE_FREE(phase_rule, env) \
((phase_rule)->ops->free(phase_rule, env))
-/** Clone.
+/** Clones given phase rule.
@sa axis2_phase_rule_ops#clone */
#define AXIS2_PHASE_RULE_CLONE(phase_rule, env) \
((phase_rule)->ops->clone(phase_rule, env))
Modified: webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c Thu Aug 24 08:41:40 2006
@@ -551,7 +551,7 @@
{
struct axis2_phase_rule *phase_rule = NULL;
phase_rule = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
- status = AXIS2_PHASE_RULE_SET_PHASE_FIRST(phase_rule, env,
+ status = AXIS2_PHASE_RULE_SET_FIRST(phase_rule, env,
AXIS2_TRUE);
if(AXIS2_SUCCESS != status)
{
@@ -564,7 +564,7 @@
{
struct axis2_phase_rule *phase_rule = NULL;
phase_rule = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
- status = AXIS2_PHASE_RULE_SET_PHASE_FIRST(phase_rule, env,
+ status = AXIS2_PHASE_RULE_SET_FIRST(phase_rule, env,
AXIS2_FALSE);
if(AXIS2_SUCCESS != status)
{
Modified: webservices/axis2/trunk/c/modules/core/description/phase_rule.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/phase_rule.c?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/phase_rule.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/phase_rule.c Thu Aug 24 08:41:40 2006
@@ -1,18 +1,18 @@
/*
- * Copyright 2004,2005 The Apache Software Foundation.
- *
- * Licensed 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.
- */
+* Copyright 2004,2005 The Apache Software Foundation.
+*
+* Licensed 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 <axis2_const.h>
#include <axis2_phase_rule.h>
@@ -20,19 +20,19 @@
typedef struct axis2_phase_rule_impl
{
- /** Phase Rule related ops */
- axis2_phase_rule_t phase_rule;
- /** name of phase or handler before */
- axis2_char_t *before;
- /** name of phase or handler after */
- axis2_char_t *after;
- /** phase name */
- axis2_char_t *name;
- /** Is this first phase? */
- axis2_bool_t phase_first;
- /** Is this last phase? */
- axis2_bool_t phase_last;
-
+ /** phase Rule related ops */
+ axis2_phase_rule_t phase_rule;
+ /** name of phase or handler before */
+ axis2_char_t *before;
+ /** name of phase or handler after */
+ axis2_char_t *after;
+ /** phase name */
+ axis2_char_t *name;
+ /** Is this first in phase? */
+ axis2_bool_t first;
+ /** Is this last in phase? */
+ axis2_bool_t last;
+
}
axis2_phase_rule_impl_t;
@@ -40,180 +40,180 @@
#define AXIS2_INTF_TO_IMPL(phase_rule) ((axis2_phase_rule_impl_t *)phase_rule)
-axis2_char_t *AXIS2_CALL
+const axis2_char_t *AXIS2_CALL
axis2_phase_rule_get_before(
- const axis2_phase_rule_t *phase_rule,
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
+
+axis2_status_t AXIS2_CALL
axis2_phase_rule_set_before(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
const axis2_char_t *before);
-
-axis2_char_t *AXIS2_CALL
+
+const axis2_char_t *AXIS2_CALL
axis2_phase_rule_get_after(
- const axis2_phase_rule_t *phase_rule,
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
+
+axis2_status_t AXIS2_CALL
axis2_phase_rule_set_after(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
const axis2_char_t *after);
-
-axis2_char_t *AXIS2_CALL
+
+const axis2_char_t *AXIS2_CALL
axis2_phase_rule_get_name(
- const axis2_phase_rule_t *phase_rule,
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_phase_rule_set_name(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_name(
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
const axis2_char_t *name);
-axis2_bool_t AXIS2_CALL
-axis2_phase_rule_is_phase_first(
- struct axis2_phase_rule *phase_rule,
+axis2_bool_t AXIS2_CALL
+axis2_phase_rule_is_first(
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-axis2_status_t AXIS2_CALL
-axis2_phase_rule_set_phase_first(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
- axis2_bool_t phase_first);
-
-axis2_bool_t AXIS2_CALL
-axis2_phase_rule_is_phase_last(
- struct axis2_phase_rule *phase_rule,
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_first(
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ axis2_bool_t first);
+
+axis2_bool_t AXIS2_CALL
+axis2_phase_rule_is_last(
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axis2_phase_rule_set_phase_last(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
- axis2_bool_t phase_last);
-
-axis2_status_t AXIS2_CALL
+
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_last(
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ axis2_bool_t last);
+
+axis2_status_t AXIS2_CALL
axis2_phase_rule_free(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-axis2_phase_rule_t *AXIS2_CALL
+axis2_phase_rule_t *AXIS2_CALL
axis2_phase_rule_clone(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env);
-
+
AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL
axis2_phase_rule_create(
- const axis2_env_t *env,
+ const axis2_env_t *env,
const axis2_char_t *name)
{
axis2_phase_rule_impl_t *phase_rule_impl = NULL;
-
+
AXIS2_ENV_CHECK(env, NULL);
-
+
phase_rule_impl = AXIS2_MALLOC( env->allocator, sizeof(axis2_phase_rule_impl_t) );
if (!phase_rule_impl)
- {
+ {
AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
- return NULL;
+ return NULL;
}
phase_rule_impl->before = NULL;
phase_rule_impl->after = NULL;
phase_rule_impl->name = NULL;
- phase_rule_impl->phase_first = AXIS2_FALSE;
- phase_rule_impl->phase_last = AXIS2_FALSE;
-
+ phase_rule_impl->first = AXIS2_FALSE;
+ phase_rule_impl->last = AXIS2_FALSE;
+
if (name)
{
phase_rule_impl->name = AXIS2_STRDUP(name, env);
}
-
+
/* initialize ops */
phase_rule_impl->phase_rule.ops = NULL;
- phase_rule_impl->phase_rule.ops = AXIS2_MALLOC( env->allocator, sizeof(axis2_phase_rule_ops_t) );
+ phase_rule_impl->phase_rule.ops = AXIS2_MALLOC( env->allocator, sizeof(axis2_phase_rule_ops_t) );
if (!phase_rule_impl->phase_rule.ops)
{
AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
axis2_phase_rule_free(&(phase_rule_impl->phase_rule), env);
- return NULL;
+ return NULL;
}
- phase_rule_impl->phase_rule.ops->get_before =
+ phase_rule_impl->phase_rule.ops->get_before =
axis2_phase_rule_get_before;
-
- phase_rule_impl->phase_rule.ops->set_before =
+
+ phase_rule_impl->phase_rule.ops->set_before =
axis2_phase_rule_set_before;
-
- phase_rule_impl->phase_rule.ops->get_after =
+
+ phase_rule_impl->phase_rule.ops->get_after =
axis2_phase_rule_get_after;
-
- phase_rule_impl->phase_rule.ops->set_after =
+
+ phase_rule_impl->phase_rule.ops->set_after =
axis2_phase_rule_set_after;
-
- phase_rule_impl->phase_rule.ops->get_name =
+
+ phase_rule_impl->phase_rule.ops->get_name =
axis2_phase_rule_get_name;
-
- phase_rule_impl->phase_rule.ops->set_name =
+
+ phase_rule_impl->phase_rule.ops->set_name =
axis2_phase_rule_set_name;
-
- phase_rule_impl->phase_rule.ops->is_phase_first =
- axis2_phase_rule_is_phase_first;
-
- phase_rule_impl->phase_rule.ops->set_phase_first =
- axis2_phase_rule_set_phase_first;
-
- phase_rule_impl->phase_rule.ops->is_phase_last =
- axis2_phase_rule_is_phase_last;
-
- phase_rule_impl->phase_rule.ops->set_phase_last =
- axis2_phase_rule_set_phase_last;
-
- phase_rule_impl->phase_rule.ops->free =
+
+ phase_rule_impl->phase_rule.ops->is_first =
+ axis2_phase_rule_is_first;
+
+ phase_rule_impl->phase_rule.ops->set_first =
+ axis2_phase_rule_set_first;
+
+ phase_rule_impl->phase_rule.ops->is_last =
+ axis2_phase_rule_is_last;
+
+ phase_rule_impl->phase_rule.ops->set_last =
+ axis2_phase_rule_set_last;
+
+ phase_rule_impl->phase_rule.ops->free =
axis2_phase_rule_free;
-
- phase_rule_impl->phase_rule.ops->clone =
+
+ phase_rule_impl->phase_rule.ops->clone =
axis2_phase_rule_clone;
return &(phase_rule_impl->phase_rule);
}
-axis2_char_t *AXIS2_CALL
+const axis2_char_t *AXIS2_CALL
axis2_phase_rule_get_before(
- const axis2_phase_rule_t *phase_rule,
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
-
+
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(phase_rule)->before;
}
-axis2_status_t AXIS2_CALL
+axis2_status_t AXIS2_CALL
axis2_phase_rule_set_before(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
const axis2_char_t *before)
{
axis2_phase_rule_impl_t *phase_rule_impl = NULL;
-
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
+
phase_rule_impl = AXIS2_INTF_TO_IMPL(phase_rule);
if (phase_rule_impl->before)
{
AXIS2_FREE(env->allocator, phase_rule_impl->before);
phase_rule_impl->before = NULL;
}
-
+
if (before)
{
- phase_rule_impl->before = AXIS2_STRDUP(before, env);
+ phase_rule_impl->before = AXIS2_STRDUP(before, env);
if (!phase_rule_impl->before)
{
AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
@@ -221,39 +221,39 @@
return AXIS2_FAILURE;
}
}
-
+
return AXIS2_SUCCESS;
}
-axis2_char_t *AXIS2_CALL
+const axis2_char_t *AXIS2_CALL
axis2_phase_rule_get_after(
- const axis2_phase_rule_t *phase_rule,
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(phase_rule)->after;
}
-axis2_status_t AXIS2_CALL
+axis2_status_t AXIS2_CALL
axis2_phase_rule_set_after(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
const axis2_char_t *after)
{
axis2_phase_rule_impl_t *phase_rule_impl = NULL;
-
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
+
phase_rule_impl = AXIS2_INTF_TO_IMPL(phase_rule);
if (phase_rule_impl->after)
{
AXIS2_FREE(env->allocator, phase_rule_impl->after);
phase_rule_impl->after = NULL;
}
-
+
if (after)
{
- phase_rule_impl->after = AXIS2_STRDUP(after, env);
+ phase_rule_impl->after = AXIS2_STRDUP(after, env);
if (!phase_rule_impl->after)
{
AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
@@ -261,39 +261,39 @@
return AXIS2_FAILURE;
}
}
-
+
return AXIS2_SUCCESS;
}
-axis2_char_t *AXIS2_CALL
+const axis2_char_t *AXIS2_CALL
axis2_phase_rule_get_name(
- const axis2_phase_rule_t *phase_rule,
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(phase_rule)->name;
}
-axis2_status_t AXIS2_CALL
+axis2_status_t AXIS2_CALL
axis2_phase_rule_set_name(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
const axis2_char_t *name)
{
axis2_phase_rule_impl_t *phase_rule_impl = NULL;
-
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
+
phase_rule_impl = AXIS2_INTF_TO_IMPL(phase_rule);
if (phase_rule_impl->name)
{
AXIS2_FREE(env->allocator, phase_rule_impl->name);
phase_rule_impl->name = NULL;
}
-
+
if (name)
{
- phase_rule_impl->name = AXIS2_STRDUP(name, env);
+ phase_rule_impl->name = AXIS2_STRDUP(name, env);
if (!phase_rule_impl->name)
{
AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
@@ -301,119 +301,119 @@
return AXIS2_FAILURE;
}
}
-
+
return AXIS2_SUCCESS;
}
-axis2_bool_t AXIS2_CALL
-axis2_phase_rule_is_phase_first(
- struct axis2_phase_rule *phase_rule,
+axis2_bool_t AXIS2_CALL
+axis2_phase_rule_is_first(
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return AXIS2_INTF_TO_IMPL(phase_rule)->phase_first;
+ return AXIS2_INTF_TO_IMPL(phase_rule)->first;
}
-axis2_status_t AXIS2_CALL
-axis2_phase_rule_set_phase_first(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
- axis2_bool_t phase_first)
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_first(
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ axis2_bool_t first)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(phase_rule)->phase_first = phase_first;
+ AXIS2_INTF_TO_IMPL(phase_rule)->first = first;
return AXIS2_SUCCESS;
}
-axis2_bool_t AXIS2_CALL
-axis2_phase_rule_is_phase_last(
- struct axis2_phase_rule *phase_rule,
+axis2_bool_t AXIS2_CALL
+axis2_phase_rule_is_last(
+ const axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return AXIS2_INTF_TO_IMPL(phase_rule)->phase_last;
+ return AXIS2_INTF_TO_IMPL(phase_rule)->last;
}
-axis2_status_t AXIS2_CALL
-axis2_phase_rule_set_phase_last(
- struct axis2_phase_rule *phase_rule,
- const axis2_env_t *env,
- axis2_bool_t phase_last)
+axis2_status_t AXIS2_CALL
+axis2_phase_rule_set_last(
+ axis2_phase_rule_t *phase_rule,
+ const axis2_env_t *env,
+ axis2_bool_t last)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(phase_rule)->phase_last = phase_last;
+ AXIS2_INTF_TO_IMPL(phase_rule)->last = last;
return AXIS2_SUCCESS;
}
-axis2_status_t AXIS2_CALL
+axis2_status_t AXIS2_CALL
axis2_phase_rule_free(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
{
axis2_phase_rule_impl_t *phase_rule_impl = NULL;
-
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
+
phase_rule_impl = AXIS2_INTF_TO_IMPL(phase_rule);
-
+
if (phase_rule_impl->phase_rule.ops)
{
AXIS2_FREE(env->allocator, phase_rule_impl->phase_rule.ops);
phase_rule_impl->phase_rule.ops = NULL;
}
-
+
if (phase_rule_impl->before)
{
AXIS2_FREE(env->allocator, phase_rule_impl->before);
phase_rule_impl->before = NULL;
- }
-
- if (phase_rule_impl->after)
+ }
+
+ if (phase_rule_impl->after)
{
AXIS2_FREE(env->allocator, phase_rule_impl->after);
phase_rule_impl->after = NULL;
}
-
+
if (phase_rule_impl->name)
{
AXIS2_FREE(env->allocator, phase_rule_impl->name);
phase_rule_impl->name = NULL;
}
-
+
AXIS2_FREE(env->allocator, phase_rule_impl);
phase_rule_impl = NULL;
-
+
return AXIS2_SUCCESS;
}
-axis2_phase_rule_t *AXIS2_CALL
+axis2_phase_rule_t *AXIS2_CALL
axis2_phase_rule_clone(
- struct axis2_phase_rule *phase_rule,
+ axis2_phase_rule_t *phase_rule,
const axis2_env_t *env)
{
axis2_phase_rule_t *phase_rule_new = NULL;
AXIS2_ENV_CHECK(env, NULL);
-
+
phase_rule_new = axis2_phase_rule_create(env, NULL);
if (!phase_rule_new)
return NULL;
-
- AXIS2_PHASE_RULE_SET_BEFORE(phase_rule_new, env,
- AXIS2_PHASE_RULE_GET_BEFORE(phase_rule, env));
-
- AXIS2_PHASE_RULE_SET_AFTER(phase_rule_new, env,
- AXIS2_PHASE_RULE_GET_AFTER(phase_rule, env));
-
- AXIS2_PHASE_RULE_SET_NAME(phase_rule_new, env,
- AXIS2_PHASE_RULE_GET_NAME(phase_rule, env));
-
- AXIS2_PHASE_RULE_SET_PHASE_FIRST(phase_rule_new, env,
- AXIS2_PHASE_RULE_IS_PHASE_FIRST(phase_rule, env) );
-
- AXIS2_PHASE_RULE_SET_PHASE_LAST(phase_rule_new, env,
- AXIS2_PHASE_RULE_IS_PHASE_LAST(phase_rule, env) );
-
+
+ AXIS2_PHASE_RULE_SET_BEFORE(phase_rule_new, env,
+ AXIS2_PHASE_RULE_GET_BEFORE(phase_rule, env));
+
+ AXIS2_PHASE_RULE_SET_AFTER(phase_rule_new, env,
+ AXIS2_PHASE_RULE_GET_AFTER(phase_rule, env));
+
+ AXIS2_PHASE_RULE_SET_NAME(phase_rule_new, env,
+ AXIS2_PHASE_RULE_GET_NAME(phase_rule, env));
+
+ AXIS2_PHASE_RULE_SET_FIRST(phase_rule_new, env,
+ AXIS2_PHASE_RULE_IS_FIRST(phase_rule, env) );
+
+ AXIS2_PHASE_RULE_SET_LAST(phase_rule_new, env,
+ AXIS2_PHASE_RULE_IS_LAST(phase_rule, env) );
+
return phase_rule_new;
}
Modified: webservices/axis2/trunk/c/modules/core/engine/phase.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/phase.c?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/phase.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/phase.c Thu Aug 24 08:41:40 2006
@@ -413,7 +413,7 @@
axis2_handler_t *handler,
const axis2_env_t *env)
{
- axis2_char_t *before = NULL, *after = NULL;
+ const axis2_char_t *before = NULL, *after = NULL;
axis2_handler_desc_t *handler_desc = NULL;
axis2_phase_rule_t *rules = NULL;
@@ -551,8 +551,8 @@
return AXIS2_FAILURE;
}
- first = AXIS2_PHASE_RULE_IS_PHASE_FIRST(rules, env);
- last = AXIS2_PHASE_RULE_IS_PHASE_LAST(rules, env);
+ first = AXIS2_PHASE_RULE_IS_FIRST(rules, env);
+ last = AXIS2_PHASE_RULE_IS_LAST(rules, env);
if (first && last)
{
@@ -618,7 +618,7 @@
axis2_phase_impl_t *phase_impl = NULL;
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
- axis2_char_t *first_handler_name = NULL, *before = NULL;
+ const axis2_char_t *first_handler_name = NULL, *before = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -665,7 +665,7 @@
axis2_phase_impl_t *phase_impl = NULL;
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
- axis2_char_t *last_handler_name = NULL, *after = NULL;
+ const axis2_char_t *last_handler_name = NULL, *after = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -712,7 +712,7 @@
axis2_phase_impl_t *phase_impl = NULL;
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
- axis2_char_t *handler_name = NULL, *before = NULL;
+ const axis2_char_t *handler_name = NULL, *before = NULL;
int i = 0;
int size = 0;
@@ -805,7 +805,8 @@
axis2_phase_impl_t *phase_impl = NULL;
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
- axis2_char_t *handler_name = NULL, *after = NULL;
+ const axis2_char_t *handler_name = NULL;
+ const axis2_char_t *after = NULL;
int i = 0;
int size = 0;
@@ -910,7 +911,7 @@
axis2_phase_impl_t *phase_impl = NULL;
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
- axis2_char_t *before_handler_name = NULL, *after_handler_name = NULL,
+ const axis2_char_t *before_handler_name = NULL, *after_handler_name = NULL,
*after_name = NULL, *before_name = NULL, *handler_name = NULL;
int i = 0;
int size = 0;
Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c Thu Aug 24 08:41:40 2006
@@ -41,7 +41,7 @@
axis2_phase_holder_is_phase_exist(
axis2_phase_holder_t *phase_holder,
const axis2_env_t *env,
- axis2_char_t *phase_name);
+ const axis2_char_t *phase_name);
axis2_status_t AXIS2_CALL
axis2_phase_holder_add_handler(
@@ -53,7 +53,7 @@
axis2_phase_holder_get_phase(
const axis2_phase_holder_t *phase_holder,
const axis2_env_t *env,
- axis2_char_t *phase_name);
+ const axis2_char_t *phase_name);
axis2_status_t AXIS2_CALL
axis2_phase_holder_build_transport_handler_chain(
@@ -170,7 +170,7 @@
axis2_phase_holder_is_phase_exist(
axis2_phase_holder_t *phase_holder,
const axis2_env_t *env,
- axis2_char_t *phase_name)
+ const axis2_char_t *phase_name)
{
int size = 0;
int i = 0;
@@ -209,7 +209,7 @@
const axis2_env_t *env,
axis2_handler_desc_t *handler)
{
- axis2_char_t *phase_name = NULL;
+ const axis2_char_t *phase_name = NULL;
axis2_status_t status = AXIS2_FAILURE;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler start");
@@ -248,7 +248,7 @@
axis2_phase_holder_get_phase(
const axis2_phase_holder_t *phase_holder,
const axis2_env_t *env,
- axis2_char_t *phase_name)
+ const axis2_char_t *phase_name)
{
int size = 0;
int i = 0;
Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c?rev=434404&r1=434403&r2=434404&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c Thu Aug 24 08:41:40 2006
@@ -442,7 +442,7 @@
for (j = 0; j < count; j++)
{
axis2_handler_desc_t *metadata = NULL;
- axis2_char_t *phase_name = NULL;
+ const axis2_char_t *phase_name = NULL;
axis2_phase_rule_t *phase_rule = NULL;
metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
@@ -551,7 +551,7 @@
for (j = 0; j < count; j++)
{
axis2_handler_desc_t *metadata = NULL;
- axis2_char_t *phase_name = NULL;
+ const axis2_char_t *phase_name = NULL;
axis2_phase_rule_t *phase_rule = NULL;
metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
@@ -1277,7 +1277,7 @@
for (j = 0; j < handler_count; j++)
{
axis2_handler_desc_t *metadata = NULL;
- axis2_char_t *phase_name = NULL;
+ const axis2_char_t *phase_name = NULL;
axis2_phase_rule_t *phase_rule = NULL;
metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
@@ -1433,7 +1433,7 @@
for (j = 0; j < AXIS2_FLOW_GET_HANDLER_COUNT(flow, env); j++)
{
axis2_handler_desc_t *metadata = NULL;
- axis2_char_t *phase_name = NULL;
+ const axis2_char_t *phase_name = NULL;
axis2_phase_rule_t *phase_rule = NULL;
metadata = AXIS2_FLOW_GET_HANDLER(flow, env, j);
@@ -1652,7 +1652,7 @@
for (j = 0; j < handler_count; j++)
{
axis2_handler_desc_t *metadata = NULL;
- axis2_char_t *phase_name = NULL;
+ const axis2_char_t *phase_name = NULL;
axis2_phase_rule_t *phase_rule = NULL;
axis2_status_t status = AXIS2_FAILURE;
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org