You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/01/01 05:16:56 UTC
svn commit: r491530 [2/4] - in /webservices/axis2/trunk/c: axiom/include/
axiom/src/om/ modules/core/deployment/
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