axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r394660 [6/6] - in /webservices/axis2/trunk/c/modules/xml/xml_schema: ./ constants/ utils/
Date Mon, 17 Apr 2006 12:15:52 GMT
Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_particle.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_particle.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_particle.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_particle.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_xml_schema_particle.h>
+
+typedef struct axis2_xml_schema_particle_impl axis2_xml_schema_particle_impl_t;
+
+/** 
+ * @brief Other Extension Struct Impl
+ *	Axis2 Other Extension  
+ */ 
+struct axis2_xml_schema_particle_impl
+{
+    axis2_xml_schema_particle_t particle;
+    axis2_xml_schema_annotated_t *annotated;
+    long max_occurs;
+    axis2_char_t *max_occurs_string;
+    long min_occurs;
+    axis2_char_t *min_occurs_string;
+    axis2_hash_t *methods;
+    void *inherited;
+};
+
+#define INTF_TO_IMPL(particle) ((axis2_xml_schema_particle_impl_t *) particle)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_schema_particle_free(void *particle,
+                        axis2_env_t **env);
+
+axis2_xml_schema_annotated_t *AXIS2_CALL
+axis2_xml_schema_particle_get_base_impl(void *particle,
+                                        axis2_env_t **env);
+
+long AXIS2_CALL
+axis2_xml_schema_particle_get_max_occurs(void *particle,
+                                            axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_particle_set_max_occurs(void *particle,
+                                            axis2_env_t **env,
+                                            long max_occurs);
+
+long AXIS2_CALL
+axis2_xml_schema_particle_get_min_occurs(void *particle,
+                                            axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_particle_set_min_occurs(void *particle,
+                                            axis2_env_t **env,
+                                            long min_occurs);
+
+AXIS2_DECLARE(axis2_xml_schema_particle_t *)
+axis2_xml_schema_particle_create(axis2_env_t **env)
+{
+    axis2_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));
+
+    particle_impl->annotated = NULL;
+    particle_impl->methods = NULL;
+    particle_impl->particle.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_particle_ops_t));
+
+    particle_impl->particle.ops->free = axis2_xml_schema_particle_free;
+    particle_impl->particle.ops->get_base_impl = 
+            axis2_xml_schema_particle_get_base_impl;
+    particle_impl->particle.ops->get_max_occurs = 
+            axis2_xml_schema_particle_get_max_occurs;
+    particle_impl->particle.ops->set_max_occurs = 
+            axis2_xml_schema_particle_set_max_occurs;
+    particle_impl->particle.ops->get_min_occurs = 
+            axis2_xml_schema_particle_get_min_occurs;
+    particle_impl->particle.ops->set_min_occurs = 
+            axis2_xml_schema_particle_set_min_occurs;
+   
+    particle_impl->methods = axis2_hash_make(env);
+    if(!particle_impl->methods)
+    {
+        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);
+    axis2_hash_set(particle_impl->methods, "get_max_occurs", 
+            AXIS2_HASH_KEY_STRING, axis2_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_set(particle_impl->methods, "get_min_occurs", 
+            AXIS2_HASH_KEY_STRING, axis2_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);
+    
+    particle_impl->annotated = axis2_xml_schema_annotated_create(env);
+    status = axis2_xml_schema_annotated_resolve_methods(
+            &(particle_impl->particle.base), env, particle_impl->annotated, 
+            particle_impl->methods);
+    
+    return &(particle_impl->particle);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_particle_free(void *particle,
+                                    axis2_env_t **env)
+{
+    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    particle_impl = INTF_TO_IMPL(particle);
+
+    if(particle_impl->methods)
+    {
+        axis2_hash_free(particle_impl->methods, env);
+        particle_impl->methods = NULL;
+    }
+
+    if(particle_impl->annotated)
+    {
+        AXIS2_XML_SCHEMA_OBJ_FREE(particle_impl->annotated, env);
+        particle_impl->annotated = NULL;
+    }
+    
+    if((&(particle_impl->particle))->ops)
+    {
+        AXIS2_FREE((*env)->allocator, (&(particle_impl->particle))->ops);
+        (&(particle_impl->particle))->ops = NULL;
+    }
+
+    if(particle_impl)
+    {
+        AXIS2_FREE((*env)->allocator, particle_impl);
+        particle_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_annotated_t *AXIS2_CALL
+axis2_xml_schema_particle_get_base_impl(void *particle,
+                                axis2_env_t **env)
+{
+    axis2_xml_schema_particle_impl_t *particle_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    particle_impl = INTF_TO_IMPL(particle);
+
+    return particle_impl->annotated;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_particle_resolve_methods(
+                                axis2_xml_schema_particle_t *particle,
+                                axis2_env_t **env,
+                                axis2_xml_schema_particle_t *particle_impl,
+                                axis2_hash_t *methods)
+{
+    axis2_xml_schema_particle_impl_t *particle_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, particle_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    particle_impl_l = (axis2_xml_schema_particle_impl_t *) particle_impl;
+    
+    particle->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_schema_particle_ops_t));
+    particle->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    particle->ops->get_base_impl = 
+            particle_impl_l->particle.ops->get_base_impl;
+    particle->ops->get_max_occurs = 
+            particle_impl_l->particle.ops->get_max_occurs;
+    particle->ops->set_max_occurs = 
+            particle_impl_l->particle.ops->set_max_occurs;
+    particle->ops->get_min_occurs = 
+            particle_impl_l->particle.ops->get_min_occurs;
+    particle->ops->set_min_occurs = 
+            particle_impl_l->particle.ops->set_min_occurs;
+    
+    return axis2_xml_schema_annotated_resolve_methods(&(particle->base), 
+            env, particle_impl_l->annotated, methods);
+}
+
+long AXIS2_CALL
+axis2_xml_schema_particle_get_max_occurs(void *particle,
+                                            axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return INTF_TO_IMPL(particle)->max_occurs;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_particle_set_max_occurs(void *particle,
+                                            axis2_env_t **env,
+                                            long max_occurs)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    INTF_TO_IMPL(particle)->max_occurs = max_occurs;
+    return AXIS2_SUCCESS;
+}
+
+long AXIS2_CALL
+axis2_xml_schema_particle_get_min_occurs(void *particle,
+                                            axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return INTF_TO_IMPL(particle)->min_occurs;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_particle_set_min_occurs(void *particle,
+                                            axis2_env_t **env,
+                                            long min_occurs)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    INTF_TO_IMPL(particle)->min_occurs = min_occurs;
+    return AXIS2_SUCCESS;
+}
+

Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_sequence.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_sequence.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_sequence.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_sequence.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_xml_schema_sequence.h>
+#include <axis2_xml_schema_group_base.h>
+
+typedef struct axis2_xml_schema_sequence_impl axis2_xml_schema_sequence_impl_t;
+
+/** 
+ * @brief Other Extension Struct Impl
+ *	Axis2 Other Extension  
+ */ 
+struct axis2_xml_schema_sequence_impl
+{
+    axis2_xml_schema_sequence_t sequence;
+    axis2_xml_schema_group_base_t *base;
+    axis2_hash_t *methods;
+    axis2_xml_schema_obj_collection_t *items;
+};
+
+#define INTF_TO_IMPL(sequence) ((axis2_xml_schema_sequence_impl_t *) sequence)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_schema_sequence_free(void *sequence,
+                        axis2_env_t **env);
+
+axis2_xml_schema_group_base_t *AXIS2_CALL
+axis2_xml_schema_sequence_get_base_impl(void *sequence,
+                                        axis2_env_t **env);
+
+axis2_xml_schema_obj_collection_t *AXIS2_CALL
+axis2_xml_schema_sequence_get_items(void *sequence,
+                                axis2_env_t **env);
+
+
+AXIS2_DECLARE(axis2_xml_schema_sequence_t *)
+axis2_xml_schema_sequence_create(axis2_env_t **env)
+{
+    axis2_xml_schema_sequence_impl_t *sequence_impl = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    sequence_impl = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_sequence_impl_t));
+
+    sequence_impl->base = NULL;
+    sequence_impl->methods = NULL;
+    sequence_impl->items = NULL;
+    sequence_impl->sequence.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_sequence_ops_t));
+
+    sequence_impl->sequence.ops->free = axis2_xml_schema_sequence_free;
+    sequence_impl->sequence.ops->get_base_impl = 
+            axis2_xml_schema_sequence_get_base_impl;
+    sequence_impl->sequence.ops->get_items = 
+            axis2_xml_schema_sequence_get_items;
+   
+    sequence_impl->methods = axis2_hash_make(env);
+    if(!sequence_impl->methods)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    axis2_hash_set(sequence_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_schema_sequence_free);
+    axis2_hash_set(sequence_impl->methods, "get_items", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_sequence_get_items);
+    
+    sequence_impl->base = axis2_xml_schema_group_base_create(env);
+    status = axis2_xml_schema_group_base_resolve_methods(
+            &(sequence_impl->sequence.base), env, sequence_impl->base, 
+            sequence_impl->methods);
+    
+    return &(sequence_impl->sequence);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_sequence_free(void *sequence,
+                                    axis2_env_t **env)
+{
+    axis2_xml_schema_sequence_impl_t *sequence_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    sequence_impl = INTF_TO_IMPL(sequence);
+
+    if(sequence_impl->items)
+    {
+        AXIS2_XML_SCHEMA_OBJ_COLLECTION_FREE(sequence_impl->items, env);
+        sequence_impl->items = NULL;
+    }
+    
+    if(sequence_impl->methods)
+    {
+        axis2_hash_free(sequence_impl->methods, env);
+        sequence_impl->methods = NULL;
+    }
+
+    if(sequence_impl->base)
+    {
+        AXIS2_XML_SCHEMA_GROUP_BASE_FREE(sequence_impl->base, env);
+        sequence_impl->base = NULL;
+    }
+    
+    if((&(sequence_impl->sequence))->ops)
+    {
+        AXIS2_FREE((*env)->allocator, (&(sequence_impl->sequence))->ops);
+        (&(sequence_impl->sequence))->ops = NULL;
+    }
+
+    if(sequence_impl)
+    {
+        AXIS2_FREE((*env)->allocator, sequence_impl);
+        sequence_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_group_base_t *AXIS2_CALL
+axis2_xml_schema_sequence_get_base_impl(void *sequence,
+                                axis2_env_t **env)
+{
+    axis2_xml_schema_sequence_impl_t *sequence_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    sequence_impl = INTF_TO_IMPL(sequence);
+
+    return sequence_impl->base;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_sequence_resolve_methods(
+                                axis2_xml_schema_sequence_t *sequence,
+                                axis2_env_t **env,
+                                axis2_xml_schema_sequence_t *sequence_impl,
+                                axis2_hash_t *methods)
+{
+    axis2_xml_schema_sequence_impl_t *sequence_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, sequence_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    sequence_impl_l = (axis2_xml_schema_sequence_impl_t *) sequence_impl;
+    
+    sequence->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_schema_sequence_ops_t));
+    sequence->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    sequence->ops->get_base_impl = 
+            sequence_impl_l->sequence.ops->get_base_impl;
+    sequence->ops->get_items = 
+            sequence_impl_l->sequence.ops->get_items;
+    
+    return axis2_xml_schema_group_base_resolve_methods(&(sequence->base), 
+            env, sequence_impl_l->base, methods);
+}
+
+axis2_xml_schema_obj_collection_t *AXIS2_CALL
+axis2_xml_schema_sequence_get_items(void *sequence,
+                                    axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return INTF_TO_IMPL(sequence)->items;
+}
+

Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,364 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_xml_schema_type.h>
+#include <axis2_xml_schema_data_type.h>
+#include <axis2_xml_schema_derivation_method.h>
+#include <axis2_xml_schema.h>
+
+typedef struct axis2_xml_schema_type_impl axis2_xml_schema_type_impl_t;
+
+/** 
+ * @brief Other Extension Struct Impl
+ *	Axis2 Other Extension  
+ */ 
+struct axis2_xml_schema_type_impl
+{
+    axis2_xml_schema_type_t type;
+    axis2_xml_schema_annotated_t *annotated;
+    axis2_hash_t *methods;
+    axis2_xml_schema_data_type_t *data_type;
+    axis2_xml_schema_derivation_method_t *derive_by;
+    axis2_xml_schema_derivation_method_t *final_derivation;
+    axis2_xml_schema_derivation_method_t *final_resolved;
+    axis2_bool_t is_mixed;
+    /* Name of the type */
+    axis2_char_t *name;
+    axis2_xml_schema_t *schema;
+};
+
+#define INTF_TO_IMPL(type) ((axis2_xml_schema_type_impl_t *) type)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_schema_type_free(void *type,
+                        axis2_env_t **env);
+
+axis2_xml_schema_annotated_t *AXIS2_CALL
+axis2_xml_schema_type_get_base_impl(void *type,
+                                        axis2_env_t **env);
+
+void *AXIS2_CALL
+axis2_xml_schema_type_get_base_schema_type(void *type,
+                                            axis2_env_t **env);
+
+axis2_xml_schema_data_type_t *AXIS2_CALL
+axis2_xml_schema_type_get_data_type(void *type,
+                                        axis2_env_t **env);
+
+axis2_xml_schema_derivation_method_t *AXIS2_CALL
+axis2_xml_schema_type_get_derive_by(void *type,
+                                    axis2_env_t **env);
+
+axis2_xml_schema_derivation_method_t *AXIS2_CALL
+axis2_xml_schema_type_get_final(void *type,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_set_final(void *type,
+                        axis2_env_t **env,
+                        axis2_xml_schema_derivation_method_t *final_derivation);
+
+axis2_xml_schema_derivation_method_t *AXIS2_CALL
+axis2_xml_schema_type_get_final_resolved(void *type,
+                                            axis2_env_t **env);
+
+axis2_bool_t AXIS2_CALL
+axis2_xml_schema_type_is_mixed(void *type,
+                                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_set_mixed(void *type,
+                                axis2_env_t **env,
+                                axis2_bool_t is_mixed); 
+
+axis2_char_t *AXIS2_CALL
+axis2_xml_schema_type_get_name(void *type,
+                                axis2_env_t **env); 
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_set_name(void *type,
+                                axis2_env_t **env,
+                                axis2_char_t *name); 
+
+axis2_qname_t *AXIS2_CALL
+axis2_xml_schema_type_get_qname(void *type,
+                                axis2_env_t **env);
+
+AXIS2_DECLARE(axis2_xml_schema_type_t *)
+axis2_xml_schema_type_create(axis2_env_t **env,
+                                axis2_xml_schema_t *schema)
+{
+    axis2_xml_schema_type_impl_t *type_impl = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    type_impl = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_type_impl_t));
+
+    type_impl->annotated = NULL;
+    type_impl->methods = NULL;
+    type_impl->schema = schema;
+    type_impl->type.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_type_ops_t));
+
+    type_impl->type.ops->free = axis2_xml_schema_type_free;
+    type_impl->type.ops->get_base_impl = 
+            axis2_xml_schema_type_get_base_impl;
+    type_impl->type.ops->get_base_schema_type = 
+            axis2_xml_schema_type_get_base_schema_type;
+    type_impl->type.ops->get_data_type = 
+            axis2_xml_schema_type_get_data_type;
+    type_impl->type.ops->get_derive_by = 
+            axis2_xml_schema_type_get_derive_by;
+    type_impl->type.ops->get_final = 
+            axis2_xml_schema_type_get_final;
+    type_impl->type.ops->set_final = 
+            axis2_xml_schema_type_set_final;
+    type_impl->type.ops->get_final_resolved = 
+            axis2_xml_schema_type_get_final_resolved;
+    type_impl->type.ops->is_mixed = 
+            axis2_xml_schema_type_is_mixed;
+    type_impl->type.ops->set_mixed = 
+            axis2_xml_schema_type_set_mixed;
+    type_impl->type.ops->get_name = 
+            axis2_xml_schema_type_get_name;
+    type_impl->type.ops->set_name = 
+            axis2_xml_schema_type_set_name;
+    type_impl->type.ops->get_qname = 
+            axis2_xml_schema_type_get_qname;
+   
+    type_impl->methods = axis2_hash_make(env);
+    if(!type_impl->methods)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    type_impl->final_derivation = axis2_xml_schema_derivation_method_create(env, 
+            "None");
+    
+    axis2_hash_set(type_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_schema_type_free);
+    axis2_hash_set(type_impl->methods, "get_base_schema_type", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_base_schema_type);
+    axis2_hash_set(type_impl->methods, "get_data_type", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_data_type);
+    axis2_hash_set(type_impl->methods, "get_derive_by", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_derive_by);
+    axis2_hash_set(type_impl->methods, "get_final", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_final);
+    axis2_hash_set(type_impl->methods, "set_final", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_set_final);
+    axis2_hash_set(type_impl->methods, "get_final_resolved", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_final_resolved);
+    axis2_hash_set(type_impl->methods, "is_mixed", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_is_mixed);
+    axis2_hash_set(type_impl->methods, "set_mixed", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_set_mixed);
+    axis2_hash_set(type_impl->methods, "get_name", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_name);
+    axis2_hash_set(type_impl->methods, "set_name", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_set_name);
+    axis2_hash_set(type_impl->methods, "get_qname", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_type_get_qname);
+    
+    type_impl->annotated = axis2_xml_schema_annotated_create(env);
+    status = axis2_xml_schema_annotated_resolve_methods(
+            &(type_impl->type.base), env, type_impl->annotated, 
+            type_impl->methods);
+    
+    return &(type_impl->type);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_free(void *type,
+                                    axis2_env_t **env)
+{
+    axis2_xml_schema_type_impl_t *type_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    type_impl = INTF_TO_IMPL(type);
+
+    if(type_impl->methods)
+    {
+        axis2_hash_free(type_impl->methods, env);
+        type_impl->methods = NULL;
+    }
+
+    if(type_impl->annotated)
+    {
+        AXIS2_XML_SCHEMA_OBJ_FREE(type_impl->annotated, env);
+        type_impl->annotated = NULL;
+    }
+    
+    if((&(type_impl->type))->ops)
+    {
+        AXIS2_FREE((*env)->allocator, (&(type_impl->type))->ops);
+        (&(type_impl->type))->ops = NULL;
+    }
+
+    if(type_impl)
+    {
+        AXIS2_FREE((*env)->allocator, type_impl);
+        type_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_annotated_t *AXIS2_CALL
+axis2_xml_schema_type_get_base_impl(void *type,
+                                axis2_env_t **env)
+{
+    axis2_xml_schema_type_impl_t *type_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    type_impl = INTF_TO_IMPL(type);
+
+    return type_impl->annotated;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_type_resolve_methods(
+                                axis2_xml_schema_type_t *type,
+                                axis2_env_t **env,
+                                axis2_xml_schema_type_t *type_impl,
+                                axis2_hash_t *methods)
+{
+    axis2_xml_schema_type_impl_t *type_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, type_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    type_impl_l = (axis2_xml_schema_type_impl_t *) type_impl;
+    
+    type->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_schema_type_ops_t));
+    type->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    type->ops->get_base_impl = 
+            type_impl_l->type.ops->get_base_impl;
+    type->ops->get_base_schema_type = 
+            type_impl_l->type.ops->get_base_schema_type;
+    type->ops->get_data_type = 
+            type_impl_l->type.ops->get_data_type;
+    type->ops->get_derive_by = 
+            type_impl_l->type.ops->get_derive_by;
+    type->ops->get_final = 
+            type_impl_l->type.ops->get_final;
+    type->ops->set_final = 
+            type_impl_l->type.ops->set_final;
+    type->ops->get_final_resolved = 
+            type_impl_l->type.ops->get_final_resolved;
+    type->ops->is_mixed = 
+            type_impl_l->type.ops->is_mixed;
+    type->ops->set_mixed = 
+            type_impl_l->type.ops->set_mixed;
+    type->ops->get_name = 
+            type_impl_l->type.ops->get_name;
+    type->ops->set_name = 
+            type_impl_l->type.ops->set_name;
+    type->ops->get_qname = 
+            type_impl_l->type.ops->get_qname;
+    
+    return axis2_xml_schema_annotated_resolve_methods(&(type->base), 
+            env, type_impl_l->annotated, methods);
+}
+
+void *AXIS2_CALL
+axis2_xml_schema_type_get_base_schema_type(void *type,
+                                            axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return NULL;
+}
+
+axis2_xml_schema_data_type_t *AXIS2_CALL
+axis2_xml_schema_type_get_data_type(void *type,
+                                        axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return NULL;
+}
+
+axis2_xml_schema_derivation_method_t *AXIS2_CALL
+axis2_xml_schema_type_get_derive_by(void *type,
+                                    axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return NULL;
+}
+
+axis2_xml_schema_derivation_method_t *AXIS2_CALL
+axis2_xml_schema_type_get_final(void *type,
+                                axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_set_final(void *type,
+                            axis2_env_t **env,
+                            axis2_xml_schema_derivation_method_t *final_derivation)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_derivation_method_t *AXIS2_CALL
+axis2_xml_schema_type_get_final_resolved(void *type,
+                                            axis2_env_t **env) 
+{
+    return NULL;
+}
+
+axis2_bool_t AXIS2_CALL
+axis2_xml_schema_type_is_mixed(void *type,
+                                axis2_env_t **env) 
+{
+    return AXIS2_TRUE;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_set_mixed(void *type,
+                                axis2_env_t **env,
+                                axis2_bool_t is_mixed) 
+{
+    return AXIS2_SUCCESS;
+}
+
+axis2_char_t *AXIS2_CALL
+axis2_xml_schema_type_get_name(void *type,
+                                axis2_env_t **env) 
+{
+    return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_set_name(void *type,
+                                axis2_env_t **env,
+                                axis2_char_t *name) 
+{
+    return AXIS2_SUCCESS;
+}
+
+axis2_qname_t *AXIS2_CALL
+axis2_xml_schema_type_get_qname(void *type,
+                                axis2_env_t **env) 
+{
+    return NULL;
+}
+

Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type_receiver.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type_receiver.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type_receiver.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_type_receiver.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <axis2_xml_schema_type_receiver.h>
+#include <axis2_xml_schema_type.h>
+#include <axis2_hash.h>
+
+typedef struct axis2_xml_schema_type_receiver_impl axis2_xml_schema_type_receiver_impl_t;
+
+/** 
+ * @brief Xml Schema Type Receiver Struct Impl
+ *	Axis2 Xml Schema Type Receiver  
+ */ 
+struct axis2_xml_schema_type_receiver_impl
+{
+    axis2_xml_schema_type_receiver_t type_receiver;
+};
+
+#define INTF_TO_IMPL(type_receiver) ((axis2_xml_schema_type_receiver_impl_t *) type_receiver)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_schema_type_receiver_free(void *type_receiver,
+                axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_receiver_set_type(void *type_receiver,
+                        axis2_env_t **env,
+                        axis2_xml_schema_type_t *type);
+
+AXIS2_DECLARE(axis2_xml_schema_type_receiver_t *)
+axis2_xml_schema_type_receiver_create(axis2_env_t **env)
+{
+    axis2_xml_schema_type_receiver_impl_t *type_receiver_impl = NULL;
+    
+    type_receiver_impl = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_type_receiver_impl_t));
+
+    type_receiver_impl->type_receiver.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_type_receiver_ops_t)); 
+
+
+    type_receiver_impl->type_receiver.ops->free = axis2_xml_schema_type_receiver_free;
+    type_receiver_impl->type_receiver.ops->set_type = axis2_xml_schema_type_receiver_set_type;
+
+    return &(type_receiver_impl->type_receiver);
+}
+
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_receiver_free(void *type_receiver,
+                axis2_env_t **env)
+{
+    axis2_xml_schema_type_receiver_impl_t *type_receiver_impl = NULL;
+
+    type_receiver_impl = INTF_TO_IMPL(type_receiver);
+
+    if((&(type_receiver_impl->type_receiver))->ops)
+    {
+        free((&(type_receiver_impl->type_receiver))->ops);
+        (&(type_receiver_impl->type_receiver))->ops = NULL;
+    }
+
+    if(type_receiver_impl)
+    {
+        free(type_receiver_impl);
+        type_receiver_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_type_receiver_resolve_methods(axis2_xml_schema_type_receiver_t *type_receiver,
+                                        axis2_env_t **env,
+                                        axis2_xml_schema_type_receiver_t *type_receiver_impl,
+                                        axis2_hash_t *methods)
+{    
+    axis2_xml_schema_type_receiver_impl_t *type_receiver_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, type_receiver_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    type_receiver_impl_l = (axis2_xml_schema_type_receiver_impl_t *) type_receiver_impl;
+    
+    type_receiver->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_schema_type_receiver_ops_t));
+    type_receiver->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    type_receiver->ops->free = axis2_hash_get(methods, "set_type", 
+            AXIS2_HASH_KEY_STRING);
+    return AXIS2_SUCCESS;    
+
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_type_receiver_set_type(void *type_receiver,
+                        axis2_env_t **env,
+                        axis2_xml_schema_type_t *type)
+{
+    axis2_xml_schema_type_receiver_impl_t *type_receiver_impl = NULL;
+
+    type_receiver_impl = INTF_TO_IMPL(type_receiver);
+
+    type_receiver_impl->type = type;
+
+    return AXIS2_SUCCESS;
+}
+

Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_use.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_use.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_use.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_use.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_xml_schema_use.h>
+
+typedef struct axis2_xml_schema_use_impl axis2_xml_schema_use_impl_t;
+
+/** 
+ * @brief Other Extension Struct Impl
+ *	Axis2 Other Extension  
+ */ 
+struct axis2_xml_schema_use_impl
+{
+    axis2_xml_schema_use_t use;
+    axis2_xml_schema_enum_t *schema_enum;
+    axis2_hash_t *methods;
+    axis2_array_list_t *members;
+};
+
+#define INTF_TO_IMPL(use) ((axis2_xml_schema_use_impl_t *) use)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_schema_use_free(void *use,
+                        axis2_env_t **env);
+
+axis2_xml_schema_enum_t *AXIS2_CALL
+axis2_xml_schema_use_get_base_impl(void *use,
+                                axis2_env_t **env);
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_use_resolve_methods(
+                                axis2_xml_schema_use_t *use,
+                                axis2_env_t **env,
+                                axis2_xml_schema_use_t *use_impl,
+                                axis2_hash_t *methods);
+
+axis2_array_list_t *
+axis2_xml_schema_use_get_values(void *use,
+                        axis2_env_t **env);
+
+
+AXIS2_DECLARE(axis2_xml_schema_use_t *)
+axis2_xml_schema_use_create(axis2_env_t **env,
+                            axis2_char_t *value)
+{
+    axis2_xml_schema_use_impl_t *use_impl = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    
+    use_impl = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_use_impl_t));
+
+    use_impl->schema_enum = NULL;
+    use_impl->methods = NULL;
+    use_impl->members = NULL;
+    use_impl->use.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_use_ops_t));
+
+    use_impl->use.ops->free = axis2_xml_schema_use_free;
+    use_impl->use.ops->get_base_impl = axis2_xml_schema_use_get_base_impl;
+    use_impl->use.ops->get_values = 
+            axis2_xml_schema_use_get_values;
+   
+    if(!use_impl->members)
+    {
+        use_impl->members = axis2_array_list_create(env, 0);
+        if(!use_impl->members)
+            return NULL;
+        AXIS2_ARRAY_LIST_ADD(use_impl->members, env, "None");
+        AXIS2_ARRAY_LIST_ADD(use_impl->members, env, "Optional");
+        AXIS2_ARRAY_LIST_ADD(use_impl->members, env, "Prohibited");
+        AXIS2_ARRAY_LIST_ADD(use_impl->members, env, "Required");
+    }
+    use_impl->methods = axis2_hash_make(env);
+    if(!use_impl->methods)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    axis2_hash_set(use_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_schema_use_free);
+    axis2_hash_set(use_impl->methods, "get_values", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_schema_use_get_values);
+
+    use_impl->schema_enum = axis2_xml_schema_enum_create(env, value);
+    status = axis2_xml_schema_enum_resolve_methods(
+            &(use_impl->use.base), env, use_impl->schema_enum, 
+            use_impl->methods); 
+
+    return &(use_impl->use);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_use_free(void *use,
+                                    axis2_env_t **env)
+{
+    axis2_xml_schema_use_impl_t *use_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    use_impl = INTF_TO_IMPL(use);
+
+    if(use_impl->members)
+    {
+        AXIS2_ARRAY_LIST_FREE(use_impl->members, env);
+        use_impl->members = NULL;
+    }
+    
+    if(use_impl->schema_enum)
+    {
+        AXIS2_XML_SCHEMA_ENUM_FREE(use_impl->schema_enum, env);
+        use_impl->schema_enum = NULL;
+    }
+    
+    if((&(use_impl->use))->ops)
+    {
+        AXIS2_FREE((*env)->allocator, (&(use_impl->use))->ops);
+        (&(use_impl->use))->ops = NULL;
+    }
+
+    if(use_impl)
+    {
+        AXIS2_FREE((*env)->allocator, use_impl);
+        use_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_enum_t *AXIS2_CALL
+axis2_xml_schema_use_get_base_impl(void *use,
+                                axis2_env_t **env)
+{
+    axis2_xml_schema_use_impl_t *use_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    use_impl = INTF_TO_IMPL(use);
+
+    return use_impl->schema_enum;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_use_resolve_methods(
+                                axis2_xml_schema_use_t *use,
+                                axis2_env_t **env,
+                                axis2_xml_schema_use_t *use_impl,
+                                axis2_hash_t *methods)
+{
+    axis2_xml_schema_use_impl_t *use_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, use_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    use_impl_l = (axis2_xml_schema_use_impl_t *) use_impl;
+    
+    use->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_schema_use_ops_t));
+    use->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    use->ops->get_base_impl = 
+            use_impl_l->use.ops->get_base_impl;
+    use->ops->get_values = 
+            use_impl_l->use.ops->get_values;
+    
+    return axis2_xml_schema_enum_resolve_methods(&(use->base), 
+            env, use_impl_l->schema_enum, methods);
+}
+
+axis2_array_list_t *AXIS2_CALL
+axis2_xml_schema_use_get_values(void *use,
+                                        axis2_env_t **env)
+{
+    return INTF_TO_IMPL(use)->members;
+}
+

Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_xpath.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_xpath.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_xpath.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_schema_xpath.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_xml_schema_xpath.h>
+
+typedef struct axis2_xml_schema_xpath_impl axis2_xml_schema_xpath_impl_t;
+
+/** 
+ * @brief Other Extension Struct Impl
+ *	Axis2 Other Extension  
+ */ 
+struct axis2_xml_schema_xpath_impl
+{
+    axis2_xml_schema_xpath_t xpath;
+    axis2_xml_schema_annotated_t *annotated;
+    axis2_hash_t *methods;
+    axis2_char_t *x_path;
+};
+
+#define INTF_TO_IMPL(xpath) ((axis2_xml_schema_xpath_impl_t *) xpath)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_schema_xpath_free(void *xpath,
+                        axis2_env_t **env);
+
+axis2_xml_schema_annotated_t *AXIS2_CALL
+axis2_xml_schema_xpath_get_base_impl(void *xpath,
+                                        axis2_env_t **env);
+
+axis2_char_t *AXIS2_CALL
+axis2_xml_schema_xpath_get_xpath(void *xpath,
+                                 axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_xpath_set_xpath(void *xpath,
+                                 axis2_env_t **env,
+                                 axis2_char_t *x_path);
+
+AXIS2_DECLARE(axis2_xml_schema_xpath_t *)
+axis2_xml_schema_xpath_create(axis2_env_t **env,
+                                void *value,
+                                axis2_bool_t fixed)
+{
+    axis2_xml_schema_xpath_impl_t *xpath_impl = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    xpath_impl = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_xpath_impl_t));
+
+    xpath_impl->annotated = NULL;
+    xpath_impl->methods = NULL;
+    xpath_impl->x_path = NULL;
+    xpath_impl->xpath.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_schema_xpath_ops_t));
+
+    xpath_impl->xpath.ops->free = axis2_xml_schema_xpath_free;
+    xpath_impl->xpath.ops->get_base_impl = 
+            axis2_xml_schema_xpath_get_base_impl;
+    xpath_impl->xpath.ops->get_xpath = 
+            axis2_xml_schema_xpath_get_xpath;
+    xpath_impl->xpath.ops->set_xpath = 
+            axis2_xml_schema_xpath_set_xpath;
+   
+    xpath_impl->methods = axis2_hash_make(env);
+    if(!xpath_impl->methods)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    axis2_hash_set(xpath_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_schema_xpath_free);
+    axis2_hash_set(xpath_impl->methods, "get_xpath", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_xpath_get_xpath);
+    axis2_hash_set(xpath_impl->methods, "set_xpath", 
+            AXIS2_HASH_KEY_STRING, axis2_xml_schema_xpath_set_xpath);
+    
+    xpath_impl->annotated = axis2_xml_schema_annotated_create(env);
+    status = axis2_xml_schema_annotated_resolve_methods(
+            &(xpath_impl->xpath.base), env, xpath_impl->annotated, 
+            xpath_impl->methods);
+    
+    return &(xpath_impl->xpath);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_xpath_free(void *xpath,
+                                    axis2_env_t **env)
+{
+    axis2_xml_schema_xpath_impl_t *xpath_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    xpath_impl = INTF_TO_IMPL(xpath);
+
+    if(xpath_impl->x_path)
+    {
+        AXIS2_FREE((*env)->allocator, xpath_impl->x_path);
+        xpath_impl->x_path = NULL;
+    }
+
+    if(xpath_impl->methods)
+    {
+        axis2_hash_free(xpath_impl->methods, env);
+        xpath_impl->methods = NULL;
+    }
+
+    if(xpath_impl->annotated)
+    {
+        AXIS2_XML_SCHEMA_OBJ_FREE(xpath_impl->annotated, env);
+        xpath_impl->annotated = NULL;
+    }
+    
+    if((&(xpath_impl->xpath))->ops)
+    {
+        AXIS2_FREE((*env)->allocator, (&(xpath_impl->xpath))->ops);
+        (&(xpath_impl->xpath))->ops = NULL;
+    }
+
+    if(xpath_impl)
+    {
+        AXIS2_FREE((*env)->allocator, xpath_impl);
+        xpath_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_annotated_t *AXIS2_CALL
+axis2_xml_schema_xpath_get_base_impl(void *xpath,
+                                axis2_env_t **env)
+{
+    axis2_xml_schema_xpath_impl_t *xpath_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    xpath_impl = INTF_TO_IMPL(xpath);
+
+    return xpath_impl->annotated;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_schema_xpath_resolve_methods(
+                                axis2_xml_schema_xpath_t *xpath,
+                                axis2_env_t **env,
+                                axis2_xml_schema_xpath_t *xpath_impl,
+                                axis2_hash_t *methods)
+{
+    axis2_xml_schema_xpath_impl_t *xpath_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, xpath_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    xpath_impl_l = (axis2_xml_schema_xpath_impl_t *) xpath_impl;
+    
+    xpath->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_schema_xpath_ops_t));
+    xpath->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    xpath->ops->get_base_impl = 
+            xpath_impl_l->xpath.ops->get_base_impl;
+    xpath->ops->get_xpath = 
+            xpath_impl_l->xpath.ops->get_xpath;
+    xpath->ops->set_xpath = 
+            xpath_impl_l->xpath.ops->set_xpath;
+    
+    return axis2_xml_schema_annotated_resolve_methods(&(xpath->base), 
+            env, xpath_impl_l->annotated, methods);
+}
+
+axis2_char_t *AXIS2_CALL
+axis2_xml_schema_xpath_get_xpath(void *xpath,
+                                 axis2_env_t **env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    return INTF_TO_IMPL(xpath)->x_path;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_schema_xpath_set_xpath(void *xpath,
+                                 axis2_env_t **env,
+                                 axis2_char_t *x_path)
+{
+    axis2_xml_schema_xpath_impl_t *xpath_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, xpath, AXIS2_FAILURE);
+    xpath_impl = INTF_TO_IMPL(xpath);
+    
+    if(xpath_impl->x_path)
+    {
+        AXIS2_FREE((*env)->allocator, xpath_impl->x_path);
+        xpath_impl->x_path = NULL;
+    }
+    xpath_impl->x_path = AXIS2_STRDUP(x_path, env);
+    if(!xpath_impl->x_path)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return AXIS2_FAILURE;
+    }
+
+    return AXIS2_SUCCESS;
+}
+

Added: webservices/axis2/trunk/c/modules/xml/xml_schema/xml_tokenized_type.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/xml/xml_schema/xml_tokenized_type.c?rev=394660&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/xml/xml_schema/xml_tokenized_type.c (added)
+++ webservices/axis2/trunk/c/modules/xml/xml_schema/xml_tokenized_type.c Mon Apr 17 05:15:47 2006
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_xml_tokenized_type.h>
+
+typedef struct axis2_xml_tokenized_type_impl axis2_xml_tokenized_type_impl_t;
+
+/** 
+ * @brief Other Extension Struct Impl
+ *	Axis2 Other Extension  
+ */ 
+struct axis2_xml_tokenized_type_impl
+{
+    axis2_xml_tokenized_type_t tokenized_type;
+    axis2_xml_schema_enum_t *schema_enum;
+    axis2_hash_t *methods;
+    axis2_array_list_t *members;
+};
+
+#define INTF_TO_IMPL(tokenized_type) ((axis2_xml_tokenized_type_impl_t *) tokenized_type)
+
+axis2_status_t AXIS2_CALL 
+axis2_xml_tokenized_type_free(void *tokenized_type,
+                        axis2_env_t **env);
+
+axis2_xml_schema_enum_t *AXIS2_CALL
+axis2_xml_tokenized_type_get_base_impl(void *tokenized_type,
+                                axis2_env_t **env);
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_tokenized_type_resolve_methods(
+                                axis2_xml_tokenized_type_t *tokenized_type,
+                                axis2_env_t **env,
+                                axis2_xml_tokenized_type_t *tokenized_type_impl,
+                                axis2_hash_t *methods);
+
+axis2_array_list_t *
+axis2_xml_tokenized_type_get_values(void *tokenized_type,
+                        axis2_env_t **env);
+
+
+AXIS2_DECLARE(axis2_xml_tokenized_type_t *)
+axis2_xml_tokenized_type_create(axis2_env_t **env,
+                            axis2_char_t *value)
+{
+    axis2_xml_tokenized_type_impl_t *tokenized_type_impl = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    
+    tokenized_type_impl = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_tokenized_type_impl_t));
+
+    tokenized_type_impl->schema_enum = NULL;
+    tokenized_type_impl->methods = NULL;
+    tokenized_type_impl->members = NULL;
+    tokenized_type_impl->tokenized_type.ops = AXIS2_MALLOC((*env)->allocator, 
+                    sizeof(axis2_xml_tokenized_type_ops_t));
+
+    tokenized_type_impl->tokenized_type.ops->free = axis2_xml_tokenized_type_free;
+    tokenized_type_impl->tokenized_type.ops->get_base_impl = axis2_xml_tokenized_type_get_base_impl;
+    tokenized_type_impl->tokenized_type.ops->get_values = 
+            axis2_xml_tokenized_type_get_values;
+   
+    if(!tokenized_type_impl->members)
+    {
+        tokenized_type_impl->members = axis2_array_list_create(env, 0);
+        if(!tokenized_type_impl->members)
+            return NULL;
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "CDATA");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "IDREF");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "IDREFS");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "ENTITY");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "ENTITIES");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "NMTOKEN");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "NMTOKENS");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "NOTATION");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "ENUMERATION");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "QName");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "NCName");
+        AXIS2_ARRAY_LIST_ADD(tokenized_type_impl->members, env, "None");
+    }
+    tokenized_type_impl->methods = axis2_hash_make(env);
+    if(!tokenized_type_impl->methods)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    axis2_hash_set(tokenized_type_impl->methods, "free", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_tokenized_type_free);
+    axis2_hash_set(tokenized_type_impl->methods, "get_values", AXIS2_HASH_KEY_STRING, 
+            axis2_xml_tokenized_type_get_values);
+
+    tokenized_type_impl->schema_enum = axis2_xml_schema_enum_create(env, value);
+    status = axis2_xml_schema_enum_resolve_methods(
+            &(tokenized_type_impl->tokenized_type.base), env, tokenized_type_impl->schema_enum, 
+            tokenized_type_impl->methods); 
+
+    return &(tokenized_type_impl->tokenized_type);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_xml_tokenized_type_free(void *tokenized_type,
+                                        axis2_env_t **env)
+{
+    axis2_xml_tokenized_type_impl_t *tokenized_type_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    tokenized_type_impl = INTF_TO_IMPL(tokenized_type);
+
+    if(tokenized_type_impl->members)
+    {
+        AXIS2_ARRAY_LIST_FREE(tokenized_type_impl->members, env);
+        tokenized_type_impl->members = NULL;
+    }
+    
+    if(tokenized_type_impl->schema_enum)
+    {
+        AXIS2_XML_SCHEMA_ENUM_FREE(tokenized_type_impl->schema_enum, env);
+        tokenized_type_impl->schema_enum = NULL;
+    }
+    
+    if((&(tokenized_type_impl->tokenized_type))->ops)
+    {
+        AXIS2_FREE((*env)->allocator, (&(tokenized_type_impl->tokenized_type))->ops);
+        (&(tokenized_type_impl->tokenized_type))->ops = NULL;
+    }
+
+    if(tokenized_type_impl)
+    {
+        AXIS2_FREE((*env)->allocator, tokenized_type_impl);
+        tokenized_type_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_xml_schema_enum_t *AXIS2_CALL
+axis2_xml_tokenized_type_get_base_impl(void *tokenized_type,
+                                axis2_env_t **env)
+{
+    axis2_xml_tokenized_type_impl_t *tokenized_type_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    tokenized_type_impl = INTF_TO_IMPL(tokenized_type);
+
+    return tokenized_type_impl->schema_enum;
+}
+
+AXIS2_DECLARE(axis2_status_t)
+axis2_xml_tokenized_type_resolve_methods(
+                        axis2_xml_tokenized_type_t *tokenized_type,
+                        axis2_env_t **env,
+                        axis2_xml_tokenized_type_t *tokenized_type_impl,
+                        axis2_hash_t *methods)
+{
+    axis2_xml_tokenized_type_impl_t *tokenized_type_impl_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, tokenized_type_impl, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK((*env)->error, methods, AXIS2_FAILURE);
+    
+    tokenized_type_impl_l = (axis2_xml_tokenized_type_impl_t *) 
+        tokenized_type_impl;
+    
+    tokenized_type->ops = AXIS2_MALLOC((*env)->allocator, 
+            sizeof(axis2_xml_tokenized_type_ops_t));
+    tokenized_type->ops->free = axis2_hash_get(methods, "free", 
+            AXIS2_HASH_KEY_STRING);
+    tokenized_type->ops->get_base_impl = 
+            tokenized_type_impl_l->tokenized_type.ops->get_base_impl;
+    tokenized_type->ops->get_values = 
+            tokenized_type_impl_l->tokenized_type.ops->get_values;
+    
+    return axis2_xml_schema_enum_resolve_methods(&(tokenized_type->base), 
+            env, tokenized_type_impl_l->schema_enum, methods);
+}
+
+axis2_array_list_t *AXIS2_CALL
+axis2_xml_tokenized_type_get_values(void *tokenized_type,
+                                        axis2_env_t **env)
+{
+    return INTF_TO_IMPL(tokenized_type)->members;
+}
+



Mime
View raw message