axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
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 GMT
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 <woden/axis2_woden_wsdl_obj.h>
-#include <woden/wsdl20/axis2_woden_feature.h>
-#include <woden/wsdl20/extensions/axis2_woden_ext_element.h>
-#include <woden/wsdl20/extensions/axis2_woden_component_exts.h>
-#include <woden/xml/axis2_woden_xml_attr.h>
-#include <woden/wsdl20/xml/axis2_woden_documentation_element.h>
+#include <woden/woden_wsdl_obj.h>
+#include <woden_feature.h>
+#include <woden_ext_element.h>
+#include <woden_component_exts.h>
+#include <woden_xml_attr.h>
+#include <woden_documentation_element.h>
 
-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 <woden/axis2_woden_wsdl_obj.h>
-#include <woden/wsdl20/axis2_woden_import.h>
-#include <woden/xml/axis2_woden_xml_attr.h>
-#include <woden/wsdl20/xml/axis2_woden_documentation_element.h>
-#include <woden/util/axis2_woden_generic_obj.h>
+#include <woden/woden_wsdl_obj.h>
+#include <woden_import.h>
+#include <woden_xml_attr.h>
+#include <woden_documentation_element.h>
+#include <woden_generic_obj.h>
 
-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 <woden/axis2_woden_wsdl_obj.h>
-#include <woden/wsdl20/axis2_woden_include.h>
-#include <woden/xml/axis2_woden_xml_attr.h>
-#include <woden/wsdl20/xml/axis2_woden_documentation_element.h>
-#include <woden/util/axis2_woden_generic_obj.h>
+#include <woden/woden_wsdl_obj.h>
+#include <woden_include.h>
+#include <woden_xml_attr.h>
+#include <woden_documentation_element.h>
+#include <woden_generic_obj.h>
 
-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


Mime
View raw message