axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r413626 [14/18] - in /webservices/axis2/trunk/c/xml_schema: include/ samples/ src/ test/
Date Mon, 12 Jun 2006 10:29:46 GMT
Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_identity_constraint.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_identity_constraint.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_identity_constraint.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_identity_constraint.c Mon Jun 12 03:29:40 2006
@@ -14,92 +14,92 @@
  * limitations under the License.
  */
 
-#include <axis2_xml_schema_identity_constraint.h>
-#include <axis2_xml_schema_obj_collection.h>
-#include <axis2_xml_schema_xpath.h>
+#include <xml_schema_identity_constraint.h>
+#include <xml_schema_obj_collection.h>
+#include <xml_schema_xpath.h>
 
-typedef struct axis2_xml_schema_identity_constraint_impl 
-                axis2_xml_schema_identity_constraint_impl_t;
+typedef struct xml_schema_identity_constraint_impl 
+                xml_schema_identity_constraint_impl_t;
 
 /** 
  * @brief Other Extension Struct Impl
  *   Axis2 Other Extension  
  */ 
-struct axis2_xml_schema_identity_constraint_impl
+struct xml_schema_identity_constraint_impl
 {
-    axis2_xml_schema_identity_constraint_t id_constr;
-    axis2_xml_schema_annotated_t *annotated;
-    axis2_xml_schema_obj_collection_t *fields;
+    xml_schema_identity_constraint_t id_constr;
+    xml_schema_annotated_t *annotated;
+    xml_schema_obj_collection_t *fields;
     axis2_char_t *name;
-    axis2_xml_schema_xpath_t *selector;
+    xml_schema_xpath_t *selector;
     
     /** keyref field */
     axis2_qname_t *refer;
     
     axis2_hash_t *methods;
     axis2_hash_t *ht_super;
-    axis2_xml_schema_types_t obj_type;
+    xml_schema_types_t obj_type;
 };
 
 #define AXIS2_INTF_TO_IMPL(id_constr) \
-        ((axis2_xml_schema_identity_constraint_impl_t *) id_constr)
+        ((xml_schema_identity_constraint_impl_t *) id_constr)
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_identity_constraint_free(void *id_constr,
+xml_schema_identity_constraint_free(void *id_constr,
                         const axis2_env_t *env);
 
-axis2_xml_schema_annotated_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_base_impl(void *id_constr,
+xml_schema_annotated_t *AXIS2_CALL
+xml_schema_identity_constraint_get_base_impl(void *id_constr,
                                         const axis2_env_t *env);
                                         
 
-axis2_xml_schema_types_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_type(void *id_constr,
+xml_schema_types_t AXIS2_CALL
+xml_schema_identity_constraint_get_type(void *id_constr,
                                         const axis2_env_t *env);
                                         
 
 axis2_hash_t* AXIS2_CALL
-axis2_xml_schema_identity_constraint_super_objs(void *id_constr,
+xml_schema_identity_constraint_super_objs(void *id_constr,
                                         const axis2_env_t *env);                                                                                
 axis2_qname_t* AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_refer(void *id_constr,
+xml_schema_identity_constraint_get_refer(void *id_constr,
                                              const axis2_env_t *env); 
                                              
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_set_refer(void *id_constr,
+xml_schema_identity_constraint_set_refer(void *id_constr,
                                              const axis2_env_t *env,
                                               axis2_qname_t *refer);                                                                                  
                                         
-axis2_xml_schema_obj_collection_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_fields(void *id_constr,
+xml_schema_obj_collection_t *AXIS2_CALL
+xml_schema_identity_constraint_get_fields(void *id_constr,
                                 const axis2_env_t *env);
 
 axis2_char_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_name(void *id_constr,
+xml_schema_identity_constraint_get_name(void *id_constr,
                                 const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_set_name(void *id_constr,
+xml_schema_identity_constraint_set_name(void *id_constr,
                                 const axis2_env_t *env,
                                 axis2_char_t *name);
 
-axis2_xml_schema_xpath_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_selector(void *id_constr,
+xml_schema_xpath_t *AXIS2_CALL
+xml_schema_identity_constraint_get_selector(void *id_constr,
                                         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_set_selector(void *id_constr,
+xml_schema_identity_constraint_set_selector(void *id_constr,
                                     const axis2_env_t *env,
-                                    axis2_xml_schema_xpath_t *selector);
+                                    xml_schema_xpath_t *selector);
 
-AXIS2_EXTERN axis2_xml_schema_identity_constraint_t * AXIS2_CALL
-axis2_xml_schema_identity_constraint_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_identity_constraint_t * AXIS2_CALL
+xml_schema_identity_constraint_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
+    xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
     id_cns_impl = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_identity_constraint_impl_t));
+                    sizeof(xml_schema_identity_constraint_impl_t));
     if(!id_cns_impl)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -115,133 +115,133 @@
     id_cns_impl->id_constr.ops = NULL;
     id_cns_impl->refer = NULL;
     id_cns_impl->ht_super = NULL;
-    id_cns_impl->obj_type = AXIS2_XML_SCHEMA_IDENTITY_CONSTRAINT;
+    id_cns_impl->obj_type = XML_SCHEMA_IDENTITY_CONSTRAINT;
     
     id_cns_impl->id_constr.ops = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_identity_constraint_ops_t));
+                    sizeof(xml_schema_identity_constraint_ops_t));
     if(!(id_cns_impl->id_constr.ops))
     {
-        axis2_xml_schema_identity_constraint_free(
+        xml_schema_identity_constraint_free(
             &(id_cns_impl->id_constr), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     id_cns_impl->id_constr.ops->free = 
-            axis2_xml_schema_identity_constraint_free;
+            xml_schema_identity_constraint_free;
     id_cns_impl->id_constr.ops->get_base_impl = 
-            axis2_xml_schema_identity_constraint_get_base_impl;
+            xml_schema_identity_constraint_get_base_impl;
     id_cns_impl->id_constr.ops->get_refer = 
-            axis2_xml_schema_identity_constraint_get_refer;
+            xml_schema_identity_constraint_get_refer;
     id_cns_impl->id_constr.ops->set_refer = 
-            axis2_xml_schema_identity_constraint_set_refer;
+            xml_schema_identity_constraint_set_refer;
     id_cns_impl->id_constr.ops->get_type = 
-            axis2_xml_schema_identity_constraint_get_type;
+            xml_schema_identity_constraint_get_type;
     id_cns_impl->id_constr.ops->super_objs = 
-            axis2_xml_schema_identity_constraint_super_objs;
+            xml_schema_identity_constraint_super_objs;
     id_cns_impl->id_constr.ops->get_fields = 
-            axis2_xml_schema_identity_constraint_get_fields;
+            xml_schema_identity_constraint_get_fields;
     id_cns_impl->id_constr.ops->get_name = 
-            axis2_xml_schema_identity_constraint_get_name;
+            xml_schema_identity_constraint_get_name;
     id_cns_impl->id_constr.ops->set_name = 
-            axis2_xml_schema_identity_constraint_set_name;
+            xml_schema_identity_constraint_set_name;
     id_cns_impl->id_constr.ops->get_selector = 
-            axis2_xml_schema_identity_constraint_get_selector;
+            xml_schema_identity_constraint_get_selector;
     id_cns_impl->id_constr.ops->set_selector = 
-            axis2_xml_schema_identity_constraint_set_selector;
+            xml_schema_identity_constraint_set_selector;
    
     id_cns_impl->methods = axis2_hash_make(env);
     id_cns_impl->ht_super = axis2_hash_make(env);
     
     if(!id_cns_impl->methods || !id_cns_impl->ht_super)
     {
-        axis2_xml_schema_identity_constraint_free(&(id_cns_impl->id_constr), env);
+        xml_schema_identity_constraint_free(&(id_cns_impl->id_constr), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     axis2_hash_set(id_cns_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
-            axis2_xml_schema_identity_constraint_free);
+            xml_schema_identity_constraint_free);
     axis2_hash_set(id_cns_impl->methods, "get_fields", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_get_fields);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_get_fields);
     axis2_hash_set(id_cns_impl->methods, "get_type", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_get_type);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_get_type);
     axis2_hash_set(id_cns_impl->methods, "super_objs", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_super_objs);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_super_objs);
     axis2_hash_set(id_cns_impl->methods, "get_refer", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_get_refer);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_get_refer);
     axis2_hash_set(id_cns_impl->methods, "set_refer", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_set_refer);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_set_refer);
     axis2_hash_set(id_cns_impl->methods, "get_name", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_get_name);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_get_name);
     axis2_hash_set(id_cns_impl->methods, "set_name", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_set_name);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_set_name);
     axis2_hash_set(id_cns_impl->methods, "get_selector", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_get_selector);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_get_selector);
     axis2_hash_set(id_cns_impl->methods, "set_selector", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_identity_constraint_set_selector);
+            AXIS2_HASH_KEY_STRING, xml_schema_identity_constraint_set_selector);
     
-    id_cns_impl->annotated = axis2_xml_schema_annotated_create(env);
+    id_cns_impl->annotated = xml_schema_annotated_create(env);
     if(!id_cns_impl->annotated)
     {
-        axis2_xml_schema_identity_constraint_free(&(id_cns_impl->id_constr), env);
+        xml_schema_identity_constraint_free(&(id_cns_impl->id_constr), env);
         return NULL;
     }
     
-    axis2_hash_set(id_cns_impl->ht_super, "AXIS2_XML_SCHEMA_IDENTITY_CONSTRAINT", 
+    axis2_hash_set(id_cns_impl->ht_super, "XML_SCHEMA_IDENTITY_CONSTRAINT", 
             AXIS2_HASH_KEY_STRING, &(id_cns_impl->id_constr));
-    axis2_hash_set(id_cns_impl->ht_super, "AXIS2_XML_SCHEMA_ANNOTATED", 
+    axis2_hash_set(id_cns_impl->ht_super, "XML_SCHEMA_ANNOTATED", 
             AXIS2_HASH_KEY_STRING, id_cns_impl->annotated);
-    axis2_hash_set(id_cns_impl->ht_super, "AXIS2_XML_SCHEMA_OBJ", 
+    axis2_hash_set(id_cns_impl->ht_super, "XML_SCHEMA_OBJ", 
             AXIS2_HASH_KEY_STRING, 
-            AXIS2_XML_SCHEMA_ANNOTATED_GET_BASE_IMPL(id_cns_impl->annotated, env));                 
-    status = axis2_xml_schema_annotated_resolve_methods(
+            XML_SCHEMA_ANNOTATED_GET_BASE_IMPL(id_cns_impl->annotated, env));                 
+    status = xml_schema_annotated_resolve_methods(
             &(id_cns_impl->id_constr.base), 
             env, id_cns_impl->annotated, 
             id_cns_impl->methods);
     return &(id_cns_impl->id_constr);
 }
 
-AXIS2_EXTERN axis2_xml_schema_identity_constraint_t * AXIS2_CALL
-axis2_xml_schema_unique_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_identity_constraint_t * AXIS2_CALL
+xml_schema_unique_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_identity_constraint_t *id_cns = NULL;
-    id_cns = axis2_xml_schema_identity_constraint_create(env);
-    AXIS2_INTF_TO_IMPL(id_cns)->obj_type = AXIS2_XML_SCHEMA_UNIQUE;
+    xml_schema_identity_constraint_t *id_cns = NULL;
+    id_cns = xml_schema_identity_constraint_create(env);
+    AXIS2_INTF_TO_IMPL(id_cns)->obj_type = XML_SCHEMA_UNIQUE;
     return id_cns;        
 }
 
-AXIS2_EXTERN axis2_xml_schema_identity_constraint_t * AXIS2_CALL
-axis2_xml_schema_keyref_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_identity_constraint_t * AXIS2_CALL
+xml_schema_keyref_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_identity_constraint_t *id_cns = NULL;
-    id_cns = axis2_xml_schema_identity_constraint_create(env);
-    AXIS2_INTF_TO_IMPL(id_cns)->obj_type = AXIS2_XML_SCHEMA_KEYREF;
+    xml_schema_identity_constraint_t *id_cns = NULL;
+    id_cns = xml_schema_identity_constraint_create(env);
+    AXIS2_INTF_TO_IMPL(id_cns)->obj_type = XML_SCHEMA_KEYREF;
     return id_cns;        
 }
 
-AXIS2_EXTERN axis2_xml_schema_identity_constraint_t * AXIS2_CALL
-axis2_xml_schema_key_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_identity_constraint_t * AXIS2_CALL
+xml_schema_key_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_identity_constraint_t *id_cns = NULL;
-    id_cns = axis2_xml_schema_identity_constraint_create(env);
-    AXIS2_INTF_TO_IMPL(id_cns)->obj_type = AXIS2_XML_SCHEMA_KEY;
+    xml_schema_identity_constraint_t *id_cns = NULL;
+    id_cns = xml_schema_identity_constraint_create(env);
+    AXIS2_INTF_TO_IMPL(id_cns)->obj_type = XML_SCHEMA_KEY;
     return id_cns;        
 }
 
-AXIS2_EXTERN axis2_xml_schema_identity_constraint_t * AXIS2_CALL
-axis2_xml_schema_keyref_create(const axis2_env_t *env);
+AXIS2_EXTERN xml_schema_identity_constraint_t * AXIS2_CALL
+xml_schema_keyref_create(const axis2_env_t *env);
 
-AXIS2_EXTERN axis2_xml_schema_identity_constraint_t * AXIS2_CALL
-axis2_xml_schema_key_create(const axis2_env_t *env);
+AXIS2_EXTERN xml_schema_identity_constraint_t * AXIS2_CALL
+xml_schema_key_create(const axis2_env_t *env);
 
 
 
 
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_free(void *id_constr,
+xml_schema_identity_constraint_free(void *id_constr,
                                     const axis2_env_t *env)
 {
-    axis2_xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
+    xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     id_cns_impl = AXIS2_INTF_TO_IMPL(id_constr);
@@ -254,7 +254,7 @@
 
     if(NULL != id_cns_impl->selector)
     {
-        AXIS2_XML_SCHEMA_XPATH_FREE(id_cns_impl->selector, env);
+        XML_SCHEMA_XPATH_FREE(id_cns_impl->selector, env);
         id_cns_impl->selector = NULL;
     }
     
@@ -275,7 +275,7 @@
     }
     if(NULL != id_cns_impl->annotated)
     {
-        AXIS2_XML_SCHEMA_ANNOTATED_FREE(id_cns_impl->annotated, env);
+        XML_SCHEMA_ANNOTATED_FREE(id_cns_impl->annotated, env);
         id_cns_impl->annotated = NULL;
     }
     
@@ -298,11 +298,11 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_xml_schema_annotated_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_base_impl(void *id_constr,
+xml_schema_annotated_t *AXIS2_CALL
+xml_schema_identity_constraint_get_base_impl(void *id_constr,
                                 const axis2_env_t *env)
 {
-    axis2_xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
+    xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
     id_cns_impl = AXIS2_INTF_TO_IMPL(id_constr);
@@ -312,22 +312,22 @@
 
 /*
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_resolve_methods(
-                axis2_xml_schema_identity_constraint_t *id_constr,
+xml_schema_identity_constraint_resolve_methods(
+                xml_schema_identity_constraint_t *id_constr,
                 const axis2_env_t *env,
-                axis2_xml_schema_identity_constraint_t *id_cns_impl,
+                xml_schema_identity_constraint_t *id_cns_impl,
                 axis2_hash_t *methods)
 {
-    axis2_xml_schema_identity_constraint_impl_t *identity_constraint_impl_l = NULL;
+    xml_schema_identity_constraint_impl_t *identity_constraint_impl_l = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, id_cns_impl, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, methods, AXIS2_FAILURE);
     
-    identity_constraint_impl_l = (axis2_xml_schema_identity_constraint_impl_t *) id_cns_impl;
+    identity_constraint_impl_l = (xml_schema_identity_constraint_impl_t *) id_cns_impl;
     
     id_constr->ops = AXIS2_MALLOC(env->allocator, 
-            sizeof(axis2_xml_schema_identity_constraint_ops_t));
+            sizeof(xml_schema_identity_constraint_ops_t));
     if(NULL == id_constr->ops)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -348,19 +348,19 @@
     id_constr->ops->set_selector = 
             identity_constraint_impl_l->id_constr.ops->set_selector;
     
-    return axis2_xml_schema_annotated_resolve_methods(&(id_constr->base), 
+    return xml_schema_annotated_resolve_methods(&(id_constr->base), 
             env, identity_constraint_impl_l->annotated, methods);
 }
 */
-axis2_xml_schema_obj_collection_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_fields(void *id_constr,
+xml_schema_obj_collection_t *AXIS2_CALL
+xml_schema_identity_constraint_get_fields(void *id_constr,
                                                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(id_constr)->fields;
 }
 axis2_char_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_name(void *id_constr,
+xml_schema_identity_constraint_get_name(void *id_constr,
                                 const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
@@ -368,11 +368,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_set_name(void *id_constr,
+xml_schema_identity_constraint_set_name(void *id_constr,
                                 const axis2_env_t *env,
                                 axis2_char_t *name)
 {
-    axis2_xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
+    xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     id_cns_impl = AXIS2_INTF_TO_IMPL(id_constr);
@@ -391,8 +391,8 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_xml_schema_xpath_t *AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_selector(void *id_constr,
+xml_schema_xpath_t *AXIS2_CALL
+xml_schema_identity_constraint_get_selector(void *id_constr,
                                                     const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
@@ -400,11 +400,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_set_selector(void *id_constr,
+xml_schema_identity_constraint_set_selector(void *id_constr,
                                     const axis2_env_t *env,
-                                    axis2_xml_schema_xpath_t *selector)
+                                    xml_schema_xpath_t *selector)
 {
-    axis2_xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
+    xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, selector, AXIS2_FAILURE);
@@ -415,8 +415,8 @@
 }
 
 
-axis2_xml_schema_types_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_type(void *id_constr,
+xml_schema_types_t AXIS2_CALL
+xml_schema_identity_constraint_get_type(void *id_constr,
                                         const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(id_constr)->obj_type;
@@ -424,24 +424,24 @@
                                         
 
 axis2_hash_t* AXIS2_CALL
-axis2_xml_schema_identity_constraint_super_objs(void *id_constr,
+xml_schema_identity_constraint_super_objs(void *id_constr,
                                         const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(id_constr)->ht_super;
 }                                                                                   
 axis2_qname_t* AXIS2_CALL
-axis2_xml_schema_identity_constraint_get_refer(void *id_constr,
+xml_schema_identity_constraint_get_refer(void *id_constr,
                                              const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(id_constr)->refer;
 }                                             
                                              
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_identity_constraint_set_refer(void *id_constr,
+xml_schema_identity_constraint_set_refer(void *id_constr,
                                              const axis2_env_t *env,
                                               axis2_qname_t *refer)
 {
-    axis2_xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
+    xml_schema_identity_constraint_impl_t *id_cns_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, refer, AXIS2_FAILURE);
     id_cns_impl = AXIS2_INTF_TO_IMPL(id_constr);

Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_import.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_import.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_import.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_import.c Mon Jun 12 03:29:40 2006
@@ -14,68 +14,68 @@
  * limitations under the License.
  */
 
-#include  <axis2_xml_schema_import.h>
-#include  <axis2_xml_schema.h>
+#include  <xml_schema_import.h>
+#include  <xml_schema.h>
 #include <axis2_utils.h>
 /** 
- * @brief axis2_xml_schema_import_impl
+ * @brief xml_schema_import_impl
  */ 
-typedef struct axis2_xml_schema_import_impl
+typedef struct xml_schema_import_impl
 {
-    axis2_xml_schema_import_t import;
+    xml_schema_import_t import;
     
-    axis2_xml_schema_external_t *external;
+    xml_schema_external_t *external;
         
     axis2_char_t *ns;
     
     axis2_hash_t *ht_super;
     
-    axis2_xml_schema_types_t obj_type;
+    xml_schema_types_t obj_type;
         
     axis2_hash_t *methods;
 
-}axis2_xml_schema_import_impl_t;
+}xml_schema_import_impl_t;
 
 #define AXIS2_INTF_TO_IMPL(import) \
-        ((axis2_xml_schema_import_impl_t *) import)
+        ((xml_schema_import_impl_t *) import)
 
 /********************* function prototypes ***********************************/
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_import_free(void *import,
+xml_schema_import_free(void *import,
                         const axis2_env_t *env);
 
-axis2_xml_schema_external_t *AXIS2_CALL
-axis2_xml_schema_import_get_base_impl(void *import,
+xml_schema_external_t *AXIS2_CALL
+xml_schema_import_get_base_impl(void *import,
                                         const axis2_env_t *env);
 
-axis2_xml_schema_types_t AXIS2_CALL
-axis2_xml_schema_import_get_type(void *import,
+xml_schema_types_t AXIS2_CALL
+xml_schema_import_get_type(void *import,
                             const axis2_env_t *env);
                             
 axis2_hash_t *AXIS2_CALL
-axis2_xml_schema_import_super_objs(void *import,
+xml_schema_import_super_objs(void *import,
                                     const axis2_env_t *env);
 axis2_char_t* AXIS2_CALL
-axis2_xml_schema_import_get_namespace(void *import,
+xml_schema_import_get_namespace(void *import,
                                      const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_import_set_namespace(void *import,
+xml_schema_import_set_namespace(void *import,
                                      const axis2_env_t *env,
                                      axis2_char_t *ns);
 
 /********************* end function prototypes ********************************/
 
-AXIS2_EXTERN axis2_xml_schema_import_t * AXIS2_CALL
-axis2_xml_schema_import_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_import_t * AXIS2_CALL
+xml_schema_import_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_import_impl_t *import_impl = NULL;
-    axis2_xml_schema_annotated_t *annotated = NULL;
+    xml_schema_import_impl_t *import_impl = NULL;
+    xml_schema_annotated_t *annotated = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
     import_impl = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_import_impl_t));
+                    sizeof(xml_schema_import_impl_t));
     if(!import_impl)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -87,85 +87,85 @@
     import_impl->import.ops = NULL;
     import_impl->import.base.ops = NULL;
     import_impl->ht_super = NULL;
-    import_impl->obj_type = AXIS2_XML_SCHEMA_IMPORT;
+    import_impl->obj_type = XML_SCHEMA_IMPORT;
     
     import_impl->import.ops = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_import_ops_t));
+                    sizeof(xml_schema_import_ops_t));
 
     if(!import_impl->import.ops)
     {
-        axis2_xml_schema_import_free(&(import_impl->import), env);
+        xml_schema_import_free(&(import_impl->import), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     
     import_impl->import.ops->free = 
-        axis2_xml_schema_import_free;
+        xml_schema_import_free;
     import_impl->import.ops->get_base_impl = 
-        axis2_xml_schema_import_get_base_impl;
+        xml_schema_import_get_base_impl;
     import_impl->import.ops->get_type =
-        axis2_xml_schema_import_get_type;
+        xml_schema_import_get_type;
     import_impl->import.ops->super_objs =
-        axis2_xml_schema_import_super_objs;        
+        xml_schema_import_super_objs;        
     import_impl->import.ops->get_namespace = 
-            axis2_xml_schema_import_get_namespace;
+            xml_schema_import_get_namespace;
     import_impl->import.ops->set_namespace = 
-            axis2_xml_schema_import_set_namespace;
+            xml_schema_import_set_namespace;
 
     import_impl->methods = axis2_hash_make(env);
     import_impl->ht_super = axis2_hash_make(env);
     if(!import_impl->methods || !import_impl->ht_super)
     {
-        axis2_xml_schema_import_free(&(import_impl->import), env);
+        xml_schema_import_free(&(import_impl->import), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
 
     axis2_hash_set(import_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
-            axis2_xml_schema_import_free);
+            xml_schema_import_free);
     axis2_hash_set(import_impl->methods, "get_type", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_import_get_type);
+            AXIS2_HASH_KEY_STRING, xml_schema_import_get_type);
     axis2_hash_set(import_impl->methods, "super_objs", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_import_super_objs);
+            AXIS2_HASH_KEY_STRING, xml_schema_import_super_objs);
     axis2_hash_set(import_impl->methods, "get_namespace", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_import_get_namespace);
+            AXIS2_HASH_KEY_STRING, xml_schema_import_get_namespace);
     axis2_hash_set(import_impl->methods, "set_namespace", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_import_set_namespace);
+            AXIS2_HASH_KEY_STRING, xml_schema_import_set_namespace);
 
-    import_impl->external = axis2_xml_schema_external_create(env);
+    import_impl->external = xml_schema_external_create(env);
      if(!import_impl->external)
     {
-        axis2_xml_schema_import_free(&(import_impl->import), env);
+        xml_schema_import_free(&(import_impl->import), env);
         return NULL;
     }
     
-    axis2_hash_set(import_impl->ht_super, "AXIS2_XML_SCHEMA_IMPORT", 
+    axis2_hash_set(import_impl->ht_super, "XML_SCHEMA_IMPORT", 
             AXIS2_HASH_KEY_STRING, &(import_impl->import));
-    axis2_hash_set(import_impl->ht_super, "AXIS2_XML_SCHEMA_EXTERNAL", 
+    axis2_hash_set(import_impl->ht_super, "XML_SCHEMA_EXTERNAL", 
             AXIS2_HASH_KEY_STRING, import_impl->external);
 
-    annotated = AXIS2_XML_SCHEMA_EXTERNAL_GET_BASE_IMPL(import_impl->external, env);
+    annotated = XML_SCHEMA_EXTERNAL_GET_BASE_IMPL(import_impl->external, env);
     if(NULL != annotated)
     { 
         
-        axis2_hash_set(import_impl->ht_super, "AXIS2_XML_SCHEMA_ANNOTATED", 
+        axis2_hash_set(import_impl->ht_super, "XML_SCHEMA_ANNOTATED", 
             AXIS2_HASH_KEY_STRING, annotated);
-        axis2_hash_set(import_impl->ht_super, "AXIS2_XML_SCHEMA_OBJ", 
+        axis2_hash_set(import_impl->ht_super, "XML_SCHEMA_OBJ", 
             AXIS2_HASH_KEY_STRING, 
-            AXIS2_XML_SCHEMA_ANNOTATED_GET_BASE_IMPL(annotated, env));
+            XML_SCHEMA_ANNOTATED_GET_BASE_IMPL(annotated, env));
     }
     
-    status = axis2_xml_schema_external_resolve_methods(
+    status = xml_schema_external_resolve_methods(
             &(import_impl->import.base), env, import_impl->external, 
             import_impl->methods);
     return &(import_impl->import);
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_import_free(void *import,
+xml_schema_import_free(void *import,
                                     const axis2_env_t *env)
 {
-    axis2_xml_schema_import_impl_t *import_impl = NULL;
+    xml_schema_import_impl_t *import_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     import_impl = AXIS2_INTF_TO_IMPL(import);
@@ -182,7 +182,7 @@
     }
     if(NULL != import_impl->external)
     {
-        AXIS2_XML_SCHEMA_EXTERNAL_FREE(import_impl->external, env);
+        XML_SCHEMA_EXTERNAL_FREE(import_impl->external, env);
         import_impl->external = NULL;
     }
     
@@ -201,11 +201,11 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_xml_schema_external_t *AXIS2_CALL
-axis2_xml_schema_import_get_base_impl(void *import,
+xml_schema_external_t *AXIS2_CALL
+xml_schema_import_get_base_impl(void *import,
                                 const axis2_env_t *env)
 {
-    axis2_xml_schema_import_impl_t *import_impl = NULL;
+    xml_schema_import_impl_t *import_impl = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
     import_impl = AXIS2_INTF_TO_IMPL(import);
@@ -214,7 +214,7 @@
 }
 
 axis2_char_t * AXIS2_CALL
-axis2_xml_schema_import_get_namespace(void *import,
+xml_schema_import_get_namespace(void *import,
                                             const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
@@ -222,11 +222,11 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_import_set_namespace(void *import,
+xml_schema_import_set_namespace(void *import,
                                      const axis2_env_t *env,
                                      axis2_char_t *ns)
 {
-    axis2_xml_schema_import_impl_t *import_impl = NULL;
+    xml_schema_import_impl_t *import_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     import_impl = AXIS2_INTF_TO_IMPL(import);
     if(NULL != import_impl->ns)
@@ -238,15 +238,15 @@
     return AXIS2_SUCCESS;
 }
 
-axis2_xml_schema_types_t AXIS2_CALL
-axis2_xml_schema_import_get_type(void *import,
+xml_schema_types_t AXIS2_CALL
+xml_schema_import_get_type(void *import,
                             const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(import)->obj_type;
 }                            
                             
 axis2_hash_t *AXIS2_CALL
-axis2_xml_schema_import_super_objs(void *import,
+xml_schema_import_super_objs(void *import,
                                     const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(import)->ht_super;

Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_input_source.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_input_source.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_input_source.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_input_source.c Mon Jun 12 03:29:40 2006
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
  
- #include <axis2_xml_schema_includes.h>
+ #include <xml_schema_includes.h>
  #include <axis2_env.h>
  
  typedef struct xml_schema_input_source_impl 

Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj.c Mon Jun 12 03:29:40 2006
@@ -14,22 +14,22 @@
  * limitations under the License.
  */
  
-#include <axis2_xml_schema_obj.h>
+#include <xml_schema_obj.h>
 #include <axis2_hash.h>
 #include <axis2_utils.h>
 
-typedef struct axis2_xml_schema_obj_impl 
-                    axis2_xml_schema_obj_impl_t;
+typedef struct xml_schema_obj_impl 
+                    xml_schema_obj_impl_t;
 
 /** 
  * @brief Xml Schema Obj Struct Impl
  *   Axis2 Xml Schema Obj  
  */ 
-struct axis2_xml_schema_obj_impl
+struct xml_schema_obj_impl
 {
-    axis2_xml_schema_obj_t obj;
+    xml_schema_obj_t obj;
     
-    axis2_xml_schema_types_t obj_type;
+    xml_schema_types_t obj_type;
     
     axis2_hash_t *ht_super;
     
@@ -41,82 +41,82 @@
 };
 
 #define AXIS2_INTF_TO_IMPL(obj) \
-        ((axis2_xml_schema_obj_impl_t *) obj)
+        ((xml_schema_obj_impl_t *) obj)
 
 /***************** function pointers ******************************************/
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_obj_free(
+xml_schema_obj_free(
         void *obj,
         const axis2_env_t *env);
 
 axis2_hash_t *AXIS2_CALL 
-axis2_xml_schema_obj_super_objs(
+xml_schema_obj_super_objs(
         void *obj,
         const axis2_env_t *env);
 
-axis2_xml_schema_types_t AXIS2_CALL 
-axis2_xml_schema_obj_get_type(
+xml_schema_types_t AXIS2_CALL 
+xml_schema_obj_get_type(
         void *obj,
         const axis2_env_t *env);
 
 axis2_char_t * AXIS2_CALL
-axis2_xml_schema_obj_get_source_uri(
+xml_schema_obj_get_source_uri(
         void *obj,
         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_set_source_uri(
+xml_schema_obj_set_source_uri(
         void *obj,
         const axis2_env_t *env,
         axis2_char_t *source_uri);
 
 axis2_bool_t AXIS2_CALL
-axis2_xml_schema_obj_equals(
+xml_schema_obj_equals(
         void *obj,
         const axis2_env_t *env,
         void *obj_comp);
 
 int AXIS2_CALL
-axis2_xml_schema_obj_get_line_num(
+xml_schema_obj_get_line_num(
         void *obj,
         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_set_line_num(
+xml_schema_obj_set_line_num(
         void *obj,
         const axis2_env_t *env,
         int line_num);
 
 int AXIS2_CALL
-axis2_xml_schema_obj_get_line_pos(
+xml_schema_obj_get_line_pos(
         void *obj,
         const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_set_line_pos(
+xml_schema_obj_set_line_pos(
         void *obj,
         const axis2_env_t *env,
         int line_pos);
 
 /******************* end function pointers ************************************/
 
-AXIS2_EXTERN axis2_xml_schema_obj_t * AXIS2_CALL
-axis2_xml_schema_obj_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_obj_t * AXIS2_CALL
+xml_schema_obj_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     
     obj_impl = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_obj_impl_t));
+                    sizeof(xml_schema_obj_impl_t));
     if(!obj_impl)
     {
         AXIS2_ERROR_SET(env->error , AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
 
-    obj_impl->obj_type = AXIS2_XML_SCHEMA_OBJ;
+    obj_impl->obj_type = XML_SCHEMA_OBJ;
     obj_impl->ht_super = NULL;
     obj_impl->line_num = -1;
     obj_impl->line_pos = -1;
@@ -124,35 +124,35 @@
     obj_impl->obj.ops   = NULL;
     
     obj_impl->obj.ops = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_obj_ops_t)); 
+                    sizeof(xml_schema_obj_ops_t)); 
     if(!obj_impl->obj.ops)
     {
-        axis2_xml_schema_obj_free(&(obj_impl->obj), env);
+        xml_schema_obj_free(&(obj_impl->obj), env);
         AXIS2_ERROR_SET(env->error , 
             AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
 
     obj_impl->obj.ops->free = 
-        axis2_xml_schema_obj_free;
+        xml_schema_obj_free;
     obj_impl->obj.ops->super_objs = 
-        axis2_xml_schema_obj_super_objs;
+        xml_schema_obj_super_objs;
     obj_impl->obj.ops->get_type = 
-        axis2_xml_schema_obj_get_type;
+        xml_schema_obj_get_type;
     obj_impl->obj.ops->get_line_num = 
-        axis2_xml_schema_obj_get_line_num;
+        xml_schema_obj_get_line_num;
     obj_impl->obj.ops->set_line_num = 
-        axis2_xml_schema_obj_set_line_num;
+        xml_schema_obj_set_line_num;
     obj_impl->obj.ops->get_line_pos = 
-        axis2_xml_schema_obj_get_line_pos;
+        xml_schema_obj_get_line_pos;
     obj_impl->obj.ops->set_line_pos = 
-        axis2_xml_schema_obj_set_line_pos;
+        xml_schema_obj_set_line_pos;
     obj_impl->obj.ops->get_source_uri = 
-        axis2_xml_schema_obj_get_source_uri;
+        xml_schema_obj_get_source_uri;
     obj_impl->obj.ops->set_source_uri = 
-        axis2_xml_schema_obj_set_source_uri;
+        xml_schema_obj_set_source_uri;
     obj_impl->obj.ops->equals = 
-        axis2_xml_schema_obj_equals;
+        xml_schema_obj_equals;
 
     obj_impl->ht_super = axis2_hash_make(env);
     if(!obj_impl->ht_super)
@@ -160,7 +160,7 @@
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    axis2_hash_set(obj_impl->ht_super, "AXIS2_XML_SCHEMA_OBJ", AXIS2_HASH_KEY_STRING, 
+    axis2_hash_set(obj_impl->ht_super, "XML_SCHEMA_OBJ", AXIS2_HASH_KEY_STRING, 
             &(obj_impl->obj));
     
     return &(obj_impl->obj);
@@ -168,10 +168,10 @@
 
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_free(void *obj,
+xml_schema_obj_free(void *obj,
                 const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
 
     obj_impl = AXIS2_INTF_TO_IMPL(obj);
 
@@ -202,41 +202,41 @@
 }
 
 axis2_hash_t *AXIS2_CALL
-axis2_xml_schema_obj_super_objs(void *obj,
+xml_schema_obj_super_objs(void *obj,
                 const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     obj_impl = AXIS2_INTF_TO_IMPL(obj);
     return obj_impl->ht_super;
 }
 
-axis2_xml_schema_types_t AXIS2_CALL
-axis2_xml_schema_obj_get_type(
+xml_schema_types_t AXIS2_CALL
+xml_schema_obj_get_type(
         void *obj,
         const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     obj_impl = AXIS2_INTF_TO_IMPL(obj);
     return obj_impl->obj_type;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_resolve_methods(
-        axis2_xml_schema_obj_t *obj,
+xml_schema_obj_resolve_methods(
+        xml_schema_obj_t *obj,
         const axis2_env_t *env,
-        axis2_xml_schema_obj_t *obj_impl,
+        xml_schema_obj_t *obj_impl,
         axis2_hash_t *methods)
 {    
-    axis2_xml_schema_obj_impl_t *obj_impl_l = NULL;
+    xml_schema_obj_impl_t *obj_impl_l = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, obj_impl, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, methods, AXIS2_FAILURE);
     
-    obj_impl_l = (axis2_xml_schema_obj_impl_t *) obj_impl;
+    obj_impl_l = (xml_schema_obj_impl_t *) obj_impl;
     
     obj->ops = AXIS2_MALLOC(env->allocator, 
-            sizeof(axis2_xml_schema_obj_ops_t));
+            sizeof(xml_schema_obj_ops_t));
     if(!obj->ops)
     {
         AXIS2_ERROR_SET(env->error , AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -275,17 +275,17 @@
     return AXIS2_SUCCESS;    
 }
 int AXIS2_CALL
-axis2_xml_schema_obj_get_line_num(void *obj,
+xml_schema_obj_get_line_num(void *obj,
                                     const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
 
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
     if(NULL != super)
     {
         obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, 
-            "AXIS2_XML_SCHEMA_OBJ", AXIS2_HASH_KEY_STRING));
+            "XML_SCHEMA_OBJ", AXIS2_HASH_KEY_STRING));
         if(NULL != obj_impl)
             return obj_impl->line_num;
     }
@@ -293,17 +293,17 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_set_line_num(void *obj,
+xml_schema_obj_set_line_num(void *obj,
                         const axis2_env_t *env,
                         int line_num)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
 
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
     if(NULL != super)
     {
-        obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "AXIS2_XML_SCHEMA_OBJ", 
+        obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "XML_SCHEMA_OBJ", 
                 AXIS2_HASH_KEY_STRING));
     }
     else
@@ -316,33 +316,33 @@
 }
 
 int AXIS2_CALL
-axis2_xml_schema_obj_get_line_pos(void *obj,
+xml_schema_obj_get_line_pos(void *obj,
                                     const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
     
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
     if(NULL != super)
     {
-        obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "AXIS2_XML_SCHEMA_OBJ", 
+        obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "XML_SCHEMA_OBJ", 
                     AXIS2_HASH_KEY_STRING));
     }
     return obj_impl->line_pos;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_set_line_pos(void *obj,
+xml_schema_obj_set_line_pos(void *obj,
                         const axis2_env_t *env,
                         int line_pos)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
 
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
     if(NULL != super)
     {
-        obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "AXIS2_XML_SCHEMA_OBJ", 
+        obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "XML_SCHEMA_OBJ", 
                     AXIS2_HASH_KEY_STRING));
         if(NULL != obj_impl)
             obj_impl->line_pos = line_pos;
@@ -351,27 +351,27 @@
 }
 
 axis2_char_t * AXIS2_CALL
-axis2_xml_schema_obj_get_source_uri(void *obj,
+xml_schema_obj_get_source_uri(void *obj,
                                     const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
-    obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "AXIS2_XML_SCHEMA_OBJ", 
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "XML_SCHEMA_OBJ", 
                 AXIS2_HASH_KEY_STRING));
     return obj_impl->source_uri;
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_set_source_uri(void *obj,
+xml_schema_obj_set_source_uri(void *obj,
                         const axis2_env_t *env,
                         axis2_char_t *source_uri)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
 
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
-    obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "AXIS2_XML_SCHEMA_OBJ", 
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "XML_SCHEMA_OBJ", 
                 AXIS2_HASH_KEY_STRING));
 
     if(NULL != obj_impl->source_uri)
@@ -385,15 +385,15 @@
 }
 
 axis2_bool_t AXIS2_CALL
-axis2_xml_schema_obj_equals(void *obj,
+xml_schema_obj_equals(void *obj,
                                 const axis2_env_t *env,
                                 void *obj_comp)
 {
-    axis2_xml_schema_obj_impl_t *obj_impl = NULL;
+    xml_schema_obj_impl_t *obj_impl = NULL;
     axis2_hash_t *super = NULL;
 
-    super = AXIS2_XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
-    obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "AXIS2_XML_SCHEMA_OBJ", 
+    super = XML_SCHEMA_OBJ_SUPER_OBJS(obj, env);
+    obj_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(super, "XML_SCHEMA_OBJ", 
                 AXIS2_HASH_KEY_STRING));
     /****
         TODO

Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_collection.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_collection.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_collection.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_collection.c Mon Jun 12 03:29:40 2006
@@ -14,89 +14,89 @@
  * limitations under the License.
  */
  
-#include <axis2_xml_schema_obj_collection.h>
+#include <xml_schema_obj_collection.h>
 #include <axis2_hash.h>
 #include <axis2_utils.h>
 
-typedef struct axis2_xml_schema_obj_collection_impl 
-                axis2_xml_schema_obj_collection_impl_t;
+typedef struct xml_schema_obj_collection_impl 
+                xml_schema_obj_collection_impl_t;
 
 /** 
  * @brief Xml Schema Obj Struct Impl
  *   Axis2 Xml Schema Obj  
  */ 
-struct axis2_xml_schema_obj_collection_impl
+struct xml_schema_obj_collection_impl
 {
-    axis2_xml_schema_obj_collection_t obj_collection;
+    xml_schema_obj_collection_t obj_collection;
     axis2_array_list_t *objs;
 };
 
 #define AXIS2_INTF_TO_IMPL(obj_collection) \
-        ((axis2_xml_schema_obj_collection_impl_t *) obj_collection)
+        ((xml_schema_obj_collection_impl_t *) obj_collection)
 
 /**************************** end function prototypes ************************/ 
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_obj_collection_free(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_free(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env);
 
 int AXIS2_CALL
-axis2_xml_schema_obj_collection_get_count(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_get_count(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env);
 
-axis2_xml_schema_obj_t *AXIS2_CALL
-axis2_xml_schema_obj_collection_get_item(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_t *AXIS2_CALL
+xml_schema_obj_collection_get_item(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         int i);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_collection_set_item(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_set_item(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         int i,
         void *item);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_collection_add(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_add(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         void *item);
 
 axis2_bool_t AXIS2_CALL
-axis2_xml_schema_obj_collection_contains(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_contains(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         void *item);
 
 int AXIS2_CALL
-axis2_xml_schema_obj_collection_index_of(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_index_of(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         void *item);
 
 void* AXIS2_CALL
-axis2_xml_schema_obj_collection_remove_at(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_remove_at(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         int index);
         
 axis2_array_list_t* AXIS2_CALL
-axis2_xml_schema_obj_collection_to_array(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_to_array(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env); 
         
                   
 
-AXIS2_EXTERN axis2_xml_schema_obj_collection_t * AXIS2_CALL
-axis2_xml_schema_obj_collection_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_obj_collection_t * AXIS2_CALL
+xml_schema_obj_collection_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
     
     obj_collection_impl = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_obj_collection_impl_t));
+                    sizeof(xml_schema_obj_collection_impl_t));
     if(!obj_collection_impl)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -105,48 +105,48 @@
 
     obj_collection_impl->objs = NULL;
     obj_collection_impl->obj_collection.ops = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_obj_collection_ops_t)); 
+                    sizeof(xml_schema_obj_collection_ops_t)); 
 
     if(!obj_collection_impl->obj_collection.ops)
     {
-        AXIS2_XML_SCHEMA_OBJ_COLLECTION_FREE(&(obj_collection_impl->obj_collection), env);
+        XML_SCHEMA_OBJ_COLLECTION_FREE(&(obj_collection_impl->obj_collection), env);
         return NULL;            
     }
     
     obj_collection_impl->objs = axis2_array_list_create(env, 0);
     if(!obj_collection_impl->objs)
     {
-        axis2_xml_schema_obj_collection_free(&(obj_collection_impl->obj_collection), env);
+        xml_schema_obj_collection_free(&(obj_collection_impl->obj_collection), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     obj_collection_impl->obj_collection.ops->free = 
-            axis2_xml_schema_obj_collection_free;
+            xml_schema_obj_collection_free;
     obj_collection_impl->obj_collection.ops->get_count = 
-            axis2_xml_schema_obj_collection_get_count;
+            xml_schema_obj_collection_get_count;
     obj_collection_impl->obj_collection.ops->get_item = 
-            axis2_xml_schema_obj_collection_get_item;
+            xml_schema_obj_collection_get_item;
     obj_collection_impl->obj_collection.ops->set_item = 
-            axis2_xml_schema_obj_collection_set_item;
+            xml_schema_obj_collection_set_item;
     obj_collection_impl->obj_collection.ops->add = 
-            axis2_xml_schema_obj_collection_add;
+            xml_schema_obj_collection_add;
     obj_collection_impl->obj_collection.ops->contains = 
-            axis2_xml_schema_obj_collection_contains;
+            xml_schema_obj_collection_contains;
     obj_collection_impl->obj_collection.ops->index_of = 
-            axis2_xml_schema_obj_collection_index_of;
+            xml_schema_obj_collection_index_of;
     obj_collection_impl->obj_collection.ops->remove_at = 
-            axis2_xml_schema_obj_collection_remove_at;
+            xml_schema_obj_collection_remove_at;
 
     return &(obj_collection_impl->obj_collection);
 }
 
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_collection_free(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_free(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
 
     obj_collection_impl = AXIS2_INTF_TO_IMPL(obj_collection);
 
@@ -169,23 +169,23 @@
 
 
 int AXIS2_CALL
-axis2_xml_schema_obj_collection_get_count(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_get_count(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     obj_collection_impl = AXIS2_INTF_TO_IMPL(obj_collection);
     return AXIS2_ARRAY_LIST_SIZE(obj_collection_impl->objs, env);
 }
 
-axis2_xml_schema_obj_t *AXIS2_CALL
-axis2_xml_schema_obj_collection_get_item(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_t *AXIS2_CALL
+xml_schema_obj_collection_get_item(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         int i)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     obj_collection_impl = AXIS2_INTF_TO_IMPL(obj_collection);
@@ -193,13 +193,13 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_collection_set_item(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_set_item(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         int i,
         void *item)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, item, AXIS2_FAILURE);
@@ -210,12 +210,12 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_collection_add(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_add(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         void *item)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, item, AXIS2_FAILURE);
@@ -224,12 +224,12 @@
 }
 
 axis2_bool_t AXIS2_CALL
-axis2_xml_schema_obj_collection_contains(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_contains(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         void *item)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, item, AXIS2_FAILURE);
@@ -239,12 +239,12 @@
 }
 
 int AXIS2_CALL
-axis2_xml_schema_obj_collection_index_of(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_index_of(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         void *item)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, item, AXIS2_FAILURE);
@@ -253,12 +253,12 @@
 }
 
 void* AXIS2_CALL
-axis2_xml_schema_obj_collection_remove_at(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_remove_at(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env,
         int index)
 {
-    axis2_xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
+    xml_schema_obj_collection_impl_t *obj_collection_impl = NULL;
     void *item = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     obj_collection_impl = AXIS2_INTF_TO_IMPL(obj_collection);
@@ -267,8 +267,8 @@
 }
 
 axis2_array_list_t* AXIS2_CALL
-axis2_xml_schema_obj_collection_to_array(
-        axis2_xml_schema_obj_collection_t *obj_collection,
+xml_schema_obj_collection_to_array(
+        xml_schema_obj_collection_t *obj_collection,
         const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(obj_collection)->objs;

Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_table.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_table.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_table.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_obj_table.c Mon Jun 12 03:29:40 2006
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
  
-#include <axis2_xml_schema_obj_table.h>
+#include <xml_schema_obj_table.h>
 #include <axis2_hash.h>
 
-typedef struct axis2_xml_schema_obj_table_impl 
-                axis2_xml_schema_obj_table_impl_t;
+typedef struct xml_schema_obj_table_impl 
+                xml_schema_obj_table_impl_t;
 
 /** 
  * @brief Xml Schema Obj Struct Impl
  *   Axis2 Xml Schema Obj  
  */ 
-struct axis2_xml_schema_obj_table_impl
+struct xml_schema_obj_table_impl
 {
-    axis2_xml_schema_obj_table_t obj_table;
+    xml_schema_obj_table_t obj_table;
     
     axis2_hash_t *collection;
     
@@ -36,69 +36,69 @@
 };
 
 #define AXIS2_INTF_TO_IMPL(obj_table) \
-        ((axis2_xml_schema_obj_table_impl_t *) obj_table)
+        ((xml_schema_obj_table_impl_t *) obj_table)
 
 /******************** function prototypes **************************************/
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_obj_table_free(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_free(xml_schema_obj_table_t *obj_table,
                 const axis2_env_t *env);
 
 int AXIS2_CALL
-axis2_xml_schema_obj_table_get_count(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_count(xml_schema_obj_table_t *obj_table,
                                      const axis2_env_t *env);
 
 void *AXIS2_CALL
-axis2_xml_schema_obj_table_get_item(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_item(xml_schema_obj_table_t *obj_table,
                                     const axis2_env_t *env,
                                     axis2_qname_t *qname);
 
 axis2_array_list_t *AXIS2_CALL
-axis2_xml_schema_obj_table_get_names(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_names(xml_schema_obj_table_t *obj_table,
                                      const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL
-axis2_xml_schema_obj_table_get_values(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_values(xml_schema_obj_table_t *obj_table,
                                       const axis2_env_t *env);
 
 axis2_bool_t AXIS2_CALL
-axis2_xml_schema_obj_table_contains(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_contains(xml_schema_obj_table_t *obj_table,
                                     const axis2_env_t *env,
                                     axis2_qname_t *qname);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_table_add(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_add(xml_schema_obj_table_t *obj_table,
                                     const axis2_env_t *env,
                                     axis2_qname_t *qname,
                                     void *value);
                                     
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_obj_table_put(
-        axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_put(
+        xml_schema_obj_table_t *obj_table,
         const axis2_env_t *env,
         axis2_char_t *key,
         void *value);
         
 void* AXIS2_CALL 
-axis2_xml_schema_obj_table_get(
-        axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get(
+        xml_schema_obj_table_t *obj_table,
         const axis2_env_t *env,
         axis2_char_t *key);
 
 axis2_hash_t* AXIS2_CALL 
-axis2_xml_schema_obj_table_get_hash_table(
-        axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_hash_table(
+        xml_schema_obj_table_t *obj_table,
         const axis2_env_t *env);
                                     
 /******************** end function pointers ***********************************/
 
-AXIS2_EXTERN axis2_xml_schema_obj_table_t * AXIS2_CALL
-axis2_xml_schema_obj_table_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_obj_table_t * AXIS2_CALL
+xml_schema_obj_table_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     
     obj_table_impl = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_obj_table_impl_t));
+                    sizeof(xml_schema_obj_table_impl_t));
 
     if(!obj_table_impl)
     {
@@ -111,10 +111,10 @@
     obj_table_impl->obj_table.ops = NULL;
 
     obj_table_impl->obj_table.ops = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_obj_table_ops_t)); 
+                    sizeof(xml_schema_obj_table_ops_t)); 
     if(!obj_table_impl->obj_table.ops)
     {
-        axis2_xml_schema_obj_table_free(&(obj_table_impl->obj_table), env);
+        xml_schema_obj_table_free(&(obj_table_impl->obj_table), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
@@ -127,29 +127,29 @@
         return NULL;
     }
     obj_table_impl->obj_table.ops->free = 
-            axis2_xml_schema_obj_table_free;
+            xml_schema_obj_table_free;
     obj_table_impl->obj_table.ops->get_count = 
-            axis2_xml_schema_obj_table_get_count;
+            xml_schema_obj_table_get_count;
     obj_table_impl->obj_table.ops->get_item = 
-            axis2_xml_schema_obj_table_get_item;
+            xml_schema_obj_table_get_item;
     obj_table_impl->obj_table.ops->get_names = 
-            axis2_xml_schema_obj_table_get_names;
+            xml_schema_obj_table_get_names;
     obj_table_impl->obj_table.ops->get_values = 
-            axis2_xml_schema_obj_table_get_values;
+            xml_schema_obj_table_get_values;
     obj_table_impl->obj_table.ops->contains = 
-            axis2_xml_schema_obj_table_contains;
+            xml_schema_obj_table_contains;
     obj_table_impl->obj_table.ops->add = 
-            axis2_xml_schema_obj_table_add;
+            xml_schema_obj_table_add;
 
     return &(obj_table_impl->obj_table);
 }
 
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_table_free(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_free(xml_schema_obj_table_t *obj_table,
                                         const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
 
     obj_table_impl = AXIS2_INTF_TO_IMPL(obj_table);
 
@@ -183,10 +183,10 @@
 }
 
 int AXIS2_CALL
-axis2_xml_schema_obj_table_get_count(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_count(xml_schema_obj_table_t *obj_table,
                                             const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     obj_table_impl = AXIS2_INTF_TO_IMPL(obj_table);
     if(NULL != obj_table_impl->collection)
@@ -198,11 +198,11 @@
 }   
 
 void *AXIS2_CALL
-axis2_xml_schema_obj_table_get_item(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_item(xml_schema_obj_table_t *obj_table,
                                     const axis2_env_t *env,
                                     axis2_qname_t *qname)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     axis2_char_t *name = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -220,10 +220,10 @@
 }
 
 axis2_array_list_t *AXIS2_CALL
-axis2_xml_schema_obj_table_get_names(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_names(xml_schema_obj_table_t *obj_table,
                             const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     axis2_hash_index_t *hi = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
@@ -254,10 +254,10 @@
 }
 
 axis2_array_list_t *AXIS2_CALL
-axis2_xml_schema_obj_table_get_values(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_values(xml_schema_obj_table_t *obj_table,
                             const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     axis2_hash_index_t *hi = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     obj_table_impl = AXIS2_INTF_TO_IMPL(obj_table);
@@ -287,11 +287,11 @@
 }
 
 axis2_bool_t AXIS2_CALL
-axis2_xml_schema_obj_table_contains(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_contains(xml_schema_obj_table_t *obj_table,
                                             const axis2_env_t *env,
                                             axis2_qname_t *qname)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     void *value = NULL;
     axis2_char_t *name = NULL;
     
@@ -311,12 +311,12 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_obj_table_add(axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_add(xml_schema_obj_table_t *obj_table,
                                 const axis2_env_t *env,
                                 axis2_qname_t *qname,
                                 void *value)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     axis2_char_t *name = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -334,13 +334,13 @@
 }
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_obj_table_put(
-        axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_put(
+        xml_schema_obj_table_t *obj_table,
         const axis2_env_t *env,
         axis2_char_t *key,
         void *value)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
@@ -352,12 +352,12 @@
 }        
         
 void* AXIS2_CALL 
-axis2_xml_schema_obj_table_get(
-        axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get(
+        xml_schema_obj_table_t *obj_table,
         const axis2_env_t *env,
         axis2_char_t *key)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, key, NULL);
     obj_table_impl = AXIS2_INTF_TO_IMPL(obj_table);
@@ -365,11 +365,11 @@
 }        
 
 axis2_hash_t* AXIS2_CALL 
-axis2_xml_schema_obj_table_get_hash_table(
-        axis2_xml_schema_obj_table_t *obj_table,
+xml_schema_obj_table_get_hash_table(
+        xml_schema_obj_table_t *obj_table,
         const axis2_env_t *env)
 {
-    axis2_xml_schema_obj_table_impl_t *obj_table_impl = NULL;
+    xml_schema_obj_table_impl_t *obj_table_impl = NULL;
     obj_table_impl = AXIS2_INTF_TO_IMPL(obj_table);
     return obj_table_impl->collection;
 }        

Modified: webservices/axis2/trunk/c/xml_schema/src/xml_schema_particle.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xml_schema/src/xml_schema_particle.c?rev=413626&r1=413625&r2=413626&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xml_schema/src/xml_schema_particle.c (original)
+++ webservices/axis2/trunk/c/xml_schema/src/xml_schema_particle.c Mon Jun 12 03:29:40 2006
@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-#include <axis2_xml_schema_particle.h>
+#include <xml_schema_particle.h>
 #include <axis2_utils.h>
 
-typedef struct axis2_xml_schema_particle_impl 
-                    axis2_xml_schema_particle_impl_t;
+typedef struct xml_schema_particle_impl 
+                    xml_schema_particle_impl_t;
 
 /** 
  * @brief Other Extension Struct Impl
  *   Axis2 Other Extension  
  */ 
-struct axis2_xml_schema_particle_impl
+struct xml_schema_particle_impl
 {
-    axis2_xml_schema_particle_t particle;
+    xml_schema_particle_t particle;
     
-    axis2_xml_schema_annotated_t *annotated;
+    xml_schema_annotated_t *annotated;
     
-    axis2_xml_schema_types_t obj_type;
+    xml_schema_types_t obj_type;
     
     axis2_hash_t *ht_super;
     
@@ -47,57 +47,57 @@
 };
 
 #define AXIS2_INTF_TO_IMPL(particle) \
-        ((axis2_xml_schema_particle_impl_t *) particle)
+        ((xml_schema_particle_impl_t *) particle)
         
 /*************** function prototypes *****************************************/
 
 axis2_status_t AXIS2_CALL 
-axis2_xml_schema_particle_free(
+xml_schema_particle_free(
         void *particle,
         const axis2_env_t *env);
 
 axis2_hash_t *AXIS2_CALL 
-axis2_xml_schema_particle_super_objs(
+xml_schema_particle_super_objs(
         void *particle,
         const axis2_env_t *env);
 
-axis2_xml_schema_types_t AXIS2_CALL 
-axis2_xml_schema_particle_get_type(
+xml_schema_types_t AXIS2_CALL 
+xml_schema_particle_get_type(
         void *particle,
         const axis2_env_t *env);
 
-axis2_xml_schema_annotated_t *AXIS2_CALL
-axis2_xml_schema_particle_get_base_impl(void *particle,
+xml_schema_annotated_t *AXIS2_CALL
+xml_schema_particle_get_base_impl(void *particle,
                                         const axis2_env_t *env);
 
 long AXIS2_CALL
-axis2_xml_schema_particle_get_max_occurs(void *particle,
+xml_schema_particle_get_max_occurs(void *particle,
                                             const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_particle_set_max_occurs(void *particle,
+xml_schema_particle_set_max_occurs(void *particle,
                                             const axis2_env_t *env,
                                             long max_occurs);
 
 long AXIS2_CALL
-axis2_xml_schema_particle_get_min_occurs(void *particle,
+xml_schema_particle_get_min_occurs(void *particle,
                                             const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_particle_set_min_occurs(void *particle,
+xml_schema_particle_set_min_occurs(void *particle,
                                             const axis2_env_t *env,
                                             long min_occurs);
 
 /*************** function prototypes *****************************************/
 
-AXIS2_EXTERN axis2_xml_schema_particle_t * AXIS2_CALL
-axis2_xml_schema_particle_create(const axis2_env_t *env)
+AXIS2_EXTERN xml_schema_particle_t * AXIS2_CALL
+xml_schema_particle_create(const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
 
     particle_impl = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_particle_impl_t));
+                    sizeof(xml_schema_particle_impl_t));
     
     if(!particle_impl)
     {
@@ -106,7 +106,7 @@
         return NULL;
     }
     particle_impl->annotated = NULL;
-    particle_impl->obj_type = AXIS2_XML_SCHEMA_PARTICLE;
+    particle_impl->obj_type = XML_SCHEMA_PARTICLE;
     particle_impl->ht_super = NULL;
     particle_impl->particle.ops = NULL;
     particle_impl->particle.base.ops = NULL;
@@ -116,84 +116,84 @@
     
     
     particle_impl->particle.ops = AXIS2_MALLOC(env->allocator, 
-                    sizeof(axis2_xml_schema_particle_ops_t));
+                    sizeof(xml_schema_particle_ops_t));
 
     if(!particle_impl->particle.ops)
     {
-        axis2_xml_schema_particle_free(&(particle_impl->particle), env);
+        xml_schema_particle_free(&(particle_impl->particle), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     
     particle_impl->particle.ops->free = 
-            axis2_xml_schema_particle_free;
+            xml_schema_particle_free;
     
     particle_impl->particle.ops->super_objs = 
-            axis2_xml_schema_particle_super_objs;
+            xml_schema_particle_super_objs;
     
     particle_impl->particle.ops->get_type = 
-            axis2_xml_schema_particle_get_type;
+            xml_schema_particle_get_type;
     
     particle_impl->particle.ops->get_base_impl = 
-            axis2_xml_schema_particle_get_base_impl;
+            xml_schema_particle_get_base_impl;
     
     particle_impl->particle.ops->get_max_occurs = 
-            axis2_xml_schema_particle_get_max_occurs;
+            xml_schema_particle_get_max_occurs;
     
     particle_impl->particle.ops->set_max_occurs = 
-            axis2_xml_schema_particle_set_max_occurs;
+            xml_schema_particle_set_max_occurs;
     
     particle_impl->particle.ops->get_min_occurs = 
-            axis2_xml_schema_particle_get_min_occurs;
+            xml_schema_particle_get_min_occurs;
     
     particle_impl->particle.ops->set_min_occurs = 
-            axis2_xml_schema_particle_set_min_occurs;
+            xml_schema_particle_set_min_occurs;
    
     particle_impl->methods = axis2_hash_make(env);
     if(!particle_impl->methods)
     {
-        axis2_xml_schema_particle_free(&(particle_impl->particle), env);
+        xml_schema_particle_free(&(particle_impl->particle), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     axis2_hash_set(particle_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
-            axis2_xml_schema_particle_free);
+            xml_schema_particle_free);
     axis2_hash_set(particle_impl->methods, "super_objs", AXIS2_HASH_KEY_STRING, 
-            axis2_xml_schema_particle_super_objs);
+            xml_schema_particle_super_objs);
     axis2_hash_set(particle_impl->methods, "get_type", AXIS2_HASH_KEY_STRING, 
-            axis2_xml_schema_particle_get_type);
+            xml_schema_particle_get_type);
     axis2_hash_set(particle_impl->methods, "get_max_occurs", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_particle_get_max_occurs);
+            AXIS2_HASH_KEY_STRING, xml_schema_particle_get_max_occurs);
     axis2_hash_set(particle_impl->methods, "set_max_occurs", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_particle_set_max_occurs);
+            AXIS2_HASH_KEY_STRING, xml_schema_particle_set_max_occurs);
     axis2_hash_set(particle_impl->methods, "get_min_occurs", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_particle_get_min_occurs);
+            AXIS2_HASH_KEY_STRING, xml_schema_particle_get_min_occurs);
     axis2_hash_set(particle_impl->methods, "set_min_occurs", 
-            AXIS2_HASH_KEY_STRING, axis2_xml_schema_particle_set_min_occurs);
+            AXIS2_HASH_KEY_STRING, xml_schema_particle_set_min_occurs);
     
-    particle_impl->annotated = axis2_xml_schema_annotated_create(env);
+    particle_impl->annotated = xml_schema_annotated_create(env);
     if(!particle_impl->annotated)
     {
-        axis2_xml_schema_particle_free(&(particle_impl->particle), env);
+        xml_schema_particle_free(&(particle_impl->particle), env);
         return NULL;        
     }
 
     particle_impl->ht_super = axis2_hash_make(env);
     if(!particle_impl->ht_super)
     {
-        axis2_xml_schema_particle_free(&(particle_impl->particle), env);
+        xml_schema_particle_free(&(particle_impl->particle), env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    axis2_hash_set(particle_impl->ht_super, "AXIS2_XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING, 
+    axis2_hash_set(particle_impl->ht_super, "XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING, 
             &(particle_impl->particle));
-    axis2_hash_set(particle_impl->ht_super, "AXIS2_XML_SCHEMA_ANNOTATED", AXIS2_HASH_KEY_STRING, 
+    axis2_hash_set(particle_impl->ht_super, "XML_SCHEMA_ANNOTATED", AXIS2_HASH_KEY_STRING, 
             particle_impl->annotated);
             
-    axis2_hash_set(particle_impl->ht_super, "AXIS2_XML_SCHEMA_OBJ", AXIS2_HASH_KEY_STRING,
-            AXIS2_XML_SCHEMA_ANNOTATED_GET_BASE_IMPL(particle_impl->annotated, env));           
+    axis2_hash_set(particle_impl->ht_super, "XML_SCHEMA_OBJ", AXIS2_HASH_KEY_STRING,
+            XML_SCHEMA_ANNOTATED_GET_BASE_IMPL(particle_impl->annotated, env));           
             
-    status = axis2_xml_schema_annotated_resolve_methods(
+    status = xml_schema_annotated_resolve_methods(
             &(particle_impl->particle.base), env, particle_impl->annotated, 
             particle_impl->methods);
     
@@ -201,10 +201,10 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_particle_free(void *particle,
+xml_schema_particle_free(void *particle,
                                     const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     particle_impl = AXIS2_INTF_TO_IMPL(particle);
@@ -223,7 +223,7 @@
 
     if(NULL != particle_impl->annotated)
     {
-        AXIS2_XML_SCHEMA_ANNOTATED_FREE(particle_impl->annotated, env);
+        XML_SCHEMA_ANNOTATED_FREE(particle_impl->annotated, env);
         particle_impl->annotated = NULL;
     }
     
@@ -247,52 +247,52 @@
 }
 
 axis2_hash_t *AXIS2_CALL
-axis2_xml_schema_particle_super_objs(void *particle,
+xml_schema_particle_super_objs(void *particle,
                                 const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     particle_impl = AXIS2_INTF_TO_IMPL(particle);
     return particle_impl->ht_super;
 }
 
-axis2_xml_schema_types_t AXIS2_CALL
-axis2_xml_schema_particle_get_type(void *particle,
+xml_schema_types_t AXIS2_CALL
+xml_schema_particle_get_type(void *particle,
                                 const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     particle_impl = AXIS2_INTF_TO_IMPL(particle);
     return particle_impl->obj_type;
 }
 
-axis2_xml_schema_annotated_t *AXIS2_CALL
-axis2_xml_schema_particle_get_base_impl(void *particle,
+xml_schema_annotated_t *AXIS2_CALL
+xml_schema_particle_get_base_impl(void *particle,
                                 const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     particle_impl = AXIS2_INTF_TO_IMPL(particle);
     return particle_impl->annotated;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_xml_schema_particle_resolve_methods(
-                                axis2_xml_schema_particle_t *particle,
+xml_schema_particle_resolve_methods(
+                                xml_schema_particle_t *particle,
                                 const axis2_env_t *env,
-                                axis2_xml_schema_particle_t *particle_impl,
+                                xml_schema_particle_t *particle_impl,
                                 axis2_hash_t *methods)
 {
-    axis2_xml_schema_particle_impl_t *sch_particle_impl = NULL;
+    xml_schema_particle_impl_t *sch_particle_impl = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, particle_impl, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, methods, AXIS2_FAILURE);
     
-    sch_particle_impl = (axis2_xml_schema_particle_impl_t *) particle_impl;
+    sch_particle_impl = (xml_schema_particle_impl_t *) particle_impl;
     
     particle->ops = AXIS2_MALLOC(env->allocator, 
-            sizeof(axis2_xml_schema_particle_ops_t));
+            sizeof(xml_schema_particle_ops_t));
     if(!particle->ops)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -330,23 +330,23 @@
             particle->ops->set_min_occurs = 
             sch_particle_impl->particle.ops->set_min_occurs;
     
-    return axis2_xml_schema_annotated_resolve_methods(&(particle->base), 
+    return xml_schema_annotated_resolve_methods(&(particle->base), 
             env, sch_particle_impl->annotated, methods);
 }
 
 long AXIS2_CALL
-axis2_xml_schema_particle_get_max_occurs(void *particle,
+xml_schema_particle_get_max_occurs(void *particle,
                                             const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     axis2_hash_t *ht_super = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    ht_super = AXIS2_XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
+    ht_super = XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
     if(NULL != ht_super)
     {
         particle_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(ht_super, 
-                "AXIS2_XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
+                "XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
         if(!particle_impl)
             return AXIS2_FAILURE;                
     }
@@ -354,19 +354,19 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_particle_set_max_occurs(void *particle,
+xml_schema_particle_set_max_occurs(void *particle,
                                             const axis2_env_t *env,
                                             long max_occurs)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     axis2_hash_t *ht_super = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    ht_super = AXIS2_XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
+    ht_super = XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
     if(NULL != ht_super)
     {
         particle_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(ht_super, 
-                "AXIS2_XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
+                "XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
         if(!particle_impl)
             return AXIS2_FAILURE;                
     }
@@ -376,18 +376,18 @@
 }
 
 long AXIS2_CALL
-axis2_xml_schema_particle_get_min_occurs(void *particle,
+xml_schema_particle_get_min_occurs(void *particle,
                                             const axis2_env_t *env)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     axis2_hash_t *ht_super = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    ht_super = AXIS2_XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
+    ht_super = XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
     if(NULL != ht_super)
     {
         particle_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(ht_super, 
-                "AXIS2_XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
+                "XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
         if(!particle_impl)
             return AXIS2_FAILURE;                
     }
@@ -396,19 +396,19 @@
 }
 
 axis2_status_t AXIS2_CALL
-axis2_xml_schema_particle_set_min_occurs(void *particle,
+xml_schema_particle_set_min_occurs(void *particle,
                                             const axis2_env_t *env,
                                             long min_occurs)
 {
-    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+    xml_schema_particle_impl_t *particle_impl = NULL;
     axis2_hash_t *ht_super = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    ht_super = AXIS2_XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
+    ht_super = XML_SCHEMA_PARTICLE_SUPER_OBJS(particle, env);
     if(NULL != ht_super)
     {
         particle_impl = AXIS2_INTF_TO_IMPL(axis2_hash_get(ht_super, 
-                "AXIS2_XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
+                "XML_SCHEMA_PARTICLE", AXIS2_HASH_KEY_STRING));
         if(!particle_impl)
             return 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