axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r491530 [2/4] - in /webservices/axis2/trunk/c: axiom/include/ axiom/src/om/ modules/core/deployment/
Date Mon, 01 Jan 2007 04:16:56 GMT
Modified: webservices/axis2/trunk/c/axiom/include/axiom_element.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_element.h?view=diff&rev=491530&r1=491529&r2=491530
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axiom_element.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_element.h Sun Dec 31 20:16:53 2006
@@ -49,412 +49,6 @@
     */
    struct axiom_element_ops
     {
-       /*
-        * Find a namespace in the scope of the document.
-        * Start to find from the given node and go up the hierarchy.
-        * @param om_element pointer to om_element_struct contained in
-        *        node , 
-        * @param env Environment. MUST NOT be NULL.
-        * @param node node containing an instance of an AXIOM element,cannot be NULL.
-        * @param uri namespace uri..
-        * @param prefix namespace prefix. can be NULL.
-        * @return pointer to the namespace, if found, else NULL. On error, returns 
-        *           NULL and sets error code in environment,s error
-        */
-        axiom_namespace_t* (AXIS2_CALL *
-        find_namespace)(axiom_element_t *om_element,
-                        const axis2_env_t *env,
-                        axiom_node_t *node,
-                        const axis2_char_t *uri,
-                        const axis2_char_t *prefix);
-      /**
-        * Declare a namespace in current element (in the scope of this element ).
-        * It checks to see if it is already declared.
-        * @param om_element contained in the om node struct
-        * @param env Environment. MUST NOT be NULL.
-        * @param node node containing an instance of an AXIOM element.
-        * @param ns pointer to the namespace struct to be declared
-        * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
-        */
-        axis2_status_t (AXIS2_CALL *
-        declare_namespace)(axiom_element_t *om_element,
-                           const axis2_env_t *env,
-                           axiom_node_t *node,
-                           axiom_namespace_t * ns);
-       /**
-        * Finds a namespace using qname
-        * Start to find from the given node and go up the hierarchy.
-        * @param om_element om_element contained in node
-        * @param env Environment. MUST NOT be NULL.
-        * @param node node containing an instance of an AXIOM element, cannot be NULL.                                        
-        * @param qname qname of the namespace to be found. cannot be NULL.
-        * @return pointer to the namespace, if found, else NULL. On error, returns 
-        *           NULL and sets the error code in environment's error struct.
-        */
-         axiom_namespace_t *(AXIS2_CALL *
-         find_namespace_with_qname)(axiom_element_t *om_element,
-                                    const axis2_env_t *env,
-                                    axiom_node_t *node,
-                                    axis2_qname_t *qname);
-
-      /**
-        * Adds an attribute to current element
-        * @param om_element element to which the attribute is to be added.cannot be NULL.
-        * @param env Environment. MUST NOT be NULL.
-        * @param attribute attribute to be added.
-        * @param node axiom_node_t node that om_element is contained in
-        * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
-        */
-         axis2_status_t (AXIS2_CALL *
-         add_attribute)(axiom_element_t *om_element,
-                        const axis2_env_t *env,
-                        axiom_attribute_t *attribute,
-                        axiom_node_t *node);
-
-      /**
-        * Gets (finds) the attribute with the given qname
-        * @param element element whose attribute is to be found. 
-        * @param env Environment. MUST NOT be NULL.
-        * @qname qname qname of the attribute to be found. should not be NULL.
-        * @return a pointer to the attribute with given qname if found, else NULL.
-        *           On error, returns NULL and sets the error code in environment's error struct.
-        */
-         axiom_attribute_t *(AXIS2_CALL *
-         get_attribute) (axiom_element_t *om_element,
-                         const axis2_env_t *env,
-                         axis2_qname_t * qname);
-                         
-        /**
-        * Gets (finds) the attribute value with the given qname
-        * @param element element whose attribute is to be found. 
-        * @param env Environment. MUST NOT be NULL.
-        * @qname qname qname of the attribute to be found. should not be NULL.
-        * @return the attribute value with given qname if found, else NULL.
-        *  On error, returns NULL and sets the error code in environment's error struct.
-        */
-         axis2_char_t *(AXIS2_CALL *
-         get_attribute_value) (axiom_element_t *om_element,
-                               const axis2_env_t *env,
-                               axis2_qname_t * qname);                         
-        
-      /**
-        * Frees given element 
-        * @param element AXIOM element to be freed.
-        * @param env Environment. MUST NOT be NULL.
-         * @return satus of the op. AXIS2_SUCCESS on success ,AXIS2_FAILURE on error.
-        */
-         axis2_status_t (AXIS2_CALL *
-         free) (axiom_element_t *element,
-                const axis2_env_t *env);
-
-      /**
-        * Serializes the start part of the given element
-        * @param element element to be serialized.
-        * @param env Environment. MUST NOT be NULL.
-        * @param om_output AXIOM output handler to be used in serializing
-        * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
-        */
-        axis2_status_t (AXIS2_CALL *
-        serialize_start_part)(axiom_element_t *om_element,
-                              const axis2_env_t *env,
-                              axiom_output_t * om_output,
-                              axiom_node_t *ele_node);
-
-      /**
-        * Serializes the end part of the given element. serialize_start_part must 
-        *     have been called before calling this method.
-        * @param om_element element to be serialized.
-        * @param env Environment must not be null.
-        * @param om_output AXIOM output handler to be used in serializing
-        * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
-        */
-        axis2_status_t (AXIS2_CALL *
-        serialize_end_part)(axiom_element_t *om_element,
-                            const axis2_env_t *env,
-                            axiom_output_t * om_output);
-       /**
-        *  finds a namespace in current elements scope
-        * @param om_element
-        * @param env environemt must not be null
-        * @param uri namespace uri
-        * @param prefix prefix 
-        * @return axiom_namespace_t if found, else return NULL
-        */ 
-        
-        axiom_namespace_t* (AXIS2_CALL *
-        find_declared_namespace)(axiom_element_t *om_element,
-                                 const axis2_env_t *env,
-                                 const axis2_char_t *uri,
-                                 const axis2_char_t *prefix);
-                                                             
-                                                        
-       /**
-        * returns the localname of this element
-        * @param om_element om_element struct
-        * @param env environment struct
-        * @returns localname of element, returns NULL on error.
-        */        
-        axis2_char_t* (AXIS2_CALL *
-        get_localname)(axiom_element_t *om_element,
-                       const axis2_env_t *env);
-       /**
-        * set the localname of this element
-        * @param om_element om_element_struct to with localname is set
-        * @param env environment struct
-        * @localname text value to be set as localname 
-        * @returns status code of op, AXIS2_SUCCESS on success,
-        *                   AXIS2_FAILURE on error.
-        */
-        axis2_status_t (AXIS2_CALL *
-        set_localname)(axiom_element_t *om_element,
-                       const axis2_env_t *env,
-                       const axis2_char_t *localname);
-        /**
-         * get the namespace  of om_element 
-         * @param om_element om_element struct
-         * @param env environemt, MUST NOT be NULL.
-         * @returns pointer to axiom_namespace_t struct 
-         *          NULL if there is no namespace associated with the element,
-         *          NULL on error with error code set to environment's error
-         */
-        axiom_namespace_t *(AXIS2_CALL *
-        get_namespace)(axiom_element_t *om_element,
-                       const axis2_env_t *env,
-                       axiom_node_t *ele_node);
-       /**
-        * set the namespace of the element
-        * @param om_element Om_element struct
-        * @param env environment must not be null
-        * @param ns pointer to namespace
-        * @returns status code of the op , NULL on error with error code 
-        *                  set to environment's error
-        */                                         
-        axis2_status_t (AXIS2_CALL *
-        set_namespace)(axiom_element_t *om_element,
-                       const axis2_env_t *env,
-                       axiom_namespace_t *ns,
-                       axiom_node_t *node);
-        /**
-         * get  the attribute list of the element 
-         * @param om_element om element
-         * @param env environment must not be null
-         * @returns axis2_hash poiner to attributes hash
-         * This hash table is read only 
-         */
-        axis2_hash_t* (AXIS2_CALL *
-        get_all_attributes)(axiom_element_t *om_element,
-                            const axis2_env_t *env);
-        /**
-         * get the namespace list of the element
-         * @param om_element om element
-         * @param env environment
-         * @returns axis2_hash pointer to namespaces hash
-         * this hash table is read only
-         */                                             
-        axis2_hash_t* (AXIS2_CALL *
-        get_namespaces)(axiom_element_t *om_element,
-                        const axis2_env_t *env);
-        /**
-         *@return qname of this element
-         * the returned qname should not be externaly freed
-         * when om_element struct is freed qname is also
-         * freed 
-         * @returns axis2_qname_t struct , NULL on failure
-         */
-        axis2_qname_t* (AXIS2_CALL *
-        get_qname)(axiom_element_t *om_element,
-                   const axis2_env_t *env,
-                   axiom_node_t *ele_node);
-        
-       /**
-        *   returns a list of children iterator
-        *   iterators free function must be called by user
-        */        
-        axiom_children_iterator_t*(AXIS2_CALL *
-        get_children)(axiom_element_t *om_element,
-                      const axis2_env_t *env,
-                     axiom_node_t *element_node);
-                                      
-       /**
-        *   returns a list of children iterator with qname
-        *   returned iterator is freed when om element struct
-        *  is freed 
-        * @param om_element 
-        * @param env 
-        * @param element_qname 
-        * @param element_node 
-        * @returns children qname iterator struct
-        */        
-                                                
-        axiom_children_qname_iterator_t *(AXIS2_CALL *
-        get_children_with_qname)(axiom_element_t *om_element,
-                                 const axis2_env_t *env,
-                                 axis2_qname_t *element_qname,
-                                 axiom_node_t* element_node);
-        /**
-         * returns the om_element corresponding to element_qname
-         */                            
-        
-        axiom_element_t* (AXIS2_CALL *
-        get_first_child_with_qname)(axiom_element_t *om_element,
-                                     const axis2_env_t *env,
-                                     axis2_qname_t *element_qname,
-                                     axiom_node_t* element_node,
-                                     axiom_node_t **child_node);                       
-        /**
-         * removes an attribute from the element attribute list
-         * user must free this attribute, element free function does not free 
-         * attributes that are not is it's attribute list
-         * @param om_element
-         * @param env
-         * @param om_attribute attribute to be removed
-         * @return AXIS2_SUCCESS if attribute was found and removed, else 
-         *           AXIS2_FAILURE
-         */         
-        axis2_status_t (AXIS2_CALL *
-        remove_attribute)(axiom_element_t *om_element,
-                          const axis2_env_t *env,
-                          axiom_attribute_t *om_attribute); 
-        /**
-         * Sets the text of the given element.
-         *caution - This method will wipe out all the text elements (and hence any
-         * mixed content) before setting the text
-         */
-        axis2_status_t (AXIS2_CALL *
-        set_text)(axiom_element_t *om_element,
-                  const axis2_env_t *env,
-                  const axis2_char_t *text,
-                  axiom_node_t *element_node); 
-        /**
-         * select all the text children and concat them to a single string
-         * @param element node , the container node of this om element
-         * @return the contanated text of all text childrens text values
-         *         return null if no text children is avilable or on error
-         */                                              
-        axis2_char_t* (AXIS2_CALL *
-        get_text)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_node_t *element_node);
-    
-        /**
-         * returns the first child om element of this om element node
-         * @param element_node the container node of this om_element
-         * @return om_element if one is availble otherwise return NULL
-         */
-        axiom_element_t* (AXIS2_CALL *
-        get_first_element)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_node_t *element_node,
-                axiom_node_t **first_element_node);  
-        /**
-         * returns the serilized text of this element and its children
-         * @param element_node the container node this on element is contained 
-         * @return a char array of xml , returns NULL on error
-         */
-        axis2_char_t* (AXIS2_CALL *
-        to_string)(
-                axiom_element_t *om_element,
-            const axis2_env_t *env,
-            axiom_node_t *element_node);
-        /** 
-         * returns an iterator with child elements of type AXIOM_ELEMENT
-         * iterator is freed when om_element node is freed
-         * @param om_element
-         * @param element_node
-         * @param env enviroment must not be null
-         * @returns axiom_child_element_iterator_t , NULL on error                                             
-         */
-         axiom_child_element_iterator_t* (AXIS2_CALL *
-         get_child_elements)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_node_t *element_node);                                                                            
-        /**
-         * builds this om_element_node completely, This is only possible 
-         * if the om_stax_builder is associated with the om_element_node,
-         * @param om_element om_element struct
-         * @param env environment
-         * @param element_node corresponding om element node of this om element
-         * struct 
-         * @returns AXIS2_SUCCESS if this element node was successfully completed,
-         * otherwise returns AXIS2_FAILURE
-         */
-         axis2_status_t (AXIS2_CALL *
-         build)(axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_node_t *element_node);
-                
-        /** 
-         * retrieves the default namespace of this element , if available,
-         * @param om_element pointer to om element
-         * @param env axis2_environment MUST Not be NULL
-         * @returns pointer to default namespace if availale , NULL otherwise
-         */
-         axiom_namespace_t* (AXIS2_CALL *
-         get_default_namespace)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_node_t *element_node);
-                                
-        /**
-         * declared a default namespace explicitly 
-         * @param om_element pointer to om element
-         * @param env environment MUST not be NULL
-         * @param uri namespace uri of the default namespace
-         * @returns the declared namespace
-                                                     */
-         axiom_namespace_t* (AXIS2_CALL *
-         declare_default_namespace)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axis2_char_t *uri);
-                
-        /** 
-         * checks for the namespace in the context of this element 
-         * with the given prefix 
-         * @param om_element pointer to om_element
-         * @param env environment MUST not be NULL
-         * @param om_element_node pointer to this element node
-         * @returns pointer to relevent namespace 
-         */
-         
-         axiom_namespace_t* (AXIS2_CALL *
-         find_namespace_uri)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axis2_char_t *prefix,
-                axiom_node_t *element_node);  
-        /**
-         *This will not search the namespace in the scope nor will 
-         * declare in the current element, as in set_namespace. This will
-         * just assign the given namespace to the element.
-         * @param om_ns pointer to namespace to be set
-         * @returns 
-         */
-         axis2_status_t (AXIS2_CALL *
-         set_namespace_with_no_find_in_current_scope)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_namespace_t *om_ns); 
-                
-        /**
-         *  Extract attributes , returns a clones hash table of attributes,
-         *  if attributes are associated with a namespace it is also cloned
-         */                                                       
-         axis2_hash_t* (AXIS2_CALL *
-         extract_attributes)(
-                axiom_element_t *om_element,
-                const axis2_env_t *env,
-                axiom_node_t *ele_node);
-                
-         axis2_char_t* (AXIS2_CALL*
-         get_attribute_value_by_name)(
-                axiom_element_t *om_ele,
-                const axis2_env_t *env,
-                axis2_char_t *attr_name);
-                
     };
 
     
@@ -465,8 +59,7 @@
     struct axiom_element
     {
         /** ops of attribute struct */
-        axiom_element_ops_t *ops;
-
+        const axiom_element_ops_t *ops;
     };
 
   /**
@@ -502,118 +95,516 @@
                                         axiom_node_t *parent,
                                         const axis2_qname_t *qname,
                                         axiom_node_t ** node);
+   /*
+    * Find a namespace in the scope of the document.
+    * Start to find from the given node and go up the hierarchy.
+    * @param om_element pointer to om_element_struct contained in
+    *        node , 
+    * @param env Environment. MUST NOT be NULL.
+    * @param node node containing an instance of an AXIOM element,cannot be NULL.
+    * @param uri namespace uri..
+    * @param prefix namespace prefix. can be NULL.
+    * @return pointer to the namespace, if found, else NULL. On error, returns 
+    *           NULL and sets error code in environment,s error
+    */
+    AXIS2_EXTERN axiom_namespace_t* AXIS2_CALL 
+    axiom_element_find_namespace(axiom_element_t *om_element,
+                    const axis2_env_t *env,
+                    axiom_node_t *node,
+                    const axis2_char_t *uri,
+                    const axis2_char_t *prefix);
+  /**
+    * Declare a namespace in current element (in the scope of this element ).
+    * It checks to see if it is already declared.
+    * @param om_element contained in the om node struct
+    * @param env Environment. MUST NOT be NULL.
+    * @param node node containing an instance of an AXIOM element.
+    * @param ns pointer to the namespace struct to be declared
+    * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
+    */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_declare_namespace(axiom_element_t *om_element,
+                       const axis2_env_t *env,
+                       axiom_node_t *node,
+                       axiom_namespace_t * ns);
+   /**
+    * Finds a namespace using qname
+    * Start to find from the given node and go up the hierarchy.
+    * @param om_element om_element contained in node
+    * @param env Environment. MUST NOT be NULL.
+    * @param node node containing an instance of an AXIOM element, cannot be NULL.                                        
+    * @param qname qname of the namespace to be found. cannot be NULL.
+    * @return pointer to the namespace, if found, else NULL. On error, returns 
+    *           NULL and sets the error code in environment's error struct.
+    */
+     AXIS2_EXTERN axiom_namespace_t * AXIS2_CALL 
+     axiom_element_find_namespace_with_qname(axiom_element_t *om_element,
+                                const axis2_env_t *env,
+                                axiom_node_t *node,
+                                axis2_qname_t *qname);
+
+  /**
+    * Adds an attribute to current element
+    * @param om_element element to which the attribute is to be added.cannot be NULL.
+    * @param env Environment. MUST NOT be NULL.
+    * @param attribute attribute to be added.
+    * @param node axiom_node_t node that om_element is contained in
+    * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
+    */
+     AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+     axiom_element_add_attribute(axiom_element_t *om_element,
+                    const axis2_env_t *env,
+                    axiom_attribute_t *attribute,
+                    axiom_node_t *node);
+
+  /**
+    * Gets (finds) the attribute with the given qname
+    * @param element element whose attribute is to be found. 
+    * @param env Environment. MUST NOT be NULL.
+    * @qname qname qname of the attribute to be found. should not be NULL.
+    * @return a pointer to the attribute with given qname if found, else NULL.
+    *           On error, returns NULL and sets the error code in environment's error struct.
+    */
+     AXIS2_EXTERN axiom_attribute_t *AXIS2_CALL 
+     axiom_element_get_attribute (axiom_element_t *om_element,
+                     const axis2_env_t *env,
+                     axis2_qname_t * qname);
+                     
+    /**
+    * Gets (finds) the attribute value with the given qname
+    * @param element element whose attribute is to be found. 
+    * @param env Environment. MUST NOT be NULL.
+    * @qname qname qname of the attribute to be found. should not be NULL.
+    * @return the attribute value with given qname if found, else NULL.
+    *  On error, returns NULL and sets the error code in environment's error struct.
+    */
+     AXIS2_EXTERN axis2_char_t * AXIS2_CALL 
+     axiom_element_get_attribute_value (axiom_element_t *om_element,
+                           const axis2_env_t *env,
+                           axis2_qname_t * qname);                         
+    
+  /**
+    * Frees given element 
+    * @param element AXIOM element to be freed.
+    * @param env Environment. MUST NOT be NULL.
+     * @return satus of the op. AXIS2_SUCCESS on success ,AXIS2_FAILURE on error.
+    */
+     AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+     axiom_element_free (axiom_element_t *element,
+            const axis2_env_t *env);
+
+  /**
+    * Serializes the start part of the given element
+    * @param element element to be serialized.
+    * @param env Environment. MUST NOT be NULL.
+    * @param om_output AXIOM output handler to be used in serializing
+    * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
+    */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_serialize_start_part(axiom_element_t *om_element,
+                          const axis2_env_t *env,
+                          axiom_output_t * om_output,
+                          axiom_node_t *ele_node);
+
+  /**
+    * Serializes the end part of the given element. serialize_start_part must 
+    *     have been called before calling this method.
+    * @param om_element element to be serialized.
+    * @param env Environment must not be null.
+    * @param om_output AXIOM output handler to be used in serializing
+    * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
+    */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_serialize_end_part(axiom_element_t *om_element,
+                        const axis2_env_t *env,
+                        axiom_output_t * om_output);
+   /**
+    *  finds a namespace in current elements scope
+    * @param om_element
+    * @param env environemt must not be null
+    * @param uri namespace uri
+    * @param prefix prefix 
+    * @return axiom_namespace_t if found, else return NULL
+    */ 
+    
+    AXIS2_EXTERN axiom_namespace_t* AXIS2_CALL 
+    axiom_element_find_declared_namespace(axiom_element_t *om_element,
+                             const axis2_env_t *env,
+                             const axis2_char_t *uri,
+                             const axis2_char_t *prefix);
+                                                         
+                                                    
+   /**
+    * returns the localname of this element
+    * @param om_element om_element struct
+    * @param env environment struct
+    * @returns localname of element, returns NULL on error.
+    */        
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_element_get_localname(axiom_element_t *om_element,
+                   const axis2_env_t *env);
+   /**
+    * set the localname of this element
+    * @param om_element om_element_struct to with localname is set
+    * @param env environment struct
+    * @localname text value to be set as localname 
+    * @returns status code of op, AXIS2_SUCCESS on success,
+    *                   AXIS2_FAILURE on error.
+    */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_set_localname(axiom_element_t *om_element,
+                   const axis2_env_t *env,
+                   const axis2_char_t *localname);
+    /**
+     * get the namespace  of om_element 
+     * @param om_element om_element struct
+     * @param env environemt, MUST NOT be NULL.
+     * @returns pointer to axiom_namespace_t struct 
+     *          NULL if there is no namespace associated with the element,
+     *          NULL on error with error code set to environment's error
+     */
+    AXIS2_EXTERN axiom_namespace_t * AXIS2_CALL 
+    axiom_element_get_namespace(axiom_element_t *om_element,
+                   const axis2_env_t *env,
+                   axiom_node_t *ele_node);
+   /**
+    * set the namespace of the element
+    * @param om_element Om_element struct
+    * @param env environment must not be null
+    * @param ns pointer to namespace
+    * @returns status code of the op , NULL on error with error code 
+    *                  set to environment's error
+    */                                         
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_set_namespace(axiom_element_t *om_element,
+                   const axis2_env_t *env,
+                   axiom_namespace_t *ns,
+                   axiom_node_t *node);
+    /**
+     * get  the attribute list of the element 
+     * @param om_element om element
+     * @param env environment must not be null
+     * @returns axis2_hash poiner to attributes hash
+     * This hash table is read only 
+     */
+    AXIS2_EXTERN axis2_hash_t* AXIS2_CALL 
+    axiom_element_get_all_attributes(axiom_element_t *om_element,
+                        const axis2_env_t *env);
+    /**
+     * get the namespace list of the element
+     * @param om_element om element
+     * @param env environment
+     * @returns axis2_hash pointer to namespaces hash
+     * this hash table is read only
+     */                                             
+    AXIS2_EXTERN axis2_hash_t* AXIS2_CALL 
+    axiom_element_get_namespaces(axiom_element_t *om_element,
+                    const axis2_env_t *env);
+    /**
+     *@return qname of this element
+     * the returned qname should not be externaly freed
+     * when om_element struct is freed qname is also
+     * freed 
+     * @returns axis2_qname_t struct , NULL on failure
+     */
+    AXIS2_EXTERN axis2_qname_t* AXIS2_CALL 
+    axiom_element_get_qname(axiom_element_t *om_element,
+               const axis2_env_t *env,
+               axiom_node_t *ele_node);
+    
+   /**
+    *   returns a list of children iterator
+    *   iterators free function must be called by user
+    */        
+    AXIS2_EXTERN axiom_children_iterator_t* AXIS2_CALL 
+    axiom_element_get_children(axiom_element_t *om_element,
+                  const axis2_env_t *env,
+                 axiom_node_t *element_node);
+                                  
+   /**
+    *   returns a list of children iterator with qname
+    *   returned iterator is freed when om element struct
+    *  is freed 
+    * @param om_element 
+    * @param env 
+    * @param element_qname 
+    * @param element_node 
+    * @returns children qname iterator struct
+    */        
+                                            
+    AXIS2_EXTERN axiom_children_qname_iterator_t * AXIS2_CALL 
+    axiom_element_get_children_with_qname(axiom_element_t *om_element,
+                             const axis2_env_t *env,
+                             axis2_qname_t *element_qname,
+                             axiom_node_t* element_node);
+    /**
+     * returns the om_element corresponding to element_qname
+     */                            
+    
+    AXIS2_EXTERN axiom_element_t* AXIS2_CALL 
+    axiom_element_get_first_child_with_qname(axiom_element_t *om_element,
+                                 const axis2_env_t *env,
+                                 axis2_qname_t *element_qname,
+                                 axiom_node_t* element_node,
+                                 axiom_node_t **child_node);                       
+    /**
+     * removes an attribute from the element attribute list
+     * user must free this attribute, element free function does not free 
+     * attributes that are not is it's attribute list
+     * @param om_element
+     * @param env
+     * @param om_attribute attribute to be removed
+     * @return AXIS2_SUCCESS if attribute was found and removed, else 
+     *           AXIS2_FAILURE
+     */         
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_remove_attribute(axiom_element_t *om_element,
+                      const axis2_env_t *env,
+                      axiom_attribute_t *om_attribute); 
+    /**
+     * Sets the text of the given element.
+     *caution - This method will wipe out all the text elements (and hence any
+     * mixed content) before setting the text
+     */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_element_set_text(axiom_element_t *om_element,
+              const axis2_env_t *env,
+              const axis2_char_t *text,
+              axiom_node_t *element_node); 
+    /**
+     * select all the text children and concat them to a single string
+     * @param element node , the container node of this om element
+     * @return the contanated text of all text childrens text values
+     *         return null if no text children is avilable or on error
+     */                                              
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_element_get_text(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *element_node);
+
+    /**
+     * returns the first child om element of this om element node
+     * @param element_node the container node of this om_element
+     * @return om_element if one is availble otherwise return NULL
+     */
+    AXIS2_EXTERN axiom_element_t* AXIS2_CALL 
+    axiom_element_get_first_element(
+            axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *element_node,
+            axiom_node_t **first_element_node);  
+    /**
+     * returns the serilized text of this element and its children
+     * @param element_node the container node this on element is contained 
+     * @return a char array of xml , returns NULL on error
+     */
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_element_to_string(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *element_node);            
+    /** 
+     * returns an iterator with child elements of type AXIOM_ELEMENT
+     * iterator is freed when om_element node is freed
+     * @param om_element
+     * @param element_node
+     * @param env enviroment must not be null
+     * @returns axiom_child_element_iterator_t , NULL on error                                             
+     */
+     AXIS2_EXTERN axiom_child_element_iterator_t* AXIS2_CALL 
+     axiom_element_get_child_elements(
+            axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *element_node);                                                                            
+    /**
+     * builds this om_element_node completely, This is only possible 
+     * if the om_stax_builder is associated with the om_element_node,
+     * @param om_element om_element struct
+     * @param env environment
+     * @param element_node corresponding om element node of this om element
+     * struct 
+     * @returns AXIS2_SUCCESS if this element node was successfully completed,
+     * otherwise returns AXIS2_FAILURE
+     */
+     AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+     axiom_element_build(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *element_node);
+            
+    /** 
+     * retrieves the default namespace of this element , if available,
+     * @param om_element pointer to om element
+     * @param env axis2_environment MUST Not be NULL
+     * @returns pointer to default namespace if availale , NULL otherwise
+     */
+     AXIS2_EXTERN axiom_namespace_t* AXIS2_CALL 
+     axiom_element_get_default_namespace(
+            axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *element_node);
+                            
+    /**
+     * declared a default namespace explicitly 
+     * @param om_element pointer to om element
+     * @param env environment MUST not be NULL
+     * @param uri namespace uri of the default namespace
+     * @returns the declared namespace
+                                                 */
+     AXIS2_EXTERN axiom_namespace_t* AXIS2_CALL 
+     axiom_element_declare_default_namespace(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axis2_char_t *uri);
+            
+    /** 
+     * checks for the namespace in the context of this element 
+     * with the given prefix 
+     * @param om_element pointer to om_element
+     * @param env environment MUST not be NULL
+     * @param om_element_node pointer to this element node
+     * @returns pointer to relevent namespace 
+     */
+     
+     AXIS2_EXTERN axiom_namespace_t* AXIS2_CALL 
+     axiom_element_find_namespace_uri(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axis2_char_t *prefix,
+            axiom_node_t *element_node);  
+    /**
+     *This will not search the namespace in the scope nor will 
+     * declare in the current element, as in set_namespace. This will
+     * just assign the given namespace to the element.
+     * @param om_ns pointer to namespace to be set
+     * @returns 
+     */
+     AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+     axiom_element_set_namespace_with_no_find_in_current_scope(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_namespace_t *om_ns); 
+            
+    /**
+     *  Extract attributes , returns a clones hash table of attributes,
+     *  if attributes are associated with a namespace it is also cloned
+     */                                                       
+     AXIS2_EXTERN axis2_hash_t* AXIS2_CALL 
+     axiom_element_extract_attributes(axiom_element_t *om_element,
+            const axis2_env_t *env,
+            axiom_node_t *ele_node);
+            
+     AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+     axiom_element_get_attribute_value_by_name(axiom_element_t *om_ele,
+            const axis2_env_t *env,
+            axis2_char_t *attr_name);
 
 /** finds given namespace with respect to given node */
 #define AXIOM_ELEMENT_FIND_NAMESPACE(om_element,env,om_node, uri, prefix) \
-        ((om_element)->ops->find_namespace (om_element, env,om_node, uri, prefix))
+        axiom_element_find_namespace (om_element, env,om_node, uri, prefix)
         
 /** declares given namespace with respect to the given node */
 #define AXIOM_ELEMENT_DECLARE_NAMESPACE(om_element, env , om_node, ns) \
-        ((om_element)->ops->declare_namespace (om_element, env, om_node, ns))
+        axiom_element_declare_namespace (om_element, env, om_node, ns)
 
 /** finds namespace with given qname */
 #define AXIOM_ELEMENT_FIND_NAMESPACE_WITH_QNAME (om_element, env, om_node, qname) \
-        ((om_element)->ops->find_namespace_with_qname (om_element, environment, om_node, qname))
+        axiom_element_find_namespace_with_qname (om_element, environment, om_node, qname)
         
 /** adds given attribute to given element */
 #define AXIOM_ELEMENT_ADD_ATTRIBUTE(om_element, env, attribute, element_node) \
-        ((om_element)->ops->add_attribute(om_element , env, attribute, element_node))
+        axiom_element_add_attribute(om_element , env, attribute, element_node)
         
 /** gets (finds) given attribute in given element */
 #define AXIOM_ELEMENT_GET_ATTRIBUTE(om_element, env, qname) \
-        ((om_element)->ops->get_attribute(om_element, env, qname))
+        axiom_element_get_attribute(om_element, env, qname)
         
 /** free an om element */
 #define AXIOM_ELEMENT_FREE(om_element, env) \
-        ((om_element)->ops->free(om_element, env))
+        axiom_element_free(om_element, env)
         
 /** serialize the start part of given element */
 #define AXIOM_ELEMENT_SERIALIZE_START_PART(om_element, env, om_output, ele_node) \
-        ((om_element)->ops->serialize_start_part(om_element, env, om_output, ele_node))
+        axiom_element_serialize_start_part(om_element, env, om_output, ele_node)
         
 /** serialize the end part of given element */
 #define AXIOM_ELEMENT_SERIALIZE_END_PART(om_element, env, om_output) \
-        ((om_element)->ops->serialize_end_part(om_element, env, om_output))
+        axiom_element_serialize_end_part(om_element, env, om_output)
 /** get localname */
 #define AXIOM_ELEMENT_GET_LOCALNAME(om_element, env)\
-        ((om_element)->ops->get_localname(om_element,env))
+        axiom_element_get_localname(om_element,env)
 /** get namespace of this element */        
 #define AXIOM_ELEMENT_GET_NAMESPACE(om_element, env, ele_node) \
-        ((om_element)->ops->get_namespace(om_element, env, ele_node))
+        axiom_element_get_namespace(om_element, env, ele_node)
 /** set localname */        
 #define AXIOM_ELEMENT_SET_LOCALNAME(om_element, env, localname) \
-        ((om_element)->ops->set_localname(om_element, env, localname))
+        axiom_element_set_localname(om_element, env, localname)
 /** set namespace */        
 #define AXIOM_ELEMENT_SET_NAMESPACE(om_element, env, ns , node) \
-        ((om_element)->ops->set_namespace(om_element, env, ns, node))
+        axiom_element_set_namespace(om_element, env, ns, node)
 
 #define AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(om_element, env, uri, prefix) \
-        ((om_element)->ops->find_declared_namespace(om_element, env, uri, prefix))        
+        axiom_element_find_declared_namespace(om_element, env, uri, prefix)        
         
 #define AXIOM_ELEMENT_GET_QNAME(om_element, env, ele_node) \
-        ((om_element)->ops->get_qname(om_element, env, ele_node))
+        axiom_element_get_qname(om_element, env, ele_node)
 
 #define AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(om_element, env) \
-        ((om_element)->ops->get_all_attributes(om_element, env))
+        axiom_element_get_all_attributes(om_element, env)
 
 #define AXIOM_ELEMENT_GET_NAMESPACES(om_element, env) \
-        ((om_element)->ops->get_namespaces(om_element, env)) 
+        axiom_element_get_namespaces(om_element, env) 
         
 #define AXIOM_ELEMENT_GET_CHILDREN(om_element, env, element_node) \
-        ((om_element)->ops->get_children(om_element, env, element_node))
+        axiom_element_get_children(om_element, env, element_node)
 
 #define AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME(om_element, env, \
             element_qname, element_node) \
-        ((om_element)->ops->get_children_with_qname(om_element,\
-            env, element_qname, element_node))
+        axiom_element_get_children_with_qname(om_element,\
+            env, element_qname, element_node)
 
 #define AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(om_element, env,\
             element_qname, element_node , child_node) \
-        ((om_element)->ops->get_first_child_with_qname(om_element, env, \
-            element_qname, element_node, child_node))
+        axiom_element_get_first_child_with_qname(om_element, env, \
+            element_qname, element_node, child_node)
 
 #define AXIOM_ELEMENT_REMOVE_ATTRIBUTE(om_element, env, om_attribute) \
-        ((om_element)->ops->remove_attribute(om_element, env, om_attribute))
+        axiom_element_remove_attribute(om_element, env, om_attribute)
 
 #define AXIOM_ELEMENT_GET_FIRST_ELEMENT(om_element, env, element_node, first_node) \
-        ((om_element)->ops->get_first_element(om_element, env, element_node, first_node))
+        axiom_element_get_first_element(om_element, env, element_node, first_node)
 
 #define AXIOM_ELEMENT_GET_TEXT(om_element, env, element_node) \
-        ((om_element)->ops->get_text(om_element, env, element_node))
+        axiom_element_get_text(om_element, env, element_node)
 
 #define AXIOM_ELEMENT_SET_TEXT(om_element, env, text, element_node) \
-        ((om_element)->ops->set_text(om_element, env, text, element_node))
+        axiom_element_set_text(om_element, env, text, element_node)
 
 #define AXIOM_ELEMENT_TO_STRING(om_element, env, element_node) \
-        ((om_element)->ops->to_string(om_element, env, element_node)) 
+        axiom_element_to_string(om_element, env, element_node) 
                
 #define AXIOM_ELEMENT_GET_CHILD_ELEMENTS(om_element, env, element_node) \
-        ((om_element)->ops->get_child_elements(om_element, env, element_node))
+        axiom_element_get_child_elements(om_element, env, element_node)
 
 #define AXIOM_ELEMENT_BUILD(om_element, env, element_node) \
-        ((om_element)->ops->build(om_element, env, element_node))
+        axiom_element_build(om_element, env, element_node)
         
 #define AXIOM_ELEMENT_GET_DEFAULT_NAMESPACE(om_element, env, element_node) \
-        ((om_element)->ops->get_default_namespace(om_element, env, element_node))
+        axiom_element_get_default_namespace(om_element, env, element_node)
         
 #define AXIOM_ELEMENT_DECLARE_DEFAULT_NAMESPACE(om_element, env, uri) \
-        ((om_element)->ops->declare_default_namespace(om_element, env, uri))
+        axiom_element_declare_default_namespace(om_element, env, uri)
         
 #define AXIOM_ELEMENT_FIND_NAMESPACE_URI(om_element, env, prefix, element_node) \
-        ((om_element)->ops->find_namespace_uri(om_element, env, prefix, element_node))
+        axiom_element_find_namespace_uri(om_element, env, prefix, element_node)
         
 #define AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, qname) \
-        ((om_element)->ops->get_attribute_value(om_element, env, qname))
+        axiom_element_get_attribute_value(om_element, env, qname)
 
 #define AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(om_element, env, attr_name) \
-        ((om_element)->ops->get_attribute_value_by_name(om_element, env, attr_name))
+        axiom_element_get_attribute_value_by_name(om_element, env, attr_name)
         
                 
 #define AXIOM_ELEMENT_SET_NAMESPACE_WITH_NO_FIND_IN_CURRENT_SCOPE(om_element, env, om_ns) \
-        ((om_element)->ops->set_namespace_with_no_find_in_current_scope(om_element, env, om_ns))
+        axiom_element_set_namespace_with_no_find_in_current_scope(om_element, env, om_ns)
                
 #define AXIOM_ELEMENT_EXTRACT_ATTRIBUTES(om_element, env, ele_node) \
-        ((om_element)->ops->extract_attributes(om_element, env, ele_node))
+        axiom_element_extract_attributes(om_element, env, ele_node)
         
 
                                                       

Modified: webservices/axis2/trunk/c/axiom/include/axiom_namespace.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_namespace.h?view=diff&rev=491530&r1=491529&r2=491530
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axiom_namespace.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_namespace.h Sun Dec 31 20:16:53 2006
@@ -48,79 +48,6 @@
     */
     typedef struct axiom_namespace_ops
     {
-      /**
-        * Frees given AXIOM namespcae
-        * @param om_namespace namespace to be freed.
-        * @param env Environment. MUST NOT be NULL.
-        * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
-        */
-        axis2_status_t (AXIS2_CALL *
-        free) (struct axiom_namespace *om_namespace,
-               const axis2_env_t *env);
-
-      /**
-        * Compares two namepsaces
-        * @param om_namespace first namespase to be compared
-        * @param env Environment. MUST NOT be NULL.
-        * @param om_namespace1 second namespace to be compared
-        * @return AXIS2_TRUE if the two namespaces are equal,AXIS2_FALSE otherwise
-        */
-        axis2_bool_t (AXIS2_CALL *
-        equals)(struct axiom_namespace *om_namespace,
-                const axis2_env_t *env,
-                struct axiom_namespace *om_namespace1);
-
-      /**
-        * Serializes given namespace 
-        * @param om_namespace namespace to be serialized.
-        * @param env Environment. MUST NOT be NULL.
-        * @param om_output AXIOM output handler to be used in serializing
-        * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
-        */
-        axis2_status_t (AXIS2_CALL *
-        serialize)(struct axiom_namespace *om_namespace,
-                   const axis2_env_t *env,
-                   axiom_output_t * om_output);
-       /**   
-        *@param om_namespace pointer to om_namespace struct
-        *@param env environment , MUST NOT be NULL.
-        *@returns namespace uri , NULL on error
-        */
-        axis2_char_t* (AXIS2_CALL *
-        get_uri)(struct axiom_namespace *om_namespace,
-                 const axis2_env_t *env);
-       /**   
-        *@param om_namespace pointer to om namespace struct
-        *@param env  environment, MUST NOT be NULL
-        *@return prefix , NULL on error
-        */
-        axis2_char_t* (AXIS2_CALL *
-        get_prefix)(struct axiom_namespace *om_namespace,
-                    const axis2_env_t *env);
-
-
-        /**
-         * clones an om_namespace struct
-         * @param om_namespace pointer to namespace struct
-         * @param env environment
-         * @returns axiom_namespace on success , NULL on error
-         */
-        struct axiom_namespace* (AXIS2_CALL *
-        clone)(struct axiom_namespace *om_namespace,
-               const axis2_env_t *env);
-               
-        /**
-         * to string , returns the string by combining namespace_uri,
-         * and prefix seperated by a '|' character
-         * @param om_namespace 
-         * @param env environment
-         * @returns pointer to string , This is a property of namespace,
-         * should not be freed by user
-         */                                                                                     
-        axis2_char_t * (AXIS2_CALL *
-        to_string)(struct axiom_namespace *om_namespace,
-                   const axis2_env_t *env);
-
     } axiom_namespace_ops_t;
 
   /** 
@@ -130,7 +57,7 @@
     typedef struct axiom_namespace
     {
         /** AXIOM namespace related ops */
-        axiom_namespace_ops_t *ops;
+        const axiom_namespace_ops_t *ops;
         int ref;        
     } axiom_namespace_t;
 
@@ -144,30 +71,102 @@
     axiom_namespace_create (const axis2_env_t *env,
                                const axis2_char_t * uri,
                                const axis2_char_t *prefix);
+  /**
+    * Frees given AXIOM namespcae
+    * @param om_namespace namespace to be freed.
+    * @param env Environment. MUST NOT be NULL.
+    * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
+    */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_namespace_free(struct axiom_namespace *om_namespace,
+           const axis2_env_t *env);
+
+  /**
+    * Compares two namepsaces
+    * @param om_namespace first namespase to be compared
+    * @param env Environment. MUST NOT be NULL.
+    * @param om_namespace1 second namespace to be compared
+    * @return AXIS2_TRUE if the two namespaces are equal,AXIS2_FALSE otherwise
+    */
+    AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+    axiom_namespace_equals(struct axiom_namespace *om_namespace,
+            const axis2_env_t *env,
+            struct axiom_namespace *om_namespace1);
+
+  /**
+    * Serializes given namespace 
+    * @param om_namespace namespace to be serialized.
+    * @param env Environment. MUST NOT be NULL.
+    * @param om_output AXIOM output handler to be used in serializing
+    * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
+    */
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_namespace_serialize(struct axiom_namespace *om_namespace,
+               const axis2_env_t *env,
+               axiom_output_t * om_output);
+   /**   
+    *@param om_namespace pointer to om_namespace struct
+    *@param env environment , MUST NOT be NULL.
+    *@returns namespace uri , NULL on error
+    */
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_namespace_get_uri(struct axiom_namespace *om_namespace,
+             const axis2_env_t *env);
+   /**   
+    *@param om_namespace pointer to om namespace struct
+    *@param env  environment, MUST NOT be NULL
+    *@return prefix , NULL on error
+    */
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_namespace_get_prefix(struct axiom_namespace *om_namespace,
+                const axis2_env_t *env);
+
+
+    /**
+     * clones an om_namespace struct
+     * @param om_namespace pointer to namespace struct
+     * @param env environment
+     * @returns axiom_namespace on success , NULL on error
+     */
+    AXIS2_EXTERN struct axiom_namespace* AXIS2_CALL 
+    axiom_namespace_clone(struct axiom_namespace *om_namespace,
+           const axis2_env_t *env);
+           
+    /**
+     * to string , returns the string by combining namespace_uri,
+     * and prefix seperated by a '|' character
+     * @param om_namespace 
+     * @param env environment
+     * @returns pointer to string , This is a property of namespace,
+     * should not be freed by user
+     */                                                                                     
+    AXIS2_EXTERN axis2_char_t * AXIS2_CALL 
+    axiom_namespace_to_string(struct axiom_namespace *om_namespace,
+               const axis2_env_t *env);
 
 /** frees given namespace */
 #define AXIOM_NAMESPACE_FREE(om_namespace,env) \
-        ((om_namespace)->ops->free(om_namespace, env))
+        axiom_namespace_free(om_namespace, env)
         
 /** compares the given two namespaces for equality */
 #define AXIOM_NAMESPACE_EQUALS(om_namespace, env, om_namespace1) \
-        ((om_namespace)->ops->equals(om_namespace, env, om_namespace1))
+        axiom_namespace_equals(om_namespace, env, om_namespace1)
         
 /** serializes given namespace */
 #define AXIOM_NAMESPACE_SERIALIZE(om_namespace,env, om_output) \
-        ((om_namespace)->ops->serialize(om_namespace, env,om_output))
+        axiom_namespace_serialize(om_namespace, env,om_output)
 /** get prefix */        
 #define AXIOM_NAMESPACE_GET_PREFIX(om_namespace, env) \
-        ((om_namespace)->ops->get_prefix(om_namespace, env))
+        axiom_namespace_get_prefix(om_namespace, env)
 /** get namespace uri */
 #define AXIOM_NAMESPACE_GET_URI(om_namespace, env) \
-        ((om_namespace)->ops->get_uri(om_namespace, env))
+        axiom_namespace_get_uri(om_namespace, env)
 /** clones a namespace */
 #define AXIOM_NAMESPACE_CLONE(om_namespace, env) \
-        ((om_namespace)->ops->clone(om_namespace, env))
+        axiom_namespace_clone(om_namespace, env)
 /** returns a string from namespace */
 #define AXIOM_NAMESPACE_TO_STRING(om_namespace, env) \
-        ((om_namespace)->ops->to_string(om_namespace, env))
+        axiom_namespace_to_string(om_namespace, env)
 
 /** @} */
 

Modified: webservices/axis2/trunk/c/axiom/include/axiom_navigator.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_navigator.h?view=diff&rev=491530&r1=491529&r2=491530
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axiom_navigator.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_navigator.h Sun Dec 31 20:16:53 2006
@@ -47,8 +47,29 @@
  * Encapsulator struct for ops of axiom_node
  */
  
- struct axiom_navigator_ops 
- {
+    struct axiom_navigator_ops 
+    {
+    };
+        
+    /** axiom_navigator_t struct */
+
+    struct axiom_navigator
+    {
+        const axiom_navigator_ops_t *ops;
+    };
+
+    /** create an axiom_navigator 
+     * @param env environment MUST not be NULL
+     * @param node a pointer to axiom_node_t struct 
+     * which is to be navigated
+     * @returns a pointer to axiom_navigator_t struct
+     * or returns NULL on error
+     */
+
+    AXIS2_EXTERN axiom_navigator_t * AXIS2_CALL
+    axiom_navigator_create(const axis2_env_t *env,
+                              axiom_node_t *node);
+    
     /**
      * free function , free the axiom_navigator struct
      * @param om_navigator axiom_navigator_struct
@@ -56,8 +77,8 @@
      * @returns AXIS2_SUCCESS 
      */
      
-     axis2_status_t (AXIS2_CALL *
-     free)(axiom_navigator_t *om_navigator,
+     AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+     axiom_navigator_free(axiom_navigator_t *om_navigator,
            const axis2_env_t *env); 
  
     /**
@@ -68,8 +89,8 @@
      * otherwise returns AXIS2_FALSE
      */
 
-     axis2_bool_t (AXIS2_CALL *
-     is_navigable)(axiom_navigator_t *om_navigator,
+     AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+     axiom_navigator_is_navigable(axiom_navigator_t *om_navigator,
                    const axis2_env_t *env);
 
     /**
@@ -82,8 +103,8 @@
      * otherwise return AXIS2_FALSE
      */
      
-     axis2_bool_t (AXIS2_CALL *
-     is_completed)(axiom_navigator_t *om_navigator,
+     AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+     axiom_navigator_is_completed(axiom_navigator_t *om_navigator,
                         const axis2_env_t *env);
 
     /**
@@ -96,8 +117,8 @@
      * pointer in the next , returns NULL on error or if there is no more nodes
      */
 
-     axiom_node_t* (AXIS2_CALL *
-     next)(axiom_navigator_t *om_navigator, 
+     AXIS2_EXTERN axiom_node_t* AXIS2_CALL 
+     axiom_navigator_next(axiom_navigator_t *om_navigator, 
            const axis2_env_t *env);
 
     /**
@@ -107,47 +128,27 @@
      * @returns AXIS2_TRUE if this node is alrady visited
      * otherwise AXIS2_FALSE
      */
-     axis2_bool_t (AXIS2_CALL *
-     visited)(axiom_navigator_t *om_navigator,
+     AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+     axiom_navigator_visited(axiom_navigator_t *om_navigator,
               const axis2_env_t *env);
 
- };
-    
-/** axiom_navigator_t struct */
-
-struct axiom_navigator
-{
-    axiom_navigator_ops_t *ops;
-};
-
-/** create an axiom_navigator 
- * @param env environment MUST not be NULL
- * @param node a pointer to axiom_node_t struct 
- * which is to be navigated
- * @returns a pointer to axiom_navigator_t struct
- * or returns NULL on error
- */
-
-AXIS2_EXTERN axiom_navigator_t * AXIS2_CALL
-axiom_navigator_create(const axis2_env_t *env,
-                          axiom_node_t *node);
-                          
+                
 /** Macros ********************************************************************/
 
 #define AXIOM_NAVIGATOR_FREE(navigator, env) \
-        ((navigator)->ops->free(navigator, env))
+        axiom_navigator_free(navigator, env)
 
 #define AXIOM_NAVIGATOR_IS_NAVIGABLE(navigator, env) \
-        ((navigator)->ops->is_navigable(navigator, env))
+        axiom_navigator_is_navigable(navigator, env)
 
 #define AXIOM_NAVIGATOR_IS_COMPLETED(navigator, env) \
-        ((navigator)->ops->is_completed(navigator, env))
+        axiom_navigator_is_completed(navigator, env)
 
 #define AXIOM_NAVIGATOR_VISITED(navigator, env) \
-        ((navigator)->ops->visited(navigator, env))
+        axiom_navigator_visited(navigator, env)
 
 #define AXIOM_NAVIGATOR_NEXT(navigator, env) \
-        ((navigator)->ops->next(navigator, env))
+        axiom_navigator_next(navigator, env)
 
 /** @} */
 

Modified: webservices/axis2/trunk/c/axiom/include/axiom_node.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_node.h?view=diff&rev=491530&r1=491529&r2=491530
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axiom_node.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_node.h Sun Dec 31 20:16:53 2006
@@ -84,16 +84,37 @@
     * @brief node ops struct
     * Encapsulator struct for ops of axiom_node
     */
-   typedef struct axiom_node_ops
-{
+    typedef struct axiom_node_ops
+    {
+    } axiom_node_ops_t;
+
+
+/**
+* This is the structure that defines a node in om tree 
+*/
+
+    struct axiom_node
+    {
+        /** ops of node struct */
+        const axiom_node_ops_t *ops;
+    };
+
+  /**
+    * Creates a node struct.
+    * @param env Environment. MUST NOT be NULL, .
+    * @return a pointer to newly created node struct. NULL on error. 
+    */
+    AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+    axiom_node_create (const axis2_env_t *env);
+
     /**
     * Frees an om node and all of its children
     * @param om_node node to be freed.
     * @param env Environment. MUST NOT be NULL, .
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
-    axis2_status_t (AXIS2_CALL *
-    free) (axiom_node_t *om_node,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_node_free (axiom_node_t *om_node,
            const axis2_env_t *env);
     /**
     * Adds given node as child to parent. child should not have a parent
@@ -103,8 +124,8 @@
     * @param child child node.
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
-    axis2_status_t (AXIS2_CALL *
-    add_child) (axiom_node_t* om_node,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_node_add_child (axiom_node_t* om_node,
                 const axis2_env_t *env,
                 axiom_node_t *child);
 
@@ -115,8 +136,8 @@
     * @return a pointer to detached node,returns NULL on error with error
     *           code set to environment's error struct
     */
-    axiom_node_t  *(AXIS2_CALL *
-    detach) (axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_node_t* AXIS2_CALL 
+    axiom_node_detach (axiom_node_t  *om_node,
              const axis2_env_t *env);
 
     /**
@@ -126,8 +147,8 @@
     * @param node_to_insert the node to be inserted. , cannot be NULL.
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
-    axis2_status_t (AXIS2_CALL *
-    insert_sibling_after)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_node_insert_sibling_after(axiom_node_t  *om_node,
                           const axis2_env_t *env,
                           axiom_node_t  * node_to_insert);
 
@@ -138,8 +159,8 @@
     * @param node_to_insert the node to be inserted. , cannot be NULL.
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
-    axis2_status_t (AXIS2_CALL *
-    insert_sibling_before)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_node_insert_sibling_before(axiom_node_t  *om_node,
                            const axis2_env_t *env,
                            axiom_node_t  * node_to_insert);
 
@@ -151,10 +172,10 @@
     * @param om_output AXIOM output handler to be used in serializing
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
-    axis2_status_t (AXIS2_CALL *
-    serialize)(axiom_node_t  * om_node,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_node_serialize(axiom_node_t  * om_node,
                const axis2_env_t *env,
-              struct axiom_output *om_output);
+               struct axiom_output *om_output);
               
     /** get parent of om_node
     *@om_node node 
@@ -163,8 +184,8 @@
     *        when an error occured.
     */                                    
 
-    axiom_node_t * (AXIS2_CALL *
-    get_parent)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+    axiom_node_get_parent(axiom_node_t  *om_node,
                 const axis2_env_t *env);
 
     /**
@@ -174,8 +195,8 @@
     * @returns pointer to first child node , NULL is returned on error with 
     *                     error code set in environments error
     */
-    axiom_node_t * (AXIS2_CALL *
-    get_first_child)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+    axiom_node_get_first_child(axiom_node_t  *om_node,
                      const axis2_env_t *env);
     /**
     * get the last child
@@ -183,8 +204,8 @@
     * @param env environment, MUST NOT be NULL
     * @return pointer to last child of this node , return NULL on error.
     */                                                   
-    axiom_node_t * (AXIS2_CALL *
-    get_last_child)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+    axiom_node_get_last_child(axiom_node_t  *om_node,
                     const axis2_env_t *env);
     /**
     * get the previous sibling 
@@ -193,8 +214,8 @@
     * @returns a pointer to previous sibling , NULL if a previous sibling does not exits
     *                (happens when this node is the first child of a node )
     */                                                            
-    axiom_node_t * (AXIS2_CALL *
-    get_previous_sibling)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+    axiom_node_get_previous_sibling(axiom_node_t  *om_node,
                           const axis2_env_t *env);
     /**
     * get next sibling
@@ -202,8 +223,8 @@
     * @param env environment, MUST NOT be NULL.
     * @return next sibling of this node.
     */ 
-    axiom_node_t * (AXIS2_CALL *
-    get_next_sibling)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+    axiom_node_get_next_sibling(axiom_node_t  *om_node,
                       const axis2_env_t *env);
     /**
     * get the node type of this element
@@ -213,8 +234,8 @@
     * @param env environment
     * @return node type
     */
-    axiom_types_t (AXIS2_CALL *
-    get_node_type)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axiom_types_t AXIS2_CALL 
+    axiom_node_get_node_type(axiom_node_t  *om_node,
                    const axis2_env_t *env);
     /**
     * get the struct contained in the node
@@ -225,8 +246,8 @@
     * @returns pointer to struct contained in the node
     *          returns NULL if no struct is contained 
     */                                                
-    void* (AXIS2_CALL *
-    get_data_element)(axiom_node_t  *om_node,
+    AXIS2_EXTERN void* AXIS2_CALL 
+    axiom_node_get_data_element(axiom_node_t  *om_node,
                       const axis2_env_t *env);    
     /**
     * Indicates whether parser has parsed this information item completely or not 
@@ -235,8 +256,8 @@
     * @returns AXIS2_TRUE if node is completly build, 
     *          AXIS2_FALSE if node is not completed
     */                                                
-    axis2_bool_t (AXIS2_CALL *
-    is_complete)(axiom_node_t  *om_node,
+    AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+    axiom_node_is_complete(axiom_node_t  *om_node,
                       const axis2_env_t *env); 
    /**
     * returns the associated document,
@@ -246,85 +267,64 @@
     * @param om_node 
     * @param env environment, MUST NOT be NULL.
     */   
-    struct axiom_document* (AXIS2_CALL *
-    get_document)(axiom_node_t *om_node,
+    AXIS2_EXTERN struct axiom_document* AXIS2_CALL 
+    axiom_node_get_document(axiom_node_t *om_node,
                   const axis2_env_t *env);
                   
-    axis2_char_t* (AXIS2_CALL *
-    to_string)(axiom_node_t *om_node,
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_node_to_string(axiom_node_t *om_node,
                const axis2_env_t *env);                  
-                                                                        
-} axiom_node_ops_t;
-
-
-/**
-* This is the structure that defines a node in om tree 
-*/
-
-    struct axiom_node
-    {
-        /** ops of node struct */
-        axiom_node_ops_t *ops;
-               
-    };
-
-  /**
-    * Creates a node struct.
-    * @param env Environment. MUST NOT be NULL, .
-    * @return a pointer to newly created node struct. NULL on error. 
-    */
-AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
-axiom_node_create (const axis2_env_t *env);
+ 
 
 /** frees given node */
 #define AXIOM_NODE_FREE_TREE(om_node,env) \
-        ((om_node)->ops->free(om_node,env))
+        axiom_node_free(om_node,env)
 /** adds given child to the given parent */
 #define AXIOM_NODE_ADD_CHILD(om_node, env, child) \
-        ((om_node)->ops->add_child(om_node, env, child))
+        axiom_node_add_child(om_node, env, child)
 /** detaches the given node from its parent */
 #define AXIOM_NODE_DETACH(om_node,env) \
-        ((om_node)->ops->detach(om_node,env))
+        axiom_node_detach(om_node,env)
 /** inserts a sibling after the given node */
 #define AXIOM_NODE_INSERT_SIBLING_AFTER(om_node,env,node_to_insert) \
-        ((om_node)->ops->insert_sibling_after(om_node,env,node_to_insert))
+        axiom_node_insert_sibling_after(om_node,env,node_to_insert)
 /** inserts a sibling before the given node */
 #define AXIOM_NODE_INSERT_SIBLING_BEFORE(om_node,env,node_to_insert) \
-        ((om_node)->ops->insert_sibling_before(om_node,env,node_to_insert))
+        axiom_node_insert_sibling_before(om_node,env,node_to_insert)
 /** serialize an om_node and all its children */
 #define AXIOM_NODE_SERIALIZE(om_node,env, om_output) \
-        ((om_node)->ops->serialize(om_node,env,om_output))
+        axiom_node_serialize(om_node,env,om_output)
 /** returns parent of this om_node */   
 #define AXIOM_NODE_GET_PARENT(om_node,env) \
-        ((om_node)->ops->get_parent(om_node,env))
+        axiom_node_get_parent(om_node,env)
 /** get firet child of this om_node  */
 #define AXIOM_NODE_GET_FIRST_CHILD(om_node,env) \
-        ((om_node)->ops->get_first_child(om_node,env))
+        axiom_node_get_first_child(om_node,env)
 /**get last child  */  
 #define AXIOM_NODE_GET_LAST_CHILD(om_node,env) \
-        ((om_node)->ops->get_last_child(om_node,env))
+        axiom_node_get_last_child(om_node,env)
 /** get next sibling */  
 #define AXIOM_NODE_GET_NEXT_SIBLING(om_node,env) \
-        ((om_node)->ops->get_next_sibling(om_node,env))
+        axiom_node_get_next_sibling(om_node,env)
 /** get previous sibling */
 #define AXIOM_NODE_GET_PREVIOUS_SIBLING(om_node,env) \
-        ((om_node)->ops->get_previous_sibling(om_node,env))
+        axiom_node_get_previous_sibling(om_node,env)
 /** get build status */
 
 #define AXIOM_NODE_IS_COMPLETE(om_node,env) \
-        ((om_node)->ops->is_complete(om_node,env))
+        axiom_node_is_complete(om_node,env)
 /** get data element of this node can be om_element om_text etc */
 #define AXIOM_NODE_GET_DATA_ELEMENT(om_node,env) \
-        ((om_node)->ops->get_data_element(om_node,env))
+        axiom_node_get_data_element(om_node,env)
 /** node type one of om_node_types */
 #define AXIOM_NODE_GET_NODE_TYPE(om_node,env) \
-        ((om_node)->ops->get_node_type(om_node,env))       
+        axiom_node_get_node_type(om_node,env)       
 /** get document */        
 #define AXIOM_NODE_GET_DOCUMENT(om_node, env) \
-        ((om_node)->ops->get_document(om_node, env))
+        axiom_node_get_document(om_node, env)
 
 #define AXIOM_NODE_TO_STRING(om_node, env) \
-        ((om_node)->ops->to_string(om_node, env))        
+        axiom_node_to_string(om_node, env)        
 /** @} */
 
 #ifdef __cplusplus

Modified: webservices/axis2/trunk/c/axiom/include/axiom_output.h
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_output.h?view=diff&rev=491530&r1=491529&r2=491530
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axiom_output.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_output.h Sun Dec 31 20:16:53 2006
@@ -48,17 +48,58 @@
     typedef struct axiom_output_ops axiom_output_ops_t;
     struct axiom_text;
     
- struct axiom_output_ops
-{
+    struct axiom_output_ops
+    {
+    };  
+        
+
+    struct axiom_output
+    {
+        const axiom_output_ops_t *ops;
+    };
+    
+    
+  /**
+    * creates AXIOM output struct 
+    * @param env Environment. MUST NOT be NULL, .
+    * @param xml_writer XML writer. 
+    * @return a pointer to newly created output struct.
+    */
+
+    AXIS2_EXTERN axiom_output_t* AXIS2_CALL 
+    axiom_output_create (const axis2_env_t *env,
+                            axiom_xml_writer_t *xml_writer);
+
    /**
+    *  Performs xml writing.
+    *  Accepts variable number of args depending on the on AXIOM type to be serialized
+    *  @param om_output Output struct to be used 
+    *  @param env Environment. MUST NOT be NULL, 
+    *  @param type one of the AXIOM types
+    *  @param no_of_args number of arguments passed in the variable parameter list
+    *  @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
+    */
+
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axiom_output_write(axiom_output_t * om_output, 
+                          const axis2_env_t *env,
+                          axiom_types_t type,
+                          int no_of_args, ...);
+                      
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL
+    axiom_output_write_optimized(axiom_output_t *om_output, 
+                          const axis2_env_t *env, 
+                          struct axiom_text *om_text);
+
+    /**
     * free om_output 
     * @param om_output om_output struct
     * @param env environment
     * @return status code AXIS2_SUCCESS on success,
     *  AXIS2_FAILURE otherwise 
     */
-    axis2_status_t (AXIS2_CALL *
-   free_fn)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_free(axiom_output_t *om_output,
              const axis2_env_t *env);
     
    /**
@@ -67,70 +108,70 @@
      * @param env environment must not be NULL
      * @returns the output soap version 
      */   
-    axis2_bool_t (AXIS2_CALL *
-   is_soap11)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+    axiom_output_is_soap11(axiom_output_t *om_output,
             const axis2_env_t *env); 
    /**
-     * @returns true if the ignore_xml_declaration property is true   
+    * @returns true if the ignore_xml_declaration property is true   
     */
-   axis2_bool_t (AXIS2_CALL *
-   is_ignore_xml_declaration)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+    axiom_output_is_ignore_xml_declaration(axiom_output_t *om_output,
                         const axis2_env_t *env);                               
 
    /**
     * sets the ignore_xml_declaration property is true
     */
-   axis2_status_t (AXIS2_CALL *
-   set_ignore_xml_declaration)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_set_ignore_xml_declaration(axiom_output_t *om_output,
                          const axis2_env_t *env,
                          axis2_bool_t ignore_xml_dec); 
    /**
     * sets the soap11  property to true
     */                     
-   axis2_status_t (AXIS2_CALL *
-   set_soap11)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_set_soap11(axiom_output_t *om_output,
             const axis2_env_t *env,
             axis2_bool_t soap11);
                
    /**
      * set xml_version property
      */    
-   axis2_status_t (AXIS2_CALL *
-   set_xml_version)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_set_xml_version(axiom_output_t *om_output,
                 const axis2_env_t *env,
                 axis2_char_t *xml_version);
    /**
      * @returns xml version property
      */    
-   axis2_char_t* (AXIS2_CALL *
-   get_xml_version)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_output_get_xml_version(axiom_output_t *om_output,
                 const axis2_env_t *env);  
    /**   
      * set the char set encoding property
      */    
-   axis2_status_t (AXIS2_CALL *
-   set_char_set_encoding)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_set_char_set_encoding(axiom_output_t *om_output,
                      const axis2_env_t *env,
                      axis2_char_t *char_set_encoding);
    /**
      * @returns the char set encoding property
      */    
-   axis2_char_t* (AXIS2_CALL *
-   get_char_set_encoding)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_output_get_char_set_encoding(axiom_output_t *om_output,
                      const axis2_env_t *env); 
    /** 
      * set the do optimize property true
      */    
-   axis2_status_t (AXIS2_CALL *
-   set_do_optimize)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_set_do_optimize(axiom_output_t *om_output,
                 const axis2_env_t *env,
                 axis2_bool_t optimize); 
    
    /**
      * returns the xml writer
      */    
-   axiom_xml_writer_t* (AXIS2_CALL *
-   get_xml_writer)(axiom_output_t *om_output,
+    AXIS2_EXTERN axiom_xml_writer_t* AXIS2_CALL 
+    axiom_output_get_xml_writer(axiom_output_t *om_output,
                const axis2_env_t *env);                                                                                                                                                  /**
      *  returns the content type
      *  for soap11 'text/xml' etc..
@@ -138,145 +179,104 @@
      *  @param env environemnt
      *  @returns content id
      */     
-   const axis2_char_t* (AXIS2_CALL *
-   get_content_type)(axiom_output_t *om_output,
+    AXIS2_EXTERN const axis2_char_t* AXIS2_CALL 
+    axiom_output_get_content_type(axiom_output_t *om_output,
                  const axis2_env_t *env);
                         
    /**
      * writes the xml versio encoding 
      */    
-   axis2_status_t (AXIS2_CALL *
-   write_xml_version_encoding)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_status_t AXIS2_CALL 
+    axiom_output_write_xml_version_encoding(axiom_output_t *om_output,
                          const axis2_env_t *env);
 
     /**
      * @returns whether the output is to be optimized 
      */
-    axis2_bool_t (AXIS2_CALL *
-    is_optimized)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_bool_t AXIS2_CALL 
+    axiom_output_is_optimized(axiom_output_t *om_output,
                   const axis2_env_t *env);                               
 
     /** returns the next content id 
      */
-    axis2_char_t* (AXIS2_CALL *
-    get_next_content_id)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_output_get_next_content_id(axiom_output_t *om_output,
                          const axis2_env_t *env);
                          
     /**
      * root content id
      */                         
-    axis2_char_t* (AXIS2_CALL *
-    get_root_content_id)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_output_get_root_content_id(axiom_output_t *om_output,
                          const axis2_env_t *env);
     
     
-    axis2_char_t* (AXIS2_CALL *
-    get_mime_boundry)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_char_t* AXIS2_CALL 
+    axiom_output_get_mime_boundry(axiom_output_t *om_output,
                       const axis2_env_t *env);                       
 
-    axis2_byte_t* (AXIS2_CALL *
-    flush)(axiom_output_t *om_output,
+    AXIS2_EXTERN axis2_byte_t* AXIS2_CALL 
+    axiom_output_flush(axiom_output_t *om_output,
                       const axis2_env_t *env,
                       axis2_byte_t **output_stream,
                       int *output_stream_size);
 
-                                                  
-};  
-    
-
-struct axiom_output
-{
-    axiom_output_ops_t *ops;
-};
-    
-    
-  /**
-    * creates AXIOM output struct 
-    * @param env Environment. MUST NOT be NULL, .
-    * @param xml_writer XML writer. 
-    * @return a pointer to newly created output struct.
-    */
-
-AXIS2_EXTERN axiom_output_t* AXIS2_CALL 
-axiom_output_create (const axis2_env_t *env,
-                        axiom_xml_writer_t *xml_writer);
-
-
-   /**
-    *  Performs xml writing.
-    *  Accepts variable number of args depending on the on AXIOM type to be serialized
-    *  @param om_output Output struct to be used 
-    *  @param env Environment. MUST NOT be NULL, 
-    *  @param type one of the AXIOM types
-    *  @param no_of_args number of arguments passed in the variable parameter list
-    *  @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
-    */
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_output_write(axiom_output_t * om_output, 
-                      const axis2_env_t *env,
-                      axiom_types_t type,
-                      int no_of_args, ...);
-                      
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_output_write_optimized(axiom_output_t *om_output, 
-                      const axis2_env_t *env, 
-                      struct axiom_text *om_text);
+                     
 /************** Macros ********************************************************/
 
 #define AXIOM_OUTPUT_FREE(output, env) \
-        ((output)->ops->free_fn(output, env))
+        axiom_output_free(output, env)
         
 #define AXIOM_OUTPUT_IS_SOAP11(output, env) \
-        ((output)->ops->is_soap11(output, env))       
+        axiom_output_is_soap11(output, env)       
         
 #define AXIOM_OUTPUT_IS_IGNORE_XML_DECLARATION(output, env) \
-        ((output)->ops->is_ignore_xml_version(output, env)) 
+        axiom_output_is_ignore_xml_version(output, env) 
         
 #define AXIOM_OUTPUT_SET_IGNORE_XML_DECLARATION(output, env, xml_dec) \
-        ((output)->ops->set_ignore_xml_version(output, env, xml_dec))
+        axiom_output_set_ignore_xml_version(output, env, xml_dec)
 
 #define AXIOM_OUTPUT_SET_SOAP11(output, env, soap11) \
-        ((output)->ops->set_soap11(output, env, soap11))
+        axiom_output_set_soap11(output, env, soap11)
         
 #define AXIOM_OUTPUT_SET_XML_VERSION(output, env, xml_version) \
-        ((output)->ops->set_xml_version(output, env, xml_version))
+        axiom_output_set_xml_version(output, env, xml_version)
         
 #define AXIOM_OUTPUT_GET_XML_VERSION(output, env) \
-        ((output)->ops->get_xml_version(output, env))
+        axiom_output_get_xml_version(output, env)
         
 #define AXIOM_OUTPUT_SET_CHAR_SET_ENCODING(output, env, char_set) \
-        ((output)->ops->set_char_set_encoding(output, env, char_set))
+        axiom_output_set_char_set_encoding(output, env, char_set)
         
 #define AXIOM_OUTPUT_GET_CHAR_SET_ENCODING(output, env) \
-        ((output)->ops->get_char_set_encoding(output, env))
+        axiom_output_get_char_set_encoding(output, env)
         
 #define AXIOM_OUTPUT_SET_DO_OPTIMIZE(output, env, optimize) \
-        ((output)->ops->set_do_optimize(output, env, optimize))  
+        axiom_output_set_do_optimize(output, env, optimize)  
         
 #define AXIOM_OUTPUT_GET_XML_WRITER(output, env) \
-        ((output)->ops->get_xml_writer(output, env))
+        axiom_output_get_xml_writer(output, env)
         
 #define AXIOM_OUTPUT_GET_CONTENT_TYPE(output, env) \
-        ((output)->ops->get_content_type(output, env))                      
+        axiom_output_get_content_type(output, env)                      
 
 #define AXIOM_OUTPUT_WRITE_XML_VERSION_ENCODING(output, env) \
-        ((output)->ops->write_xml_version_encoding(output, env))
+        axiom_output_write_xml_version_encoding(output, env)
 
 #define AXIOM_OUTPUT_IS_OPTIMIZED(output, env) \
-        ((output)->ops->is_optimized(output, env))
+        axiom_output_is_optimized(output, env)
 
 #define AXIOM_OUTPUT_GET_NEXT_CONTENT_ID(om_output, env) \
-        ((om_output)->ops->get_next_content_id(om_output, env))
+        axiom_output_get_next_content_id(om_output, env)
         
 #define AXIOM_OUTPUT_GET_ROOT_CONTENT_ID(om_output, env) \
-        ((om_output)->ops->get_root_content_id(om_output, env))
+        axiom_output_get_root_content_id(om_output, env)
         
 #define AXIOM_OUTPUT_GET_MIME_BOUNDRY(om_output, env) \
-        ((om_output)->ops->get_mime_boundry(om_output, env))                
+        axiom_output_get_mime_boundry(om_output, env)                
 
 #define AXIOM_OUTPUT_FLUSH(om_output, env, output_stream, output_stream_size) \
-        ((om_output)->ops->flush(om_output, env, output_stream, output_stream_size))                
+        axiom_output_flush(om_output, env, output_stream, output_stream_size)                
 /** @} */
 
 #ifdef __cplusplus



---------------------------------------------------------------------
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