Return-Path: Delivered-To: apmail-ws-axis-dev-archive@www.apache.org Received: (qmail 66909 invoked from network); 1 Jan 2007 04:18:06 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 1 Jan 2007 04:18:05 -0000 Received: (qmail 15092 invoked by uid 500); 1 Jan 2007 04:18:09 -0000 Delivered-To: apmail-ws-axis-dev-archive@ws.apache.org Received: (qmail 14659 invoked by uid 500); 1 Jan 2007 04:18:08 -0000 Mailing-List: contact axis-cvs-help@ws.apache.org; run by ezmlm Precedence: bulk list-help: list-unsubscribe: List-Post: List-Id: Delivered-To: mailing list axis-cvs@ws.apache.org Received: (qmail 14572 invoked by uid 500); 1 Jan 2007 04:18:06 -0000 Delivered-To: apmail-ws-axis2-cvs@ws.apache.org Received: (qmail 13986 invoked by uid 99); 1 Jan 2007 04:18:04 -0000 Received: from herse.apache.org (HELO herse.apache.org) (140.211.11.133) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 31 Dec 2006 20:18:03 -0800 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received: from [140.211.11.3] (HELO eris.apache.org) (140.211.11.3) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 31 Dec 2006 20:17:53 -0800 Received: by eris.apache.org (Postfix, from userid 65534) id 995B21A981F; Sun, 31 Dec 2006 20:16:58 -0800 (PST) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit 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 -0000 To: axis2-cvs@ws.apache.org From: samisa@apache.org X-Mailer: svnmailer-1.1.0 Message-Id: <20070101041658.995B21A981F@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org 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