Return-Path: Delivered-To: apmail-ws-axis-dev-archive@www.apache.org Received: (qmail 92435 invoked from network); 14 Jun 2006 05:25:45 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 14 Jun 2006 05:25:45 -0000 Received: (qmail 64256 invoked by uid 500); 14 Jun 2006 05:25:26 -0000 Delivered-To: apmail-ws-axis-dev-archive@ws.apache.org Received: (qmail 64096 invoked by uid 500); 14 Jun 2006 05:25:25 -0000 Mailing-List: contact axis-cvs-help@ws.apache.org; run by ezmlm Precedence: bulk list-help: list-unsubscribe: List-Post: List-Id: Delivered-To: mailing list axis-cvs@ws.apache.org Received: (qmail 63903 invoked by uid 500); 14 Jun 2006 05:25:22 -0000 Delivered-To: apmail-ws-axis2-cvs@ws.apache.org Received: (qmail 63687 invoked by uid 99); 14 Jun 2006 05:25:19 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 13 Jun 2006 22:25:19 -0700 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [140.211.166.113] (HELO eris.apache.org) (140.211.166.113) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 13 Jun 2006 22:25:06 -0700 Received: by eris.apache.org (Postfix, from userid 65534) id 6BD691A985C; Tue, 13 Jun 2006 22:23:54 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r414079 [19/26] - in /webservices/axis2/trunk/c/woden: include/ src/builder/ src/schema/ src/util/ src/wsdl20/ src/wsdl20/enumeration/ src/wsdl20/extensions/ src/wsdl20/extensions/soap/ src/wsdl20/xml/ src/xml/ test/ Date: Wed, 14 Jun 2006 05:23:21 -0000 To: axis2-cvs@ws.apache.org From: damitha@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20060614052354.6BD691A985C@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Modified: webservices/axis2/trunk/c/woden/src/wsdl20/feature.c URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/woden/src/wsdl20/feature.c?rev=414079&r1=414078&r2=414079&view=diff ============================================================================== --- webservices/axis2/trunk/c/woden/src/wsdl20/feature.c (original) +++ webservices/axis2/trunk/c/woden/src/wsdl20/feature.c Tue Jun 13 22:23:14 2006 @@ -14,24 +14,24 @@ * limitations under the License. */ -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include -typedef struct axis2_woden_feature_impl axis2_woden_feature_impl_t; +typedef struct woden_feature_impl woden_feature_impl_t; /** * @brief Feature Struct Impl * Axis2 Feature */ -struct axis2_woden_feature_impl +struct woden_feature_impl { - axis2_woden_feature_t feature; - axis2_woden_obj_types_t obj_type; - axis2_woden_documentable_t *documentable; + woden_feature_t feature; + woden_obj_types_t obj_type; + woden_documentable_t *documentable; axis2_hash_t *super; axis2_hash_t *methods; axis2_uri_t *f_ref; @@ -39,301 +39,301 @@ void *f_parent; }; -#define INTF_TO_IMPL(feature) ((axis2_woden_feature_impl_t *) feature) +#define INTF_TO_IMPL(feature) ((woden_feature_impl_t *) feature) axis2_status_t AXIS2_CALL -axis2_woden_feature_free( +woden_feature_free( void *feature, const axis2_env_t *env); axis2_hash_t *AXIS2_CALL -axis2_woden_feature_super_objs( +woden_feature_super_objs( void *feature, const axis2_env_t *env); -axis2_woden_obj_types_t AXIS2_CALL -axis2_woden_feature_type( +woden_obj_types_t AXIS2_CALL +woden_feature_type( void *feature, const axis2_env_t *env); -axis2_woden_documentable_t *AXIS2_CALL -axis2_woden_feature_get_base_impl( +woden_documentable_t *AXIS2_CALL +woden_feature_get_base_impl( void *feature, const axis2_env_t *env); axis2_status_t AXIS2_CALL -axis2_woden_feature_set_ref( +woden_feature_set_ref( void *feature, const axis2_env_t *env, axis2_uri_t *ref); axis2_uri_t *AXIS2_CALL -axis2_woden_feature_get_ref( +woden_feature_get_ref( void *feature, const axis2_env_t *env); axis2_status_t AXIS2_CALL -axis2_woden_feature_set_required( +woden_feature_set_required( void *feature, const axis2_env_t *env, axis2_bool_t required); axis2_bool_t AXIS2_CALL -axis2_woden_feature_is_required( +woden_feature_is_required( void *feature, const axis2_env_t *env); axis2_status_t AXIS2_CALL -axis2_woden_feature_set_parent_element( +woden_feature_set_parent_element( void *feature, const axis2_env_t *env, - axis2_woden_wsdl_element_t *parent); + woden_wsdl_element_t *parent); void *AXIS2_CALL -axis2_woden_feature_get_parent_element( +woden_feature_get_parent_element( void *feature, const axis2_env_t *env); void *AXIS2_CALL -axis2_woden_feature_get_parent( +woden_feature_get_parent( void *feature, const axis2_env_t *env); void *AXIS2_CALL -axis2_woden_feature_to_element( +woden_feature_to_element( void *feature, const axis2_env_t *env); -static axis2_woden_feature_t * +static woden_feature_t * create(const axis2_env_t *env); static axis2_status_t -axis2_woden_feature_free_ops( +woden_feature_free_ops( void *feature, const axis2_env_t *env); /************************Woden C Internal Methods******************************/ -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_feature_element( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_feature_element( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.feature_element.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_feature_element_ops_t)); - axis2_woden_feature_element_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_feature_element_ops_t)); + woden_feature_element_resolve_methods(&(feature_impl->feature.base. feature_element), env, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_nested_element( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_nested_element( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.feature_element.base.nested_element.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_nested_element_ops_t)); - axis2_woden_nested_element_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_nested_element_ops_t)); + woden_nested_element_resolve_methods(&(feature_impl->feature.base. feature_element.base.nested_element), env, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_documentable_element( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_documentable_element( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.feature_element.base.documentable_element.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_documentable_element_ops_t)); - axis2_woden_documentable_element_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_documentable_element_ops_t)); + woden_documentable_element_resolve_methods(&(feature_impl->feature.base. feature_element.base.documentable_element), env, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_documentable( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_documentable( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.documentable.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_documentable_ops_t)); - axis2_woden_documentable_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_documentable_ops_t)); + woden_documentable_resolve_methods(&(feature_impl->feature.base. documentable), env, feature_impl->documentable, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_wsdl_obj( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_wsdl_obj( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; void *wsdl_obj = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.documentable.base.wsdl_obj.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_wsdl_obj_ops_t)); - wsdl_obj = AXIS2_WODEN_DOCUMENTABLE_GET_BASE_IMPL( + sizeof(woden_wsdl_obj_ops_t)); + wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL( feature_impl->documentable, env); - axis2_woden_wsdl_obj_resolve_methods(&(feature_impl->feature.base. + woden_wsdl_obj_resolve_methods(&(feature_impl->feature.base. documentable.base.wsdl_obj), env, wsdl_obj, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_nested_component( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_nested_component( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.nested_component.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_nested_component_ops_t)); - axis2_woden_nested_component_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_nested_component_ops_t)); + woden_nested_component_resolve_methods(&(feature_impl->feature.base. nested_component), env, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_wsdl_component( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_wsdl_component( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.nested_component.wsdl_component.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_wsdl_component_ops_t)); - axis2_woden_wsdl_component_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_wsdl_component_ops_t)); + woden_wsdl_component_resolve_methods(&(feature_impl->feature.base. nested_component.wsdl_component), env, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_attr_extensible( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_attr_extensible( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.documentable.base.wsdl_obj.base. wsdl_element.base.attr_extensible.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_attr_extensible_ops_t)); - axis2_woden_attr_extensible_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_attr_extensible_ops_t)); + woden_attr_extensible_resolve_methods(&(feature_impl->feature.base. documentable.base.wsdl_obj.base.wsdl_element.base.attr_extensible), env, NULL, feature_impl->methods); return feature; } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_to_element_extensible( +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_to_element_extensible( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!feature) { - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); } else - feature_impl = (axis2_woden_feature_impl_t *) feature; - axis2_woden_feature_free_ops(feature, env); + feature_impl = (woden_feature_impl_t *) feature; + woden_feature_free_ops(feature, env); feature_impl->feature.base.documentable.base.wsdl_obj.base.wsdl_element. base.element_extensible.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_element_extensible_ops_t)); - axis2_woden_element_extensible_resolve_methods(&(feature_impl->feature.base. + sizeof(woden_element_extensible_ops_t)); + woden_element_extensible_resolve_methods(&(feature_impl->feature.base. documentable.base.wsdl_obj.base.wsdl_element.base.element_extensible), env, NULL, feature_impl->methods); return feature; @@ -341,16 +341,16 @@ } /************************End of Woden C Internal Methods***********************/ -static axis2_woden_feature_t * +static woden_feature_t * create(const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); feature_impl = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_feature_impl_t)); + sizeof(woden_feature_impl_t)); - feature_impl->obj_type= AXIS2_WODEN_FEATURE; + feature_impl->obj_type= WODEN_FEATURE; feature_impl->super = NULL; feature_impl->methods = NULL; feature_impl->f_parent = NULL; @@ -371,18 +371,18 @@ base.element_extensible.ops = NULL; feature_impl->feature.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_feature_ops_t)); + sizeof(woden_feature_ops_t)); - feature_impl->feature.ops->free = axis2_woden_feature_free; - feature_impl->feature.ops->super_objs = axis2_woden_feature_super_objs; - feature_impl->feature.ops->type = axis2_woden_feature_type; - feature_impl->feature.ops->get_base_impl = axis2_woden_feature_get_base_impl; - feature_impl->feature.ops->get_ref = axis2_woden_feature_get_ref; - feature_impl->feature.ops->is_required = axis2_woden_feature_is_required; + feature_impl->feature.ops->free = woden_feature_free; + feature_impl->feature.ops->super_objs = woden_feature_super_objs; + feature_impl->feature.ops->type = woden_feature_type; + feature_impl->feature.ops->get_base_impl = woden_feature_get_base_impl; + feature_impl->feature.ops->get_ref = woden_feature_get_ref; + feature_impl->feature.ops->is_required = woden_feature_is_required; feature_impl->feature.ops->get_parent = - axis2_woden_feature_get_parent; + woden_feature_get_parent; feature_impl->feature.ops->to_element = - axis2_woden_feature_to_element; + woden_feature_to_element; feature_impl->methods = axis2_hash_make(env); if(!feature_impl->methods) @@ -391,49 +391,49 @@ return NULL; } axis2_hash_set(feature_impl->methods, "free", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_free); + woden_feature_free); axis2_hash_set(feature_impl->methods, "super_objs", - AXIS2_HASH_KEY_STRING, axis2_woden_feature_super_objs); + AXIS2_HASH_KEY_STRING, woden_feature_super_objs); axis2_hash_set(feature_impl->methods, "type", - AXIS2_HASH_KEY_STRING, axis2_woden_feature_type); + AXIS2_HASH_KEY_STRING, woden_feature_type); axis2_hash_set(feature_impl->methods, "get_parent", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_get_parent); + woden_feature_get_parent); axis2_hash_set(feature_impl->methods, "set_parent_element", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_set_parent_element); + woden_feature_set_parent_element); axis2_hash_set(feature_impl->methods, "get_parent_element", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_get_parent_element); + woden_feature_get_parent_element); axis2_hash_set(feature_impl->methods, "set_ref", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_set_ref); + woden_feature_set_ref); axis2_hash_set(feature_impl->methods, "get_ref", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_get_ref); + woden_feature_get_ref); axis2_hash_set(feature_impl->methods, "set_required", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_set_required); + woden_feature_set_required); axis2_hash_set(feature_impl->methods, "is_required", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_is_required); + woden_feature_is_required); axis2_hash_set(feature_impl->methods, "to_element", AXIS2_HASH_KEY_STRING, - axis2_woden_feature_to_element); + woden_feature_to_element); return &(feature_impl->feature); } -AXIS2_EXTERN axis2_woden_feature_t * AXIS2_CALL -axis2_woden_feature_create(const axis2_env_t *env) +AXIS2_EXTERN woden_feature_t * AXIS2_CALL +woden_feature_create(const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - feature_impl = (axis2_woden_feature_impl_t *) create(env); + feature_impl = (woden_feature_impl_t *) create(env); - feature_impl->documentable = axis2_woden_documentable_create(env); + feature_impl->documentable = woden_documentable_create(env); feature_impl->super = axis2_hash_make(env); if(!feature_impl->super) @@ -441,20 +441,20 @@ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } - axis2_hash_set(feature_impl->super, "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING, + axis2_hash_set(feature_impl->super, "WODEN_FEATURE", AXIS2_HASH_KEY_STRING, &(feature_impl->feature)); - axis2_hash_set(feature_impl->super, "AXIS2_WODEN_DOCUMENTABLE", AXIS2_HASH_KEY_STRING, + axis2_hash_set(feature_impl->super, "WODEN_DOCUMENTABLE", AXIS2_HASH_KEY_STRING, feature_impl->documentable); return &(feature_impl->feature); } static axis2_status_t -axis2_woden_feature_free_ops( +woden_feature_free_ops( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); feature_impl = INTF_TO_IMPL(feature); @@ -535,10 +535,10 @@ axis2_status_t AXIS2_CALL -axis2_woden_feature_free(void *feature, +woden_feature_free(void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); feature_impl = INTF_TO_IMPL(feature); @@ -565,11 +565,11 @@ if(feature_impl->documentable) { - AXIS2_WODEN_DOCUMENTABLE_FREE(feature_impl->documentable, env); + WODEN_DOCUMENTABLE_FREE(feature_impl->documentable, env); feature_impl->documentable = NULL; } - axis2_woden_feature_free_ops(feature, env); + woden_feature_free_ops(feature, env); if((&(feature_impl->feature))->ops) { @@ -586,11 +586,11 @@ } axis2_hash_t *AXIS2_CALL -axis2_woden_feature_super_objs( +woden_feature_super_objs( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); feature_impl = INTF_TO_IMPL(feature); @@ -598,12 +598,12 @@ return feature_impl->super; } -axis2_woden_obj_types_t AXIS2_CALL -axis2_woden_feature_type( +woden_obj_types_t AXIS2_CALL +woden_feature_type( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); feature_impl = INTF_TO_IMPL(feature); @@ -611,12 +611,12 @@ return feature_impl->obj_type; } -axis2_woden_documentable_t *AXIS2_CALL -axis2_woden_feature_get_base_impl( +woden_documentable_t *AXIS2_CALL +woden_feature_get_base_impl( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; AXIS2_ENV_CHECK(env, NULL); feature_impl = INTF_TO_IMPL(feature); @@ -625,13 +625,13 @@ } axis2_status_t AXIS2_CALL -axis2_woden_feature_resolve_methods( - axis2_woden_feature_t *feature, +woden_feature_resolve_methods( + woden_feature_t *feature, const axis2_env_t *env, - axis2_woden_feature_t *feature_impl, + woden_feature_t *feature_impl, axis2_hash_t *methods) { - axis2_woden_feature_impl_t *feature_impl_l = NULL; + woden_feature_impl_t *feature_impl_l = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, methods, AXIS2_FAILURE); @@ -672,18 +672,18 @@ } axis2_status_t AXIS2_CALL -axis2_woden_feature_set_ref( +woden_feature_set_ref( void *feature, const axis2_env_t *env, axis2_uri_t *ref) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); if(feature_impl->f_ref) { @@ -694,68 +694,68 @@ } axis2_uri_t *AXIS2_CALL -axis2_woden_feature_get_ref( +woden_feature_get_ref( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, NULL); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); return feature_impl->f_ref; } axis2_status_t AXIS2_CALL -axis2_woden_feature_set_required( +woden_feature_set_required( void *feature, const axis2_env_t *env, axis2_bool_t required) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); feature_impl->f_required = required; return AXIS2_SUCCESS; } axis2_bool_t AXIS2_CALL -axis2_woden_feature_is_required( +woden_feature_is_required( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); return feature_impl->f_required; } axis2_status_t AXIS2_CALL -axis2_woden_feature_set_parent_element( +woden_feature_set_parent_element( void *feature, const axis2_env_t *env, - axis2_woden_wsdl_element_t *parent) + woden_wsdl_element_t *parent) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); if(feature_impl->f_parent) { @@ -766,50 +766,50 @@ } void *AXIS2_CALL -axis2_woden_feature_get_parent_element( +woden_feature_get_parent_element( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); return feature_impl->f_parent; } void *AXIS2_CALL -axis2_woden_feature_get_parent( +woden_feature_get_parent( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); /* TODO complete this */ return NULL; } void *AXIS2_CALL -axis2_woden_feature_to_element( +woden_feature_to_element( void *feature, const axis2_env_t *env) { - axis2_woden_feature_impl_t *feature_impl = NULL; + woden_feature_impl_t *feature_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - super = AXIS2_WODEN_FEATURE_SUPER_OBJS(feature, env); + super = WODEN_FEATURE_SUPER_OBJS(feature, env); feature_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); + "WODEN_FEATURE", AXIS2_HASH_KEY_STRING)); return &(feature_impl->feature); } Modified: webservices/axis2/trunk/c/woden/src/wsdl20/import.c URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/woden/src/wsdl20/import.c?rev=414079&r1=414078&r2=414079&view=diff ============================================================================== --- webservices/axis2/trunk/c/woden/src/wsdl20/import.c (original) +++ webservices/axis2/trunk/c/woden/src/wsdl20/import.c Tue Jun 13 22:23:14 2006 @@ -14,168 +14,168 @@ * limitations under the License. */ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -typedef struct axis2_woden_import_impl axis2_woden_import_impl_t; +typedef struct woden_import_impl woden_import_impl_t; /** * @brief Feature Struct Impl * Axis2 Feature */ -struct axis2_woden_import_impl +struct woden_import_impl { - axis2_woden_import_t import; - axis2_woden_obj_types_t obj_type; - axis2_woden_wsdl_ref_t *wsdl_ref; + woden_import_t import; + woden_obj_types_t obj_type; + woden_wsdl_ref_t *wsdl_ref; axis2_hash_t *super; axis2_hash_t *methods; axis2_uri_t *f_namespc; }; -#define INTF_TO_IMPL(import) ((axis2_woden_import_impl_t *) import) +#define INTF_TO_IMPL(import) ((woden_import_impl_t *) import) axis2_status_t AXIS2_CALL -axis2_woden_import_free( +woden_import_free( void *import, const axis2_env_t *env); axis2_hash_t *AXIS2_CALL -axis2_woden_import_super_objs( +woden_import_super_objs( void *import, const axis2_env_t *env); -axis2_woden_obj_types_t AXIS2_CALL -axis2_woden_import_type( +woden_obj_types_t AXIS2_CALL +woden_import_type( void *import, const axis2_env_t *env); -axis2_woden_wsdl_ref_t *AXIS2_CALL -axis2_woden_import_get_base_impl( +woden_wsdl_ref_t *AXIS2_CALL +woden_import_get_base_impl( void *import, const axis2_env_t *env); axis2_status_t AXIS2_CALL -axis2_woden_import_set_namespace( +woden_import_set_namespace( void *import, const axis2_env_t *env, axis2_uri_t *ns_uri); axis2_uri_t *AXIS2_CALL -axis2_woden_import_get_namespace( +woden_import_get_namespace( void *import, const axis2_env_t *env); -static axis2_woden_import_t * +static woden_import_t * create(const axis2_env_t *env); static axis2_status_t -axis2_woden_import_free_ops( +woden_import_free_ops( void *import, const axis2_env_t *env); /************************Woden C Internal Methods******************************/ -AXIS2_EXTERN axis2_woden_import_t * AXIS2_CALL -axis2_woden_import_to_import_element( +AXIS2_EXTERN woden_import_t * AXIS2_CALL +woden_import_to_import_element( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!import) { - import_impl = (axis2_woden_import_impl_t *) create(env); + import_impl = (woden_import_impl_t *) create(env); } else - import_impl = (axis2_woden_import_impl_t *) import; + import_impl = (woden_import_impl_t *) import; - axis2_woden_import_free_ops(import, env); + woden_import_free_ops(import, env); import_impl->import.base.import_element.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_import_element_ops_t)); - axis2_woden_import_element_resolve_methods(&(import_impl->import.base. + sizeof(woden_import_element_ops_t)); + woden_import_element_resolve_methods(&(import_impl->import.base. import_element), env, import_impl->methods); return import; } -AXIS2_EXTERN axis2_woden_import_t * AXIS2_CALL -axis2_woden_import_to_wsdl_ref( +AXIS2_EXTERN woden_import_t * AXIS2_CALL +woden_import_to_wsdl_ref( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!import) { - import_impl = (axis2_woden_import_impl_t *) create(env); + import_impl = (woden_import_impl_t *) create(env); } else - import_impl = (axis2_woden_import_impl_t *) import; - axis2_woden_import_free_ops(import, env); + import_impl = (woden_import_impl_t *) import; + woden_import_free_ops(import, env); import_impl->import.base.wsdl_ref.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_wsdl_ref_ops_t)); - axis2_woden_documentable_resolve_methods(&(import_impl->import.base. + sizeof(woden_wsdl_ref_ops_t)); + woden_documentable_resolve_methods(&(import_impl->import.base. wsdl_ref), env, import_impl->wsdl_ref, import_impl->methods); return import; } -AXIS2_EXTERN axis2_woden_import_t * AXIS2_CALL -axis2_woden_import_to_attr_extensible( +AXIS2_EXTERN woden_import_t * AXIS2_CALL +woden_import_to_attr_extensible( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!import) { - import_impl = (axis2_woden_import_impl_t *) create(env); + import_impl = (woden_import_impl_t *) create(env); } else - import_impl = (axis2_woden_import_impl_t *) import; - axis2_woden_import_free_ops(import, env); + import_impl = (woden_import_impl_t *) import; + woden_import_free_ops(import, env); import_impl->import.base.wsdl_ref.wsdl_element.base. attr_extensible.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_attr_extensible_ops_t)); - axis2_woden_attr_extensible_resolve_methods(&(import_impl->import.base. + sizeof(woden_attr_extensible_ops_t)); + woden_attr_extensible_resolve_methods(&(import_impl->import.base. wsdl_ref.wsdl_element.base.attr_extensible), env, NULL, import_impl->methods); return import; } -AXIS2_EXTERN axis2_woden_import_t * AXIS2_CALL -axis2_woden_import_to_element_extensible( +AXIS2_EXTERN woden_import_t * AXIS2_CALL +woden_import_to_element_extensible( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!import) { - import_impl = (axis2_woden_import_impl_t *) create(env); + import_impl = (woden_import_impl_t *) create(env); } else - import_impl = (axis2_woden_import_impl_t *) import; - axis2_woden_import_free_ops(import, env); + import_impl = (woden_import_impl_t *) import; + woden_import_free_ops(import, env); import_impl->import.base.wsdl_ref.wsdl_element. base.element_extensible.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_element_extensible_ops_t)); - axis2_woden_element_extensible_resolve_methods(&(import_impl->import.base. + sizeof(woden_element_extensible_ops_t)); + woden_element_extensible_resolve_methods(&(import_impl->import.base. wsdl_ref.wsdl_element.base.element_extensible), env, NULL, import_impl->methods); return import; @@ -183,16 +183,16 @@ } /************************End of Woden C Internal Methods***********************/ -static axis2_woden_import_t * +static woden_import_t * create(const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); import_impl = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_import_impl_t)); + sizeof(woden_import_impl_t)); - import_impl->obj_type= AXIS2_WODEN_IMPORT; + import_impl->obj_type= WODEN_IMPORT; import_impl->super = NULL; import_impl->methods = NULL; import_impl->f_namespc = NULL; @@ -203,15 +203,15 @@ import_impl->import.base.wsdl_ref.wsdl_element.base.element_extensible.ops = NULL; import_impl->import.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_import_ops_t)); + sizeof(woden_import_ops_t)); - import_impl->import.ops->free = axis2_woden_import_free; - import_impl->import.ops->super_objs = axis2_woden_import_super_objs; - import_impl->import.ops->type = axis2_woden_import_type; - import_impl->import.ops->get_base_impl = axis2_woden_import_get_base_impl; + import_impl->import.ops->free = woden_import_free; + import_impl->import.ops->super_objs = woden_import_super_objs; + import_impl->import.ops->type = woden_import_type; + import_impl->import.ops->get_base_impl = woden_import_get_base_impl; - import_impl->import.ops->get_namespace = axis2_woden_import_get_namespace; - import_impl->import.ops->set_namespace = axis2_woden_import_set_namespace; + import_impl->import.ops->get_namespace = woden_import_get_namespace; + import_impl->import.ops->set_namespace = woden_import_set_namespace; import_impl->methods = axis2_hash_make(env); if(!import_impl->methods) @@ -220,31 +220,31 @@ return NULL; } axis2_hash_set(import_impl->methods, "free", AXIS2_HASH_KEY_STRING, - axis2_woden_import_free); + woden_import_free); axis2_hash_set(import_impl->methods, "super_objs", AXIS2_HASH_KEY_STRING, - axis2_woden_import_super_objs); + woden_import_super_objs); axis2_hash_set(import_impl->methods, "type", - AXIS2_HASH_KEY_STRING, axis2_woden_import_type); + AXIS2_HASH_KEY_STRING, woden_import_type); axis2_hash_set(import_impl->methods, "set_namespace", AXIS2_HASH_KEY_STRING, - axis2_woden_import_set_namespace); + woden_import_set_namespace); axis2_hash_set(import_impl->methods, "get_namespace", AXIS2_HASH_KEY_STRING, - axis2_woden_import_get_namespace); + woden_import_get_namespace); return &(import_impl->import); } -AXIS2_EXTERN axis2_woden_import_t * AXIS2_CALL -axis2_woden_import_create(const axis2_env_t *env) +AXIS2_EXTERN woden_import_t * AXIS2_CALL +woden_import_create(const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - import_impl = (axis2_woden_import_impl_t *) create(env); + import_impl = (woden_import_impl_t *) create(env); - import_impl->wsdl_ref = axis2_woden_wsdl_ref_create(env); + import_impl->wsdl_ref = woden_wsdl_ref_create(env); import_impl->super = axis2_hash_make(env); if(!import_impl->super) @@ -252,20 +252,20 @@ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } - axis2_hash_set(import_impl->super, "AXIS2_WODEN_IMPORT", + axis2_hash_set(import_impl->super, "WODEN_IMPORT", AXIS2_HASH_KEY_STRING, &(import_impl->import)); - axis2_hash_set(import_impl->super, "AXIS2_WODEN_WSDL_REF", + axis2_hash_set(import_impl->super, "WODEN_WSDL_REF", AXIS2_HASH_KEY_STRING, import_impl->wsdl_ref); return &(import_impl->import); } static axis2_status_t -axis2_woden_import_free_ops( +woden_import_free_ops( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); import_impl = INTF_TO_IMPL(import); @@ -304,10 +304,10 @@ axis2_status_t AXIS2_CALL -axis2_woden_import_free(void *import, +woden_import_free(void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); import_impl = INTF_TO_IMPL(import); @@ -332,11 +332,11 @@ if(import_impl->wsdl_ref) { - AXIS2_WODEN_WSDL_REF_FREE(import_impl->wsdl_ref, env); + WODEN_WSDL_REF_FREE(import_impl->wsdl_ref, env); import_impl->wsdl_ref = NULL; } - axis2_woden_import_free_ops(import, env); + woden_import_free_ops(import, env); if((&(import_impl->import))->ops) { @@ -353,11 +353,11 @@ } axis2_hash_t *AXIS2_CALL -axis2_woden_import_super_objs( +woden_import_super_objs( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); import_impl = INTF_TO_IMPL(import); @@ -365,12 +365,12 @@ return import_impl->super; } -axis2_woden_obj_types_t AXIS2_CALL -axis2_woden_import_type( +woden_obj_types_t AXIS2_CALL +woden_import_type( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); import_impl = INTF_TO_IMPL(import); @@ -378,11 +378,11 @@ return import_impl->obj_type; } -axis2_woden_wsdl_ref_t *AXIS2_CALL -axis2_woden_import_get_base_impl(void *import, +woden_wsdl_ref_t *AXIS2_CALL +woden_import_get_base_impl(void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; AXIS2_ENV_CHECK(env, NULL); import_impl = INTF_TO_IMPL(import); @@ -391,13 +391,13 @@ } axis2_status_t AXIS2_CALL -axis2_woden_import_resolve_methods( - axis2_woden_import_t *import, +woden_import_resolve_methods( + woden_import_t *import, const axis2_env_t *env, - axis2_woden_import_t *import_impl, + woden_import_t *import_impl, axis2_hash_t *methods) { - axis2_woden_import_impl_t *import_impl_l = NULL; + woden_import_impl_t *import_impl_l = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, methods, AXIS2_FAILURE); @@ -426,19 +426,19 @@ } axis2_status_t AXIS2_CALL -axis2_woden_import_set_namespace( +woden_import_set_namespace( void *import, const axis2_env_t *env, axis2_uri_t *ns_uri) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, ns_uri, AXIS2_FAILURE); - super = AXIS2_WODEN_IMPORT_SUPER_OBJS(import, env); + super = WODEN_IMPORT_SUPER_OBJS(import, env); import_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_IMPORT", AXIS2_HASH_KEY_STRING)); + "WODEN_IMPORT", AXIS2_HASH_KEY_STRING)); if(import_impl->f_namespc) { @@ -451,17 +451,17 @@ } axis2_uri_t *AXIS2_CALL -axis2_woden_import_get_namespace( +woden_import_get_namespace( void *import, const axis2_env_t *env) { - axis2_woden_import_impl_t *import_impl = NULL; + woden_import_impl_t *import_impl = NULL; axis2_hash_t *super = NULL; AXIS2_ENV_CHECK(env, NULL); - super = AXIS2_WODEN_IMPORT_SUPER_OBJS(import, env); + super = WODEN_IMPORT_SUPER_OBJS(import, env); import_impl = INTF_TO_IMPL(axis2_hash_get(super, - "AXIS2_WODEN_IMPORT", AXIS2_HASH_KEY_STRING)); + "WODEN_IMPORT", AXIS2_HASH_KEY_STRING)); return import_impl->f_namespc; } Modified: webservices/axis2/trunk/c/woden/src/wsdl20/include.c URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/woden/src/wsdl20/include.c?rev=414079&r1=414078&r2=414079&view=diff ============================================================================== --- webservices/axis2/trunk/c/woden/src/wsdl20/include.c (original) +++ webservices/axis2/trunk/c/woden/src/wsdl20/include.c Tue Jun 13 22:23:14 2006 @@ -14,155 +14,155 @@ * limitations under the License. */ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -typedef struct axis2_woden_include_impl axis2_woden_include_impl_t; +typedef struct woden_include_impl woden_include_impl_t; /** * @brief Feature Struct Impl * Axis2 Feature */ -struct axis2_woden_include_impl +struct woden_include_impl { - axis2_woden_include_t include; - axis2_woden_obj_types_t obj_type; - axis2_woden_wsdl_ref_t *wsdl_ref; + woden_include_t include; + woden_obj_types_t obj_type; + woden_wsdl_ref_t *wsdl_ref; axis2_hash_t *super; axis2_hash_t *methods; }; -#define INTF_TO_IMPL(include) ((axis2_woden_include_impl_t *) include) +#define INTF_TO_IMPL(include) ((woden_include_impl_t *) include) axis2_status_t AXIS2_CALL -axis2_woden_include_free( +woden_include_free( void *include, const axis2_env_t *env); axis2_hash_t *AXIS2_CALL -axis2_woden_include_super_objs( +woden_include_super_objs( void *include, const axis2_env_t *env); -axis2_woden_obj_types_t AXIS2_CALL -axis2_woden_include_type( +woden_obj_types_t AXIS2_CALL +woden_include_type( void *include, const axis2_env_t *env); -axis2_woden_wsdl_ref_t *AXIS2_CALL -axis2_woden_include_get_base_impl( +woden_wsdl_ref_t *AXIS2_CALL +woden_include_get_base_impl( void *include, const axis2_env_t *env); -static axis2_woden_include_t * +static woden_include_t * create(const axis2_env_t *env); static axis2_status_t -axis2_woden_include_free_ops( +woden_include_free_ops( void *include, const axis2_env_t *env); /************************Woden C Internal Methods******************************/ -AXIS2_EXTERN axis2_woden_include_t * AXIS2_CALL -axis2_woden_include_to_include_element( +AXIS2_EXTERN woden_include_t * AXIS2_CALL +woden_include_to_include_element( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!include) { - include_impl = (axis2_woden_include_impl_t *) create(env); + include_impl = (woden_include_impl_t *) create(env); } else - include_impl = (axis2_woden_include_impl_t *) include; + include_impl = (woden_include_impl_t *) include; - axis2_woden_include_free_ops(include, env); + woden_include_free_ops(include, env); include_impl->include.base.include_element.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_include_element_ops_t)); - axis2_woden_include_element_resolve_methods(&(include_impl->include.base. + sizeof(woden_include_element_ops_t)); + woden_include_element_resolve_methods(&(include_impl->include.base. include_element), env, include_impl->methods); return include; } -AXIS2_EXTERN axis2_woden_include_t * AXIS2_CALL -axis2_woden_include_to_wsdl_ref( +AXIS2_EXTERN woden_include_t * AXIS2_CALL +woden_include_to_wsdl_ref( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!include) { - include_impl = (axis2_woden_include_impl_t *) create(env); + include_impl = (woden_include_impl_t *) create(env); } else - include_impl = (axis2_woden_include_impl_t *) include; - axis2_woden_include_free_ops(include, env); + include_impl = (woden_include_impl_t *) include; + woden_include_free_ops(include, env); include_impl->include.base.wsdl_ref.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_wsdl_ref_ops_t)); - axis2_woden_documentable_resolve_methods(&(include_impl->include.base. + sizeof(woden_wsdl_ref_ops_t)); + woden_documentable_resolve_methods(&(include_impl->include.base. wsdl_ref), env, include_impl->wsdl_ref, include_impl->methods); return include; } -AXIS2_EXTERN axis2_woden_include_t * AXIS2_CALL -axis2_woden_include_to_attr_extensible( +AXIS2_EXTERN woden_include_t * AXIS2_CALL +woden_include_to_attr_extensible( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!include) { - include_impl = (axis2_woden_include_impl_t *) create(env); + include_impl = (woden_include_impl_t *) create(env); } else - include_impl = (axis2_woden_include_impl_t *) include; - axis2_woden_include_free_ops(include, env); + include_impl = (woden_include_impl_t *) include; + woden_include_free_ops(include, env); include_impl->include.base.wsdl_ref.wsdl_element.base. attr_extensible.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_attr_extensible_ops_t)); - axis2_woden_attr_extensible_resolve_methods(&(include_impl->include.base. + sizeof(woden_attr_extensible_ops_t)); + woden_attr_extensible_resolve_methods(&(include_impl->include.base. wsdl_ref.wsdl_element.base.attr_extensible), env, NULL, include_impl->methods); return include; } -AXIS2_EXTERN axis2_woden_include_t * AXIS2_CALL -axis2_woden_include_to_element_extensible( +AXIS2_EXTERN woden_include_t * AXIS2_CALL +woden_include_to_element_extensible( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(!include) { - include_impl = (axis2_woden_include_impl_t *) create(env); + include_impl = (woden_include_impl_t *) create(env); } else - include_impl = (axis2_woden_include_impl_t *) include; - axis2_woden_include_free_ops(include, env); + include_impl = (woden_include_impl_t *) include; + woden_include_free_ops(include, env); include_impl->include.base.wsdl_ref.wsdl_element. base.element_extensible.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_element_extensible_ops_t)); - axis2_woden_element_extensible_resolve_methods(&(include_impl->include.base. + sizeof(woden_element_extensible_ops_t)); + woden_element_extensible_resolve_methods(&(include_impl->include.base. wsdl_ref.wsdl_element.base.element_extensible), env, NULL, include_impl->methods); return include; @@ -170,16 +170,16 @@ } /************************End of Woden C Internal Methods***********************/ -static axis2_woden_include_t * +static woden_include_t * create(const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); include_impl = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_include_impl_t)); + sizeof(woden_include_impl_t)); - include_impl->obj_type= AXIS2_WODEN_INCLUDE; + include_impl->obj_type= WODEN_INCLUDE; include_impl->super = NULL; include_impl->methods = NULL; @@ -189,12 +189,12 @@ include_impl->include.base.wsdl_ref.wsdl_element.base.element_extensible.ops = NULL; include_impl->include.ops = AXIS2_MALLOC(env->allocator, - sizeof(axis2_woden_include_ops_t)); + sizeof(woden_include_ops_t)); - include_impl->include.ops->free = axis2_woden_include_free; - include_impl->include.ops->super_objs = axis2_woden_include_super_objs; - include_impl->include.ops->type = axis2_woden_include_type; - include_impl->include.ops->get_base_impl = axis2_woden_include_get_base_impl; + include_impl->include.ops->free = woden_include_free; + include_impl->include.ops->super_objs = woden_include_super_objs; + include_impl->include.ops->type = woden_include_type; + include_impl->include.ops->get_base_impl = woden_include_get_base_impl; include_impl->methods = axis2_hash_make(env); if(!include_impl->methods) @@ -203,24 +203,24 @@ return NULL; } axis2_hash_set(include_impl->methods, "free", AXIS2_HASH_KEY_STRING, - axis2_woden_include_free); + woden_include_free); axis2_hash_set(include_impl->methods, "super_objs", AXIS2_HASH_KEY_STRING, - axis2_woden_include_super_objs); + woden_include_super_objs); axis2_hash_set(include_impl->methods, "type", - AXIS2_HASH_KEY_STRING, axis2_woden_include_type); + AXIS2_HASH_KEY_STRING, woden_include_type); return &(include_impl->include); } -AXIS2_EXTERN axis2_woden_include_t * AXIS2_CALL -axis2_woden_include_create(const axis2_env_t *env) +AXIS2_EXTERN woden_include_t * AXIS2_CALL +woden_include_create(const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); - include_impl = (axis2_woden_include_impl_t *) create(env); + include_impl = (woden_include_impl_t *) create(env); - include_impl->wsdl_ref = axis2_woden_wsdl_ref_create(env); + include_impl->wsdl_ref = woden_wsdl_ref_create(env); include_impl->super = axis2_hash_make(env); if(!include_impl->super) @@ -228,20 +228,20 @@ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } - axis2_hash_set(include_impl->super, "AXIS2_WODEN_INCLUDE", + axis2_hash_set(include_impl->super, "WODEN_INCLUDE", AXIS2_HASH_KEY_STRING, &(include_impl->include)); - axis2_hash_set(include_impl->super, "AXIS2_WODEN_WSDL_REF", + axis2_hash_set(include_impl->super, "WODEN_WSDL_REF", AXIS2_HASH_KEY_STRING, include_impl->wsdl_ref); return &(include_impl->include); } static axis2_status_t -axis2_woden_include_free_ops( +woden_include_free_ops( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); include_impl = INTF_TO_IMPL(include); @@ -280,10 +280,10 @@ axis2_status_t AXIS2_CALL -axis2_woden_include_free(void *include, +woden_include_free(void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); include_impl = INTF_TO_IMPL(include); @@ -302,11 +302,11 @@ if(include_impl->wsdl_ref) { - AXIS2_WODEN_WSDL_REF_FREE(include_impl->wsdl_ref, env); + WODEN_WSDL_REF_FREE(include_impl->wsdl_ref, env); include_impl->wsdl_ref = NULL; } - axis2_woden_include_free_ops(include, env); + woden_include_free_ops(include, env); if((&(include_impl->include))->ops) { @@ -323,11 +323,11 @@ } axis2_hash_t *AXIS2_CALL -axis2_woden_include_super_objs( +woden_include_super_objs( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); include_impl = INTF_TO_IMPL(include); @@ -335,12 +335,12 @@ return include_impl->super; } -axis2_woden_obj_types_t AXIS2_CALL -axis2_woden_include_type( +woden_obj_types_t AXIS2_CALL +woden_include_type( void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); include_impl = INTF_TO_IMPL(include); @@ -348,11 +348,11 @@ return include_impl->obj_type; } -axis2_woden_wsdl_ref_t *AXIS2_CALL -axis2_woden_include_get_base_impl(void *include, +woden_wsdl_ref_t *AXIS2_CALL +woden_include_get_base_impl(void *include, const axis2_env_t *env) { - axis2_woden_include_impl_t *include_impl = NULL; + woden_include_impl_t *include_impl = NULL; AXIS2_ENV_CHECK(env, NULL); include_impl = INTF_TO_IMPL(include); @@ -361,13 +361,13 @@ } axis2_status_t AXIS2_CALL -axis2_woden_include_resolve_methods( - axis2_woden_include_t *include, +woden_include_resolve_methods( + woden_include_t *include, const axis2_env_t *env, - axis2_woden_include_t *include_impl, + woden_include_t *include_impl, axis2_hash_t *methods) { - axis2_woden_include_impl_t *include_impl_l = NULL; + woden_include_impl_t *include_impl_l = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, methods, AXIS2_FAILURE); --------------------------------------------------------------------- To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org For additional commands, e-mail: axis-cvs-help@ws.apache.org