axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r413605 [2/10] - in /webservices/axis2/trunk/c/axiom: include/ src/attachments/ src/om/ src/soap/ src/util/ test/om/ test/soap/ test/unit/ test/unit/om/
Date Mon, 12 Jun 2006 08:23:02 GMT
Copied: webservices/axis2/trunk/c/axiom/include/axiom_element.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_element.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_element.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_element.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_element.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_element.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_element.h Mon Jun 12 01:22:58 2006
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-#ifndef AXIS2_OM_ELEMENT_H
-#define AXIS2_OM_ELEMENT_H
+#ifndef AXIOM_ELEMENT_H
+#define AXIOM_ELEMENT_H
 
-#include <axis2_om_namespace.h>
-#include <axis2_om_attribute.h>
-#include <axis2_om_output.h>
-#include <axis2_om_node.h>
-#include <axis2_om_children_iterator.h>
-#include <axis2_om_children_qname_iterator.h>
-#include <axis2_om_child_element_iterator.h>
+#include <axiom_namespace.h>
+#include <axiom_attribute.h>
+#include <axiom_output.h>
+#include <axiom_node.h>
+#include <axiom_children_iterator.h>
+#include <axiom_children_qname_iterator.h>
+#include <axiom_child_element_iterator.h>
 #include <axis2_hash.h>
 #include <axis2_utils.h>
 
@@ -32,21 +32,21 @@
 {
 #endif
 
-    typedef struct axis2_om_element axis2_om_element_t;
-    typedef struct axis2_om_element_ops axis2_om_element_ops_t;
+    typedef struct axiom_element axiom_element_t;
+    typedef struct axiom_element_ops axiom_element_ops_t;
 
 /**
- * @defgroup axis2_om_element OM Element
- * @ingroup axis2_om 
+ * @defgroup axiom_element OM Element
+ * @ingroup axiom 
  * @{
  */
 
 
     /** 
     * @brief OM element ops struct
-    * Encapsulator struct for ops of axis2_om_element
+    * Encapsulator struct for ops of axiom_element
     */
-AXIS2_DECLARE_DATA   struct axis2_om_element_ops
+AXIS2_DECLARE_DATA   struct axiom_element_ops
     {
        /*
         * Find a namespace in the scope of the document.
@@ -60,10 +60,10 @@
         * @return pointer to the namespace, if found, else NULL. On error, returns 
         *           NULL and sets error code in environment,s error
         */
-        axis2_om_namespace_t* (AXIS2_CALL *
-        find_namespace)(axis2_om_element_t *om_element,
+        axiom_namespace_t* (AXIS2_CALL *
+        find_namespace)(axiom_element_t *om_element,
                         const axis2_env_t *env,
-                        axis2_om_node_t *node,
+                        axiom_node_t *node,
                         const axis2_char_t *uri,
                         const axis2_char_t *prefix);
       /**
@@ -76,10 +76,10 @@
         * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
         */
         axis2_status_t (AXIS2_CALL *
-        declare_namespace)(axis2_om_element_t *om_element,
+        declare_namespace)(axiom_element_t *om_element,
                            const axis2_env_t *env,
-                           axis2_om_node_t *node,
-                           axis2_om_namespace_t * ns);
+                           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.
@@ -90,10 +90,10 @@
         * @return pointer to the namespace, if found, else NULL. On error, returns 
         *           NULL and sets the error code in environment's error struct.
         */
-         axis2_om_namespace_t *(AXIS2_CALL *
-         find_namespace_with_qname)(axis2_om_element_t *om_element,
+         axiom_namespace_t *(AXIS2_CALL *
+         find_namespace_with_qname)(axiom_element_t *om_element,
                                     const axis2_env_t *env,
-                                    axis2_om_node_t *node,
+                                    axiom_node_t *node,
                                     axis2_qname_t *qname);
 
       /**
@@ -101,14 +101,14 @@
         * @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 axis2_om_node_t node that om_element is contained in
+        * @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)(axis2_om_element_t *om_element,
+         add_attribute)(axiom_element_t *om_element,
                         const axis2_env_t *env,
-                        axis2_om_attribute_t *attribute,
-                        axis2_om_node_t *node);
+                        axiom_attribute_t *attribute,
+                        axiom_node_t *node);
 
       /**
         * Gets (finds) the attribute with the given qname
@@ -118,8 +118,8 @@
         * @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_om_attribute_t *(AXIS2_CALL *
-         get_attribute) (axis2_om_element_t *om_element,
+         axiom_attribute_t *(AXIS2_CALL *
+         get_attribute) (axiom_element_t *om_element,
                          const axis2_env_t *env,
                          axis2_qname_t * qname);
                          
@@ -132,7 +132,7 @@
         *  On error, returns NULL and sets the error code in environment's error struct.
         */
          axis2_char_t *(AXIS2_CALL *
-         get_attribute_value) (axis2_om_element_t *om_element,
+         get_attribute_value) (axiom_element_t *om_element,
                                const axis2_env_t *env,
                                axis2_qname_t * qname);                         
         
@@ -143,7 +143,7 @@
          * @return satus of the op. AXIS2_SUCCESS on success ,AXIS2_FAILURE on error.
         */
          axis2_status_t (AXIS2_CALL *
-         free) (axis2_om_element_t *element,
+         free) (axiom_element_t *element,
                 const axis2_env_t *env);
 
       /**
@@ -154,10 +154,10 @@
         * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
         */
         axis2_status_t (AXIS2_CALL *
-        serialize_start_part)(axis2_om_element_t *om_element,
+        serialize_start_part)(axiom_element_t *om_element,
                               const axis2_env_t *env,
-                              axis2_om_output_t * om_output,
-                              axis2_om_node_t *ele_node);
+                              axiom_output_t * om_output,
+                              axiom_node_t *ele_node);
 
       /**
         * Serializes the end part of the given element. serialize_start_part must 
@@ -168,20 +168,20 @@
         * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
         */
         axis2_status_t (AXIS2_CALL *
-        serialize_end_part)(axis2_om_element_t *om_element,
+        serialize_end_part)(axiom_element_t *om_element,
                             const axis2_env_t *env,
-                            axis2_om_output_t * om_output);
+                            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 axis2_om_namespace_t if found, else return NULL
+        * @return axiom_namespace_t if found, else return NULL
         */ 
         
-        axis2_om_namespace_t* (AXIS2_CALL *
-        find_declared_namespace)(axis2_om_element_t *om_element,
+        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);
@@ -194,7 +194,7 @@
         * @returns localname of element, returns NULL on error.
         */        
         axis2_char_t* (AXIS2_CALL *
-        get_localname)(axis2_om_element_t *om_element,
+        get_localname)(axiom_element_t *om_element,
                        const axis2_env_t *env);
        /**
         * set the localname of this element
@@ -205,21 +205,21 @@
         *                   AXIS2_FAILURE on error.
         */
         axis2_status_t (AXIS2_CALL *
-        set_localname)(axis2_om_element_t *om_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 axis2_om_namespace_t struct 
+         * @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_om_namespace_t *(AXIS2_CALL *
-        get_namespace)(axis2_om_element_t *om_element,
+        axiom_namespace_t *(AXIS2_CALL *
+        get_namespace)(axiom_element_t *om_element,
                        const axis2_env_t *env,
-                       axis2_om_node_t *ele_node);
+                       axiom_node_t *ele_node);
        /**
         * set the namespace of the element
         * @param om_element Om_element struct
@@ -229,10 +229,10 @@
         *                  set to environment's error
         */                                         
         axis2_status_t (AXIS2_CALL *
-        set_namespace)(axis2_om_element_t *om_element,
+        set_namespace)(axiom_element_t *om_element,
                        const axis2_env_t *env,
-                       axis2_om_namespace_t *ns,
-                       axis2_om_node_t *node);
+                       axiom_namespace_t *ns,
+                       axiom_node_t *node);
         /**
          * get  the attribute list of the element 
          * @param om_element om element
@@ -241,7 +241,7 @@
          * This hash table is read only 
          */
         axis2_hash_t* (AXIS2_CALL *
-        get_all_attributes)(axis2_om_element_t *om_element,
+        get_all_attributes)(axiom_element_t *om_element,
                             const axis2_env_t *env);
         /**
          * get the namespace list of the element
@@ -251,7 +251,7 @@
          * this hash table is read only
          */                                             
         axis2_hash_t* (AXIS2_CALL *
-        get_namespaces)(axis2_om_element_t *om_element,
+        get_namespaces)(axiom_element_t *om_element,
                         const axis2_env_t *env);
         /**
          *@return qname of this element
@@ -261,18 +261,18 @@
          * @returns axis2_qname_t struct , NULL on failure
          */
         axis2_qname_t* (AXIS2_CALL *
-        get_qname)(axis2_om_element_t *om_element,
+        get_qname)(axiom_element_t *om_element,
                    const axis2_env_t *env,
-                   axis2_om_node_t *ele_node);
+                   axiom_node_t *ele_node);
         
        /**
         *   returns a list of children iterator
         *   iterators free function must be called by user
         */        
-        axis2_om_children_iterator_t*(AXIS2_CALL *
-        get_children)(axis2_om_element_t *om_element,
+        axiom_children_iterator_t*(AXIS2_CALL *
+        get_children)(axiom_element_t *om_element,
                       const axis2_env_t *env,
-                     axis2_om_node_t *element_node);
+                     axiom_node_t *element_node);
                                       
        /**
         *   returns a list of children iterator with qname
@@ -285,21 +285,21 @@
         * @returns children qname iterator struct
         */        
                                                 
-        axis2_om_children_qname_iterator_t *(AXIS2_CALL *
-        get_children_with_qname)(axis2_om_element_t *om_element,
+        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,
-                                 axis2_om_node_t* element_node);
+                                 axiom_node_t* element_node);
         /**
          * returns the om_element corresponding to element_qname
          */                            
         
-        axis2_om_element_t* (AXIS2_CALL *
-        get_first_child_with_qname)(axis2_om_element_t *om_element,
+        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,
-                                     axis2_om_node_t* element_node,
-                                     axis2_om_node_t **child_node);                       
+                                     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 
@@ -311,19 +311,19 @@
          *           AXIS2_FAILURE
          */         
         axis2_status_t (AXIS2_CALL *
-        remove_attribute)(axis2_om_element_t *om_element,
+        remove_attribute)(axiom_element_t *om_element,
                           const axis2_env_t *env,
-                          axis2_om_attribute_t *om_attribute); 
+                          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)(axis2_om_element_t *om_element,
+        set_text)(axiom_element_t *om_element,
                   const axis2_env_t *env,
                   const axis2_char_t *text,
-                  axis2_om_node_t *element_node); 
+                  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
@@ -332,21 +332,21 @@
          */                                              
         axis2_char_t* (AXIS2_CALL *
         get_text)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_node_t *element_node);
+                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_om_element_t* (AXIS2_CALL *
+        axiom_element_t* (AXIS2_CALL *
         get_first_element)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_node_t *element_node,
-                axis2_om_node_t **first_element_node);  
+                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 
@@ -354,22 +354,22 @@
          */
         axis2_char_t* (AXIS2_CALL *
         to_string)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
             const axis2_env_t *env,
-            axis2_om_node_t *element_node);
+            axiom_node_t *element_node);
         /** 
-         * returns an iterator with child elements of type AXIS2_OM_ELEMENT
+         * 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 axis2_om_child_element_iterator_t , NULL on error                                             
+         * @returns axiom_child_element_iterator_t , NULL on error                                             
          */
-         axis2_om_child_element_iterator_t* (AXIS2_CALL *
+         axiom_child_element_iterator_t* (AXIS2_CALL *
          get_child_elements)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_node_t *element_node);                                                                            
+                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,
@@ -381,9 +381,9 @@
          * otherwise returns AXIS2_FAILURE
          */
          axis2_status_t (AXIS2_CALL *
-         build)(axis2_om_element_t *om_element,
+         build)(axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_node_t *element_node);
+                axiom_node_t *element_node);
                 
         /** 
          * retrieves the default namespace of this element , if available,
@@ -391,11 +391,11 @@
          * @param env axis2_environment MUST Not be NULL
          * @returns pointer to default namespace if availale , NULL otherwise
          */
-         axis2_om_namespace_t* (AXIS2_CALL *
+         axiom_namespace_t* (AXIS2_CALL *
          get_default_namespace)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_node_t *element_node);
+                axiom_node_t *element_node);
                                 
         /**
          * declared a default namespace explicitly 
@@ -404,9 +404,9 @@
          * @param uri namespace uri of the default namespace
          * @returns the declared namespace
                                                      */
-         axis2_om_namespace_t* (AXIS2_CALL *
+         axiom_namespace_t* (AXIS2_CALL *
          declare_default_namespace)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
                 axis2_char_t *uri);
                 
@@ -419,12 +419,12 @@
          * @returns pointer to relevent namespace 
          */
          
-         axis2_om_namespace_t* (AXIS2_CALL *
+         axiom_namespace_t* (AXIS2_CALL *
          find_namespace_uri)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
                 axis2_char_t *prefix,
-                axis2_om_node_t *element_node);  
+                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
@@ -434,9 +434,9 @@
          */
          axis2_status_t (AXIS2_CALL *
          set_namespace_with_no_find_in_current_scope)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_namespace_t *om_ns); 
+                axiom_namespace_t *om_ns); 
                 
         /**
          *  Extract attributes , returns a clones hash table of attributes,
@@ -444,13 +444,13 @@
          */                                                       
          axis2_hash_t* (AXIS2_CALL *
          extract_attributes)(
-                axis2_om_element_t *om_element,
+                axiom_element_t *om_element,
                 const axis2_env_t *env,
-                axis2_om_node_t *ele_node);
+                axiom_node_t *ele_node);
                 
          axis2_char_t* (AXIS2_CALL*
          get_attribute_value_by_name)(
-                axis2_om_element_t *om_ele,
+                axiom_element_t *om_ele,
                 const axis2_env_t *env,
                 axis2_char_t *attr_name);
                 
@@ -461,10 +461,10 @@
     * \brief OM element struct
     * Handles the XML element in OM
     */
-    struct axis2_om_element
+    struct axiom_element
     {
         /** ops of attribute struct */
-        axis2_om_element_ops_t *ops;
+        axiom_element_ops_t *ops;
 
     };
 
@@ -476,15 +476,15 @@
     * @param ns namespace of the element.  can be NULL.
     * @param node This is an out parameter. cannot be NULL.
     *                       Returns the node corresponding to the comment created.
-    *                       Node type will be set to AXIS2_OM_ELEMENT
+    *                       Node type will be set to AXIOM_ELEMENT
     * @return a pointer to the newly created element struct
     */
-    AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL
-    axis2_om_element_create (const axis2_env_t *env,
-                             axis2_om_node_t *parent,
+    AXIS2_EXTERN axiom_element_t * AXIS2_CALL
+    axiom_element_create (const axis2_env_t *env,
+                             axiom_node_t *parent,
                              const axis2_char_t *localname,
-                             axis2_om_namespace_t *ns,
-                             axis2_om_node_t **node);
+                             axiom_namespace_t *ns,
+                             axiom_node_t **node);
 
   /**
     * Creates an OM element with given qname
@@ -493,125 +493,125 @@
     * @param qname qname of the elment.cannot be NULL.
     * @param node This is an out parameter. cannot be NULL.
     *                       Returns the node corresponding to the comment created.
-    *                       Node type will be set to AXIS2_OM_ELEMENT
+    *                       Node type will be set to AXIOM_ELEMENT
     * @return a pointer to the newly created element struct
     */
-    AXIS2_EXTERN axis2_om_element_t * AXIS2_CALL 
-    axis2_om_element_create_with_qname (const axis2_env_t *env,
-                                        axis2_om_node_t *parent,
+    AXIS2_EXTERN axiom_element_t * AXIS2_CALL 
+    axiom_element_create_with_qname (const axis2_env_t *env,
+                                        axiom_node_t *parent,
                                         const axis2_qname_t *qname,
-                                        axis2_om_node_t ** node);
+                                        axiom_node_t ** node);
 
 /** finds given namespace with respect to given node */
-#define AXIS2_OM_ELEMENT_FIND_NAMESPACE(om_element,env,om_node, uri, prefix) \
+#define AXIOM_ELEMENT_FIND_NAMESPACE(om_element,env,om_node, uri, prefix) \
         ((om_element)->ops->find_namespace (om_element, env,om_node, uri, prefix))
         
 /** declares given namespace with respect to the given node */
-#define AXIS2_OM_ELEMENT_DECLARE_NAMESPACE(om_element, env , om_node, ns) \
+#define AXIOM_ELEMENT_DECLARE_NAMESPACE(om_element, env , om_node, ns) \
         ((om_element)->ops->declare_namespace (om_element, env, om_node, ns))
 
 /** finds namespace with given qname */
-#define AXIS2_OM_ELEMENT_FIND_NAMESPACE_WITH_QNAME (om_element, env, om_node, 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))
         
 /** adds given attribute to given element */
-#define AXIS2_OM_ELEMENT_ADD_ATTRIBUTE(om_element, env, attribute, element_node) \
+#define AXIOM_ELEMENT_ADD_ATTRIBUTE(om_element, env, attribute, element_node) \
         ((om_element)->ops->add_attribute(om_element , env, attribute, element_node))
         
 /** gets (finds) given attribute in given element */
-#define AXIS2_OM_ELEMENT_GET_ATTRIBUTE(om_element, env, qname) \
+#define AXIOM_ELEMENT_GET_ATTRIBUTE(om_element, env, qname) \
         ((om_element)->ops->get_attribute(om_element, env, qname))
         
 /** free an om element */
-#define AXIS2_OM_ELEMENT_FREE(om_element, env) \
+#define AXIOM_ELEMENT_FREE(om_element, env) \
         ((om_element)->ops->free(om_element, env))
         
 /** serialize the start part of given element */
-#define AXIS2_OM_ELEMENT_SERIALIZE_START_PART(om_element, env, om_output, ele_node) \
+#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))
         
 /** serialize the end part of given element */
-#define AXIS2_OM_ELEMENT_SERIALIZE_END_PART(om_element, env, om_output) \
+#define AXIOM_ELEMENT_SERIALIZE_END_PART(om_element, env, om_output) \
         ((om_element)->ops->serialize_end_part(om_element, env, om_output))
 /** get localname */
-#define AXIS2_OM_ELEMENT_GET_LOCALNAME(om_element, env)\
+#define AXIOM_ELEMENT_GET_LOCALNAME(om_element, env)\
         ((om_element)->ops->get_localname(om_element,env))
 /** get namespace of this element */        
-#define AXIS2_OM_ELEMENT_GET_NAMESPACE(om_element, env, ele_node) \
+#define AXIOM_ELEMENT_GET_NAMESPACE(om_element, env, ele_node) \
         ((om_element)->ops->get_namespace(om_element, env, ele_node))
 /** set localname */        
-#define AXIS2_OM_ELEMENT_SET_LOCALNAME(om_element, env, localname) \
+#define AXIOM_ELEMENT_SET_LOCALNAME(om_element, env, localname) \
         ((om_element)->ops->set_localname(om_element, env, localname))
 /** set namespace */        
-#define AXIS2_OM_ELEMENT_SET_NAMESPACE(om_element, env, ns , node) \
+#define AXIOM_ELEMENT_SET_NAMESPACE(om_element, env, ns , node) \
         ((om_element)->ops->set_namespace(om_element, env, ns, node))
 
-#define AXIS2_OM_ELEMENT_FIND_DECLARED_NAMESPACE(om_element, env, uri, prefix) \
+#define AXIOM_ELEMENT_FIND_DECLARED_NAMESPACE(om_element, env, uri, prefix) \
         ((om_element)->ops->find_declared_namespace(om_element, env, uri, prefix))        
         
-#define AXIS2_OM_ELEMENT_GET_QNAME(om_element, env, ele_node) \
+#define AXIOM_ELEMENT_GET_QNAME(om_element, env, ele_node) \
         ((om_element)->ops->get_qname(om_element, env, ele_node))
 
-#define AXIS2_OM_ELEMENT_GET_ALL_ATTRIBUTES(om_element, env) \
+#define AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(om_element, env) \
         ((om_element)->ops->get_all_attributes(om_element, env))
 
-#define AXIS2_OM_ELEMENT_GET_NAMESPACES(om_element, env) \
+#define AXIOM_ELEMENT_GET_NAMESPACES(om_element, env) \
         ((om_element)->ops->get_namespaces(om_element, env)) 
         
-#define AXIS2_OM_ELEMENT_GET_CHILDREN(om_element, env, element_node) \
+#define AXIOM_ELEMENT_GET_CHILDREN(om_element, env, element_node) \
         ((om_element)->ops->get_children(om_element, env, element_node))
 
-#define AXIS2_OM_ELEMENT_GET_CHILDREN_WITH_QNAME(om_element, env, \
+#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))
 
-#define AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(om_element, env,\
+#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))
 
-#define AXIS2_OM_ELEMENT_REMOVE_ATTRIBUTE(om_element, env, om_attribute) \
+#define AXIOM_ELEMENT_REMOVE_ATTRIBUTE(om_element, env, om_attribute) \
         ((om_element)->ops->remove_attribute(om_element, env, om_attribute))
 
-#define AXIS2_OM_ELEMENT_GET_FIRST_ELEMENT(om_element, env, element_node, first_node) \
+#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))
 
-#define AXIS2_OM_ELEMENT_GET_TEXT(om_element, env, element_node) \
+#define AXIOM_ELEMENT_GET_TEXT(om_element, env, element_node) \
         ((om_element)->ops->get_text(om_element, env, element_node))
 
-#define AXIS2_OM_ELEMENT_SET_TEXT(om_element, env, text, element_node) \
+#define AXIOM_ELEMENT_SET_TEXT(om_element, env, text, element_node) \
         ((om_element)->ops->set_text(om_element, env, text, element_node))
 
-#define AXIS2_OM_ELEMENT_TO_STRING(om_element, env, element_node) \
+#define AXIOM_ELEMENT_TO_STRING(om_element, env, element_node) \
         ((om_element)->ops->to_string(om_element, env, element_node)) 
                
-#define AXIS2_OM_ELEMENT_GET_CHILD_ELEMENTS(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))
 
-#define AXIS2_OM_ELEMENT_BUILD(om_element, env, element_node) \
+#define AXIOM_ELEMENT_BUILD(om_element, env, element_node) \
         ((om_element)->ops->build(om_element, env, element_node))
         
-#define AXIS2_OM_ELEMENT_GET_DEFAULT_NAMESPACE(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))
         
-#define AXIS2_OM_ELEMENT_DECLARE_DEFAULT_NAMESPACE(om_element, env, uri) \
+#define AXIOM_ELEMENT_DECLARE_DEFAULT_NAMESPACE(om_element, env, uri) \
         ((om_element)->ops->declare_default_namespace(om_element, env, uri))
         
-#define AXIS2_OM_ELEMENT_FIND_NAMESPACE_URI(om_element, env, prefix, element_node) \
+#define AXIOM_ELEMENT_FIND_NAMESPACE_URI(om_element, env, prefix, element_node) \
         ((om_element)->ops->find_namespace_uri(om_element, env, prefix, element_node))
         
-#define AXIS2_OM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, qname) \
+#define AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE(om_element, env, qname) \
         ((om_element)->ops->get_attribute_value(om_element, env, qname))
 
-#define AXIS2_OM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(om_element, env, attr_name) \
+#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))
         
                 
-#define AXIS2_OM_ELEMENT_SET_NAMESPACE_WITH_NO_FIND_IN_CURRENT_SCOPE(om_element, env, om_ns) \
+#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))
                
-#define AXIS2_OM_ELEMENT_EXTRACT_ATTRIBUTES(om_element, env, ele_node) \
+#define AXIOM_ELEMENT_EXTRACT_ATTRIBUTES(om_element, env, ele_node) \
         ((om_element)->ops->extract_attributes(om_element, env, ele_node))
         
 
@@ -623,4 +623,4 @@
 }
 #endif
 
-#endif    /* AXIS2_OM_ELEMENT_H */
+#endif    /* AXIOM_ELEMENT_H */

Copied: webservices/axis2/trunk/c/axiom/include/axiom_namespace.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_namespace.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_namespace.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_namespace.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_namespace.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_namespace.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_namespace.h Mon Jun 12 01:22:58 2006
@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#ifndef AXIS2_OM_NAMESPACE_H
-#define AXIS2_OM_NAMESPACE_H
+#ifndef AXIOM_NAMESPACE_H
+#define AXIOM_NAMESPACE_H
 
 /**
- * @file axis2_om_namespace.h
- * @brief defines axis2_om_namespace data structure,
+ * @file axiom_namespace.h
+ * @brief defines axiom_namespace data structure,
  *        used for representing XML namespaces in OM
  */
 
 #include <axis2_utils_defines.h>
 #include <axis2_env.h>
-#include <axis2_om_output.h>
+#include <axiom_output.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-    struct axis2_om_namespace;
-    struct axis2_om_namespace_ops;
+    struct axiom_namespace;
+    struct axiom_namespace_ops;
     
 /**
- * @defgroup axis2_om_namespace OM Namespace
- * @ingroup axis2_om 
+ * @defgroup axiom_namespace OM Namespace
+ * @ingroup axiom 
  * @{
  */
 
   /** 
     * \brief OM Namespace ops struct
-    * Encapsulator struct for ops of axis2_om_namespace
+    * Encapsulator struct for ops of axiom_namespace
     */
- AXIS2_DECLARE_DATA   typedef struct axis2_om_namespace_ops
+ AXIS2_DECLARE_DATA   typedef struct axiom_namespace_ops
     {
       /**
         * Frees given OM namespcae
@@ -54,7 +54,7 @@
         * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
         */
         axis2_status_t (AXIS2_CALL *
-        free) (struct axis2_om_namespace *om_namespace,
+        free) (struct axiom_namespace *om_namespace,
                const axis2_env_t *env);
 
       /**
@@ -65,9 +65,9 @@
         * @return AXIS2_TRUE if the two namespaces are equal,AXIS2_FALSE otherwise
         */
         axis2_bool_t (AXIS2_CALL *
-        equals)(struct axis2_om_namespace *om_namespace,
+        equals)(struct axiom_namespace *om_namespace,
                 const axis2_env_t *env,
-                struct axis2_om_namespace *om_namespace1);
+                struct axiom_namespace *om_namespace1);
 
       /**
         * Serializes given namespace 
@@ -77,16 +77,16 @@
         * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
         */
         axis2_status_t (AXIS2_CALL *
-        serialize)(struct axis2_om_namespace *om_namespace,
+        serialize)(struct axiom_namespace *om_namespace,
                    const axis2_env_t *env,
-                   axis2_om_output_t * om_output);
+                   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 axis2_om_namespace *om_namespace,
+        get_uri)(struct axiom_namespace *om_namespace,
                  const axis2_env_t *env);
        /**   
         *@param om_namespace pointer to om namespace struct
@@ -94,7 +94,7 @@
         *@return prefix , NULL on error
         */
         axis2_char_t* (AXIS2_CALL *
-        get_prefix)(struct axis2_om_namespace *om_namespace,
+        get_prefix)(struct axiom_namespace *om_namespace,
                     const axis2_env_t *env);
 
 
@@ -102,10 +102,10 @@
          * clones an om_namespace struct
          * @param om_namespace pointer to namespace struct
          * @param env environment
-         * @returns axis2_om_namespace on success , NULL on error
+         * @returns axiom_namespace on success , NULL on error
          */
-        struct axis2_om_namespace* (AXIS2_CALL *
-        clone)(struct axis2_om_namespace *om_namespace,
+        struct axiom_namespace* (AXIS2_CALL *
+        clone)(struct axiom_namespace *om_namespace,
                const axis2_env_t *env);
                
         /**
@@ -117,21 +117,21 @@
          * should not be freed by user
          */                                                                                     
         axis2_char_t * (AXIS2_CALL *
-        to_string)(struct axis2_om_namespace *om_namespace,
+        to_string)(struct axiom_namespace *om_namespace,
                    const axis2_env_t *env);
 
-    } axis2_om_namespace_ops_t;
+    } axiom_namespace_ops_t;
 
   /** 
     * \brief OM namespace struct
     * Handles the XML namespace in OM
     */
-    typedef struct axis2_om_namespace
+    typedef struct axiom_namespace
     {
         /** OM namespace related ops */
-        axis2_om_namespace_ops_t *ops;
+        axiom_namespace_ops_t *ops;
         
-    } axis2_om_namespace_t;
+    } axiom_namespace_t;
 
   /**
     * Creates a namespace struct
@@ -139,33 +139,33 @@
     * @param prefix namespace prefix
     * @return a pointer to newly created namespace struct
     */
-    AXIS2_EXTERN axis2_om_namespace_t * AXIS2_CALL
-    axis2_om_namespace_create (const axis2_env_t *env,
+    AXIS2_EXTERN axiom_namespace_t * AXIS2_CALL
+    axiom_namespace_create (const axis2_env_t *env,
                                const axis2_char_t * uri,
                                const axis2_char_t *prefix);
 
 /** frees given namespace */
-#define AXIS2_OM_NAMESPACE_FREE(om_namespace,env) \
+#define AXIOM_NAMESPACE_FREE(om_namespace,env) \
         ((om_namespace)->ops->free(om_namespace, env))
         
 /** compares the given two namespaces for equality */
-#define AXIS2_OM_NAMESPACE_EQUALS(om_namespace, env, om_namespace1) \
+#define AXIOM_NAMESPACE_EQUALS(om_namespace, env, om_namespace1) \
         ((om_namespace)->ops->equals(om_namespace, env, om_namespace1))
         
 /** serializes given namespace */
-#define AXIS2_OM_NAMESPACE_SERIALIZE(om_namespace,env, om_output) \
+#define AXIOM_NAMESPACE_SERIALIZE(om_namespace,env, om_output) \
         ((om_namespace)->ops->serialize(om_namespace, env,om_output))
 /** get prefix */        
-#define AXIS2_OM_NAMESPACE_GET_PREFIX(om_namespace, env) \
+#define AXIOM_NAMESPACE_GET_PREFIX(om_namespace, env) \
         ((om_namespace)->ops->get_prefix(om_namespace, env))
 /** get namespace uri */
-#define AXIS2_OM_NAMESPACE_GET_URI(om_namespace, env) \
+#define AXIOM_NAMESPACE_GET_URI(om_namespace, env) \
         ((om_namespace)->ops->get_uri(om_namespace, env))
 /** clones a namespace */
-#define AXIS2_OM_NAMESPACE_CLONE(om_namespace, env) \
+#define AXIOM_NAMESPACE_CLONE(om_namespace, env) \
         ((om_namespace)->ops->clone(om_namespace, env))
 /** returns a string from namespace */
-#define AXIS2_OM_NAMESPACE_TO_STRING(om_namespace, env) \
+#define AXIOM_NAMESPACE_TO_STRING(om_namespace, env) \
         ((om_namespace)->ops->to_string(om_namespace, env))
 
 /** @} */
@@ -174,4 +174,4 @@
 }
 #endif
 
-#endif                          /* AXIS2_OM_NAMESPACE */
+#endif                          /* AXIOM_NAMESPACE */

Copied: webservices/axis2/trunk/c/axiom/include/axiom_navigator.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_navigator.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_navigator.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_navigator.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_navigator.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_navigator.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_navigator.h Mon Jun 12 01:22:58 2006
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
  
- #ifndef AXIS2_OM_NAVIGATOR_H
- #define AXIS2_OM_NAVIGATOR_H
+ #ifndef AXIOM_NAVIGATOR_H
+ #define AXIOM_NAVIGATOR_H
  
-/** @defgroup axis2_om AXIOM (Axis Object Model)
+/** @defgroup axiom AXIOM (Axis Object Model)
  * @ingroup axis2
  * @{
  */
@@ -25,13 +25,13 @@
 /** @} */
       
 /**
- * @file axis2_om_navigator.h
- * @brief defines axis2_om_navigator struct and its ops
+ * @file axiom_navigator.h
+ * @brief defines axiom_navigator struct and its ops
  */
 
 #include <axis2_utils.h>
 #include <axis2_env.h>
-#include <axis2_om_node.h>
+#include <axiom_node.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -39,71 +39,71 @@
 #endif
 
 /**
- * @defgroup axis2_om_navigator  om_navigator 
- * @ingroup axis2_om
+ * @defgroup axiom_navigator  om_navigator 
+ * @ingroup axiom
  * @{
  */
  
- typedef struct axis2_om_navigator axis2_om_navigator_t;
+ typedef struct axiom_navigator axiom_navigator_t;
 
- typedef struct axis2_om_navigator_ops axis2_om_navigator_ops_t;
+ typedef struct axiom_navigator_ops axiom_navigator_ops_t;
  
 /**
  * @brief OM Node ops struct
- * Encapsulator struct for ops of axis2_om_node
+ * Encapsulator struct for ops of axiom_node
  */
  
- struct axis2_om_navigator_ops 
+ struct axiom_navigator_ops 
  {
     /**
-     * free function , free the axis2_om_navigator struct
-     * @param om_navigator axis2_om_navigator_struct
+     * free function , free the axiom_navigator struct
+     * @param om_navigator axiom_navigator_struct
      * @param env environment MUST not be NULL
      * @returns AXIS2_SUCCESS 
      */
      
      axis2_status_t (AXIS2_CALL *
-     free)(axis2_om_navigator_t *om_navigator,
+     free)(axiom_navigator_t *om_navigator,
            const axis2_env_t *env); 
  
     /**
      *  returns the navigable status 
-     * @param  om_navigator axis2_om_navigator_struct
+     * @param  om_navigator axiom_navigator_struct
      * @param env environment MUST not be NULL
      * @returns AXIS2_TRUE if the om is navigable 
      * otherwise returns AXIS2_FALSE
      */
 
      axis2_bool_t (AXIS2_CALL *
-     is_navigable)(axis2_om_navigator_t *om_navigator,
+     is_navigable)(axiom_navigator_t *om_navigator,
                    const axis2_env_t *env);
 
     /**
      * returns the build status of this node 
      * if the node is completly build returns AXIS2_TRUE
      * otherwise AXIS2_FALSE
-     * @param om_navigator axis2_om_navigator struct
+     * @param om_navigator axiom_navigator struct
      * @param env environment MUST not be NULL
      * @return AXIS2_TRUE if this node is completly built
      * otherwise return AXIS2_FALSE
      */
      
      axis2_bool_t (AXIS2_CALL *
-     is_completed)(axis2_om_navigator_t *om_navigator,
+     is_completed)(axiom_navigator_t *om_navigator,
                         const axis2_env_t *env);
 
     /**
      * gets the next node 
      * @param om_navigator om_navigaot struct 
      * @param env environment MUST not be NULL
-     * @returns axis2_om_node_t pointer in the sequence of preorder travasal 
+     * @returns axiom_node_t pointer in the sequence of preorder travasal 
      * however the an element node is treated slightly differently
      * Once the om_element type om node is passed it returns the same om_node 
      * pointer in the next , returns NULL on error or if there is no more nodes
      */
 
-     axis2_om_node_t* (AXIS2_CALL *
-     next)(axis2_om_navigator_t *om_navigator, 
+     axiom_node_t* (AXIS2_CALL *
+     next)(axiom_navigator_t *om_navigator, 
            const axis2_env_t *env);
 
     /**
@@ -114,45 +114,45 @@
      * otherwise AXIS2_FALSE
      */
      axis2_bool_t (AXIS2_CALL *
-     visited)(axis2_om_navigator_t *om_navigator,
+     visited)(axiom_navigator_t *om_navigator,
               const axis2_env_t *env);
 
  };
     
-/** axis2_om_navigator_t struct */
+/** axiom_navigator_t struct */
 
-struct axis2_om_navigator
+struct axiom_navigator
 {
-    axis2_om_navigator_ops_t *ops;
+    axiom_navigator_ops_t *ops;
 };
 
-/** create an axis2_om_navigator 
+/** create an axiom_navigator 
  * @param env environment MUST not be NULL
- * @param node a pointer to axis2_om_node_t struct 
+ * @param node a pointer to axiom_node_t struct 
  * which is to be navigated
- * @returns a pointer to axis2_om_navigator_t struct
+ * @returns a pointer to axiom_navigator_t struct
  * or returns NULL on error
  */
 
-AXIS2_EXTERN axis2_om_navigator_t * AXIS2_CALL
-axis2_om_navigator_create(const axis2_env_t *env,
-                          axis2_om_node_t *node);
+AXIS2_EXTERN axiom_navigator_t * AXIS2_CALL
+axiom_navigator_create(const axis2_env_t *env,
+                          axiom_node_t *node);
                           
 /** Macros ********************************************************************/
 
-#define AXIS2_OM_NAVIGATOR_FREE(navigator, env) \
+#define AXIOM_NAVIGATOR_FREE(navigator, env) \
         ((navigator)->ops->free(navigator, env))
 
-#define AXIS2_OM_NAVIGATOR_IS_NAVIGABLE(navigator, env) \
+#define AXIOM_NAVIGATOR_IS_NAVIGABLE(navigator, env) \
         ((navigator)->ops->is_navigable(navigator, env))
 
-#define AXIS2_OM_NAVIGATOR_IS_COMPLETED(navigator, env) \
+#define AXIOM_NAVIGATOR_IS_COMPLETED(navigator, env) \
         ((navigator)->ops->is_completed(navigator, env))
 
-#define AXIS2_OM_NAVIGATOR_VISITED(navigator, env) \
+#define AXIOM_NAVIGATOR_VISITED(navigator, env) \
         ((navigator)->ops->visited(navigator, env))
 
-#define AXIS2_OM_NAVIGATOR_NEXT(navigator, env) \
+#define AXIOM_NAVIGATOR_NEXT(navigator, env) \
         ((navigator)->ops->next(navigator, env))
 
 /** @} */
@@ -161,4 +161,4 @@
 }
 #endif
 
-#endif /* AXIS2_OM_NAVIGATOR_H */
+#endif /* AXIOM_NAVIGATOR_H */

Copied: webservices/axis2/trunk/c/axiom/include/axiom_node.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_node.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_node.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_node.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_node.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_node.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_node.h Mon Jun 12 01:22:58 2006
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#ifndef AXIS2_OM_NODE_H
-#define AXIS2_OM_NODE_H
+#ifndef AXIOM_NODE_H
+#define AXIOM_NODE_H
 
-/** @defgroup axis2_om AXIOM (Axis Object Model)
+/** @defgroup axiom AXIOM (Axis Object Model)
   * @ingroup axis2
   * @{
   */
@@ -25,8 +25,8 @@
 /** @} */
 
 /**
- * @file axis2_om_node.h
- * @brief defines axis2_om_node struct and its ops
+ * @file axiom_node.h
+ * @brief defines axiom_node struct and its ops
  */
 #include <axis2_env.h>
 #include <axis2_utils.h>
@@ -37,47 +37,47 @@
 {
 #endif
 
-    typedef struct axis2_om_node axis2_om_node_t;
-    struct axis2_om_node_ops;
-    struct axis2_om_output;
-    struct axis2_om_document;
-    struct axis2_om_stax_builder;
+    typedef struct axiom_node axiom_node_t;
+    struct axiom_node_ops;
+    struct axiom_output;
+    struct axiom_document;
+    struct axiom_stax_builder;
 /**
- * @defgroup axis2_om_node  OM Node
- * @ingroup axis2_om 
+ * @defgroup axiom_node  OM Node
+ * @ingroup axiom 
  * @{
  */
 
   /** 
     * @brief OM types
     */
-    typedef enum axis2_om_types_t
+    typedef enum axiom_types_t
     {
         /** Invalid node type */
-        AXIS2_OM_INVALID = 0,
+        AXIOM_INVALID = 0,
         /** OM document type */
-        AXIS2_OM_DOCUMENT,
+        AXIOM_DOCUMENT,
         /** OM element type */
-        AXIS2_OM_ELEMENT,
+        AXIOM_ELEMENT,
         /** OM doctype type */
-        AXIS2_OM_DOCTYPE,
+        AXIOM_DOCTYPE,
         /** OM comment type */
-        AXIS2_OM_COMMENT,
+        AXIOM_COMMENT,
         /** OM attribute type */
-        AXIS2_OM_ATTRIBUTE,
+        AXIOM_ATTRIBUTE,
         /** OM namespace type */
-        AXIS2_OM_NAMESPACE,
+        AXIOM_NAMESPACE,
         /** OM processing instruction type */
-        AXIS2_OM_PROCESSING_INSTRUCTION,
+        AXIOM_PROCESSING_INSTRUCTION,
         /** OM text type */
-        AXIS2_OM_TEXT
-    } axis2_om_types_t;
+        AXIOM_TEXT
+    } axiom_types_t;
 
   /** 
     * @brief OM Node ops struct
-    * Encapsulator struct for ops of axis2_om_node
+    * Encapsulator struct for ops of axiom_node
     */
-AXIS2_DECLARE_DATA   typedef struct axis2_om_node_ops
+AXIS2_DECLARE_DATA   typedef struct axiom_node_ops
 {
     /**
     * Frees an om node and all of its children
@@ -86,7 +86,7 @@
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
     axis2_status_t (AXIS2_CALL *
-    free) (axis2_om_node_t *om_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
@@ -97,9 +97,9 @@
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
     axis2_status_t (AXIS2_CALL *
-    add_child) (axis2_om_node_t* om_node,
+    add_child) (axiom_node_t* om_node,
                 const axis2_env_t *env,
-                axis2_om_node_t *child);
+                axiom_node_t *child);
 
     /**
     * Detaches given node from the parent and reset the links
@@ -108,8 +108,8 @@
     * @return a pointer to detached node,returns NULL on error with error
     *           code set to environment's error struct
     */
-    axis2_om_node_t  *(AXIS2_CALL *
-    detach) (axis2_om_node_t  *om_node,
+    axiom_node_t  *(AXIS2_CALL *
+    detach) (axiom_node_t  *om_node,
              const axis2_env_t *env);
 
     /**
@@ -120,9 +120,9 @@
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
     axis2_status_t (AXIS2_CALL *
-    insert_sibling_after)(axis2_om_node_t  *om_node,
+    insert_sibling_after)(axiom_node_t  *om_node,
                           const axis2_env_t *env,
-                          axis2_om_node_t  * node_to_insert);
+                          axiom_node_t  * node_to_insert);
 
     /**
     * Inserts a sibling node before the given current node
@@ -132,9 +132,9 @@
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
     axis2_status_t (AXIS2_CALL *
-    insert_sibling_before)(axis2_om_node_t  *om_node,
+    insert_sibling_before)(axiom_node_t  *om_node,
                            const axis2_env_t *env,
-                           axis2_om_node_t  * node_to_insert);
+                           axiom_node_t  * node_to_insert);
 
     /**
     * Serializes the given node. This op makes the node go
@@ -145,9 +145,9 @@
     * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE
     */
     axis2_status_t (AXIS2_CALL *
-    serialize)(axis2_om_node_t  * om_node,
+    serialize)(axiom_node_t  * om_node,
                const axis2_env_t *env,
-              struct axis2_om_output *om_output);
+              struct axiom_output *om_output);
               
     /** get parent of om_node
     *@om_node node 
@@ -156,8 +156,8 @@
     *        when an error occured.
     */                                    
 
-    axis2_om_node_t * (AXIS2_CALL *
-    get_parent)(axis2_om_node_t  *om_node,
+    axiom_node_t * (AXIS2_CALL *
+    get_parent)(axiom_node_t  *om_node,
                 const axis2_env_t *env);
 
     /**
@@ -167,8 +167,8 @@
     * @returns pointer to first child node , NULL is returned on error with 
     *                     error code set in environments error
     */
-    axis2_om_node_t * (AXIS2_CALL *
-    get_first_child)(axis2_om_node_t  *om_node,
+    axiom_node_t * (AXIS2_CALL *
+    get_first_child)(axiom_node_t  *om_node,
                      const axis2_env_t *env);
     /**
     * get the last child
@@ -176,8 +176,8 @@
     * @param env environment, MUST NOT be NULL
     * @return pointer to last child of this node , return NULL on error.
     */                                                   
-    axis2_om_node_t * (AXIS2_CALL *
-    get_last_child)(axis2_om_node_t  *om_node,
+    axiom_node_t * (AXIS2_CALL *
+    get_last_child)(axiom_node_t  *om_node,
                     const axis2_env_t *env);
     /**
     * get the previous sibling 
@@ -186,8 +186,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 )
     */                                                            
-    axis2_om_node_t * (AXIS2_CALL *
-    get_previous_sibling)(axis2_om_node_t  *om_node,
+    axiom_node_t * (AXIS2_CALL *
+    get_previous_sibling)(axiom_node_t  *om_node,
                           const axis2_env_t *env);
     /**
     * get next sibling
@@ -195,31 +195,31 @@
     * @param env environment, MUST NOT be NULL.
     * @return next sibling of this node.
     */ 
-    axis2_om_node_t * (AXIS2_CALL *
-    get_next_sibling)(axis2_om_node_t  *om_node,
+    axiom_node_t * (AXIS2_CALL *
+    get_next_sibling)(axiom_node_t  *om_node,
                       const axis2_env_t *env);
     /**
     * get the node type of this element
-    * Node type can be one of AXIS2_OM_ELEMENT, AXIS2_OM_COMMENT, AXIS2_OM_TEXT
-    *      AXIS2_OM_DOCTYPE, AXIS2_OM_PROCESSING_INSTRUCTION
+    * Node type can be one of AXIOM_ELEMENT, AXIOM_COMMENT, AXIOM_TEXT
+    *      AXIOM_DOCTYPE, AXIOM_PROCESSING_INSTRUCTION
     * @param om_node  node of which node type is required
     * @param env environment
     * @return node type
     */
-    axis2_om_types_t (AXIS2_CALL *
-    get_node_type)(axis2_om_node_t  *om_node,
+    axiom_types_t (AXIS2_CALL *
+    get_node_type)(axiom_node_t  *om_node,
                    const axis2_env_t *env);
     /**
     * get the struct contained in the node
-    * IF the node is on type AXIS2_OM_ELEMENT , this method returns
-    * a pointer to  axis2_om_element_t struct contained
+    * IF the node is on type AXIOM_ELEMENT , this method returns
+    * a pointer to  axiom_element_t struct contained
     * @param om_node node
     * @param env environment, MUST NOT be NULL.
     * @returns pointer to struct contained in the node
     *          returns NULL if no struct is contained 
     */                                                
     void* (AXIS2_CALL *
-    get_data_element)(axis2_om_node_t  *om_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 
@@ -229,35 +229,35 @@
     *          AXIS2_FALSE if node is not completed
     */                                                
     axis2_bool_t (AXIS2_CALL *
-    is_complete)(axis2_om_node_t  *om_node,
+    is_complete)(axiom_node_t  *om_node,
                       const axis2_env_t *env); 
    /**
     * returns the associated document,
     * only valid if built using builder and for a node of type 
-    * AXIS2_OM_ELEMENT
+    * AXIOM_ELEMENT
     * returns null if no document is available
     * @param om_node 
     * @param env environment, MUST NOT be NULL.
     */   
-    struct axis2_om_document* (AXIS2_CALL *
-    get_document)(axis2_om_node_t *om_node,
+    struct axiom_document* (AXIS2_CALL *
+    get_document)(axiom_node_t *om_node,
                   const axis2_env_t *env);
                   
     axis2_char_t* (AXIS2_CALL *
-    to_string)(axis2_om_node_t *om_node,
+    to_string)(axiom_node_t *om_node,
                const axis2_env_t *env);                  
                                                                         
-} axis2_om_node_ops_t;
+} axiom_node_ops_t;
 
 
 /**
 * This is the structure that defines a node in om tree 
 */
 
-    struct axis2_om_node
+    struct axiom_node
     {
         /** ops of node struct */
-        axis2_om_node_ops_t *ops;
+        axiom_node_ops_t *ops;
                
     };
 
@@ -266,57 +266,57 @@
     * @param env Environment. MUST NOT be NULL, .
     * @return a pointer to newly created node struct. NULL on error. 
     */
-AXIS2_EXTERN axis2_om_node_t * AXIS2_CALL 
-axis2_om_node_create (const axis2_env_t *env);
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL 
+axiom_node_create (const axis2_env_t *env);
 
 /** frees given node */
-#define AXIS2_OM_NODE_FREE_TREE(om_node,env) \
+#define AXIOM_NODE_FREE_TREE(om_node,env) \
         ((om_node)->ops->free(om_node,env))
 /** adds given child to the given parent */
-#define AXIS2_OM_NODE_ADD_CHILD(om_node, env, child) \
+#define AXIOM_NODE_ADD_CHILD(om_node, env, child) \
         ((om_node)->ops->add_child(om_node, env, child))
 /** detaches the given node from its parent */
-#define AXIS2_OM_NODE_DETACH(om_node,env) \
+#define AXIOM_NODE_DETACH(om_node,env) \
         ((om_node)->ops->detach(om_node,env))
 /** inserts a sibling after the given node */
-#define AXIS2_OM_NODE_INSERT_SIBLING_AFTER(om_node,env,node_to_insert) \
+#define AXIOM_NODE_INSERT_SIBLING_AFTER(om_node,env,node_to_insert) \
         ((om_node)->ops->insert_sibling_after(om_node,env,node_to_insert))
 /** inserts a sibling before the given node */
-#define AXIS2_OM_NODE_INSERT_SIBLING_BEFORE(om_node,env,node_to_insert) \
+#define AXIOM_NODE_INSERT_SIBLING_BEFORE(om_node,env,node_to_insert) \
         ((om_node)->ops->insert_sibling_before(om_node,env,node_to_insert))
 /** serialize an om_node and all its children */
-#define AXIS2_OM_NODE_SERIALIZE(om_node,env, om_output) \
+#define AXIOM_NODE_SERIALIZE(om_node,env, om_output) \
         ((om_node)->ops->serialize(om_node,env,om_output))
 /** returns parent of this om_node */   
-#define AXIS2_OM_NODE_GET_PARENT(om_node,env) \
+#define AXIOM_NODE_GET_PARENT(om_node,env) \
         ((om_node)->ops->get_parent(om_node,env))
 /** get firet child of this om_node  */
-#define AXIS2_OM_NODE_GET_FIRST_CHILD(om_node,env) \
+#define AXIOM_NODE_GET_FIRST_CHILD(om_node,env) \
         ((om_node)->ops->get_first_child(om_node,env))
 /**get last child  */  
-#define AXIS2_OM_NODE_GET_LAST_CHILD(om_node,env) \
+#define AXIOM_NODE_GET_LAST_CHILD(om_node,env) \
         ((om_node)->ops->get_last_child(om_node,env))
 /** get next sibling */  
-#define AXIS2_OM_NODE_GET_NEXT_SIBLING(om_node,env) \
+#define AXIOM_NODE_GET_NEXT_SIBLING(om_node,env) \
         ((om_node)->ops->get_next_sibling(om_node,env))
 /** get previous sibling */
-#define AXIS2_OM_NODE_GET_PREVIOUS_SIBLING(om_node,env) \
+#define AXIOM_NODE_GET_PREVIOUS_SIBLING(om_node,env) \
         ((om_node)->ops->get_previous_sibling(om_node,env))
 /** get build status */
 
-#define AXIS2_OM_NODE_IS_COMPLETE(om_node,env) \
+#define AXIOM_NODE_IS_COMPLETE(om_node,env) \
         ((om_node)->ops->is_complete(om_node,env))
 /** get data element of this node can be om_element om_text etc */
-#define AXIS2_OM_NODE_GET_DATA_ELEMENT(om_node,env) \
+#define AXIOM_NODE_GET_DATA_ELEMENT(om_node,env) \
         ((om_node)->ops->get_data_element(om_node,env))
 /** node type one of om_node_types */
-#define AXIS2_OM_NODE_GET_NODE_TYPE(om_node,env) \
+#define AXIOM_NODE_GET_NODE_TYPE(om_node,env) \
         ((om_node)->ops->get_node_type(om_node,env))       
 /** get document */        
-#define AXIS2_OM_NODE_GET_DOCUMENT(om_node, env) \
+#define AXIOM_NODE_GET_DOCUMENT(om_node, env) \
         ((om_node)->ops->get_document(om_node, env))
 
-#define AXIS2_OM_NODE_TO_STRING(om_node, env) \
+#define AXIOM_NODE_TO_STRING(om_node, env) \
         ((om_node)->ops->to_string(om_node, env))        
 /** @} */
 
@@ -324,4 +324,4 @@
 }
 #endif
 
-#endif                          /* AXIS2_OM_NODE_H */
+#endif                          /* AXIOM_NODE_H */

Copied: webservices/axis2/trunk/c/axiom/include/axiom_output.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_output.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_output.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_output.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_output.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_output.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_output.h Mon Jun 12 01:22:58 2006
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-#ifndef AXIS2_OM_OUTPUT_H
-#define AXIS2_OM_OUTPUT_H
+#ifndef AXIOM_OUTPUT_H
+#define AXIOM_OUTPUT_H
 
 /**
- * @file axis2_om_output.h
+ * @file axiom_output.h
  * @brief interface of om xml writer
  */
 
 #include <axis2_utils_defines.h>
 #include <axis2_utils.h>
 #include <axis2_env.h>
-#include <axis2_om_node.h>
+#include <axiom_node.h>
 #include <axis2_xml_writer.h>
 
 #ifdef __cplusplus
@@ -34,8 +34,8 @@
 #endif
 
 /**
- * @defgroup axis2_om_output OM Output
- * @ingroup axis2_om 
+ * @defgroup axiom_output OM Output
+ * @ingroup axiom 
  * @{
  */
 
@@ -43,11 +43,11 @@
     * \brief OM Output struct
     * The XML writer interface struct of om
     */
-    typedef struct axis2_om_output axis2_om_output_t;
-    typedef struct axis2_om_output_ops axis2_om_output_ops_t;
-    struct axis2_om_text;
+    typedef struct axiom_output axiom_output_t;
+    typedef struct axiom_output_ops axiom_output_ops_t;
+    struct axiom_text;
     
-AXIS2_DECLARE_DATA struct axis2_om_output_ops
+AXIS2_DECLARE_DATA struct axiom_output_ops
 {
    /**
     * free om_output 
@@ -57,7 +57,7 @@
     *  AXIS2_FAILURE otherwise 
     */
     axis2_status_t (AXIS2_CALL *
-   free_fn)(axis2_om_output_t *om_output,
+   free_fn)(axiom_output_t *om_output,
              const axis2_env_t *env);
     
    /**
@@ -67,27 +67,27 @@
      * @returns the output soap version 
      */   
     axis2_bool_t (AXIS2_CALL *
-   is_soap11)(axis2_om_output_t *om_output,
+   is_soap11)(axiom_output_t *om_output,
             const axis2_env_t *env); 
    /**
      * @returns true if the ignore_xml_declaration property is true   
     */
    axis2_bool_t (AXIS2_CALL *
-   is_ignore_xml_declaration)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_output,
+   set_soap11)(axiom_output_t *om_output,
             const axis2_env_t *env,
             axis2_bool_t soap11);
                
@@ -95,33 +95,33 @@
      * set xml_version property
      */    
    axis2_status_t (AXIS2_CALL *
-   set_xml_version)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_output,
+   set_do_optimize)(axiom_output_t *om_output,
                 const axis2_env_t *env,
                 axis2_bool_t optimize); 
    
@@ -129,7 +129,7 @@
      * returns the xml writer
      */    
    axis2_xml_writer_t* (AXIS2_CALL *
-   get_xml_writer)(axis2_om_output_t *om_output,
+   get_xml_writer)(axiom_output_t *om_output,
                const axis2_env_t *env);                                                                                                                                                  /**
      *  returns the content type
      *  for soap11 'text/xml' etc..
@@ -138,43 +138,43 @@
      *  @returns content id
      */     
    const axis2_char_t* (AXIS2_CALL *
-   get_content_type)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_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)(axis2_om_output_t *om_output,
+    get_root_content_id)(axiom_output_t *om_output,
                          const axis2_env_t *env);
     
     
     axis2_char_t* (AXIS2_CALL *
-    get_mime_boundry)(axis2_om_output_t *om_output,
+    get_mime_boundry)(axiom_output_t *om_output,
                       const axis2_env_t *env);                       
 
     axis2_byte_t* (AXIS2_CALL *
-    flush)(axis2_om_output_t *om_output,
+    flush)(axiom_output_t *om_output,
                       const axis2_env_t *env,
                       axis2_byte_t **output_stream,
                       int *output_stream_size);
@@ -183,9 +183,9 @@
 };  
     
 
-struct axis2_om_output
+struct axiom_output
 {
-    axis2_om_output_ops_t *ops;
+    axiom_output_ops_t *ops;
 };
     
     
@@ -196,8 +196,8 @@
     * @return a pointer to newly created output struct.
     */
 
-AXIS2_EXTERN axis2_om_output_t* AXIS2_CALL 
-axis2_om_output_create (const axis2_env_t *env,
+AXIS2_EXTERN axiom_output_t* AXIS2_CALL 
+axiom_output_create (const axis2_env_t *env,
                         axis2_xml_writer_t *xml_writer);
 
 
@@ -212,69 +212,69 @@
     */
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_om_output_write(axis2_om_output_t * om_output, 
+axiom_output_write(axiom_output_t * om_output, 
                       const axis2_env_t *env,
-                      axis2_om_types_t type,
+                      axiom_types_t type,
                       int no_of_args, ...);
                       
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_om_output_write_optimized(axis2_om_output_t *om_output, 
+axiom_output_write_optimized(axiom_output_t *om_output, 
                       const axis2_env_t *env, 
-                      struct axis2_om_text *om_text);
+                      struct axiom_text *om_text);
 /************** Macros ********************************************************/
 
-#define AXIS2_OM_OUTPUT_FREE(output, env) \
+#define AXIOM_OUTPUT_FREE(output, env) \
         ((output)->ops->free_fn(output, env))
         
-#define AXIS2_OM_OUTPUT_IS_SOAP11(output, env) \
+#define AXIOM_OUTPUT_IS_SOAP11(output, env) \
         ((output)->ops->is_soap11(output, env))       
         
-#define AXIS2_OM_OUTPUT_IS_IGNORE_XML_DECLARATION(output, env) \
+#define AXIOM_OUTPUT_IS_IGNORE_XML_DECLARATION(output, env) \
         ((output)->ops->is_ignore_xml_version(output, env)) 
         
-#define AXIS2_OM_OUTPUT_SET_IGNORE_XML_DECLARATION(output, env, xml_dec) \
+#define AXIOM_OUTPUT_SET_IGNORE_XML_DECLARATION(output, env, xml_dec) \
         ((output)->ops->set_ignore_xml_version(output, env, xml_dec))
 
-#define AXIS2_OM_OUTPUT_SET_SOAP11(output, env, soap11) \
+#define AXIOM_OUTPUT_SET_SOAP11(output, env, soap11) \
         ((output)->ops->set_soap11(output, env, soap11))
         
-#define AXIS2_OM_OUTPUT_SET_XML_VERSION(output, env, xml_version) \
+#define AXIOM_OUTPUT_SET_XML_VERSION(output, env, xml_version) \
         ((output)->ops->set_xml_version(output, env, xml_version))
         
-#define AXIS2_OM_OUTPUT_GET_XML_VERSION(output, env) \
+#define AXIOM_OUTPUT_GET_XML_VERSION(output, env) \
         ((output)->ops->get_xml_version(output, env))
         
-#define AXIS2_OM_OUTPUT_SET_CHAR_SET_ENCODING(output, env, char_set) \
+#define AXIOM_OUTPUT_SET_CHAR_SET_ENCODING(output, env, char_set) \
         ((output)->ops->set_char_set_encoding(output, env, char_set))
         
-#define AXIS2_OM_OUTPUT_GET_CHAR_SET_ENCODING(output, env) \
+#define AXIOM_OUTPUT_GET_CHAR_SET_ENCODING(output, env) \
         ((output)->ops->get_char_set_encoding(output, env))
         
-#define AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(output, env, optimize) \
+#define AXIOM_OUTPUT_SET_DO_OPTIMIZE(output, env, optimize) \
         ((output)->ops->set_do_optimize(output, env, optimize))  
         
-#define AXIS2_OM_OUTPUT_GET_XML_WRITER(output, env) \
+#define AXIOM_OUTPUT_GET_XML_WRITER(output, env) \
         ((output)->ops->get_xml_writer(output, env))
         
-#define AXIS2_OM_OUTPUT_GET_CONTENT_TYPE(output, env) \
+#define AXIOM_OUTPUT_GET_CONTENT_TYPE(output, env) \
         ((output)->ops->get_content_type(output, env))                      
 
-#define AXIS2_OM_OUTPUT_WRITE_XML_VERSION_ENCODING(output, env) \
+#define AXIOM_OUTPUT_WRITE_XML_VERSION_ENCODING(output, env) \
         ((output)->ops->write_xml_version_encoding(output, env))
 
-#define AXIS2_OM_OUTPUT_IS_OPTIMIZED(output, env) \
+#define AXIOM_OUTPUT_IS_OPTIMIZED(output, env) \
         ((output)->ops->is_optimized(output, env))
 
-#define AXIS2_OM_OUTPUT_GET_NEXT_CONTENT_ID(om_output, env) \
+#define AXIOM_OUTPUT_GET_NEXT_CONTENT_ID(om_output, env) \
         ((om_output)->ops->get_next_content_id(om_output, env))
         
-#define AXIS2_OM_OUTPUT_GET_ROOT_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))
         
-#define AXIS2_OM_OUTPUT_GET_MIME_BOUNDRY(om_output, env) \
+#define AXIOM_OUTPUT_GET_MIME_BOUNDRY(om_output, env) \
         ((om_output)->ops->get_mime_boundry(om_output, env))                
 
-#define AXIS2_OM_OUTPUT_FLUSH(om_output, env, output_stream, output_stream_size) \
+#define AXIOM_OUTPUT_FLUSH(om_output, env, output_stream, output_stream_size) \
         ((om_output)->ops->flush(om_output, env, output_stream, output_stream_size))                
 /** @} */
 
@@ -282,4 +282,4 @@
 }
 #endif
 
-#endif                          /* AXIS2_OM_OUTPUT_H */
+#endif                          /* AXIOM_OUTPUT_H */

Copied: webservices/axis2/trunk/c/axiom/include/axiom_processing_instruction.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_processing_instruction.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_processing_instruction.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_processing_instruction.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_processing_instruction.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_processing_instruction.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_processing_instruction.h Mon Jun 12 01:22:58 2006
@@ -14,47 +14,47 @@
  * limitations under the License.
  */
 
-#ifndef AXIS2_OM_PI_H
-#define AXIS2_OM_PI_H
+#ifndef AXIOM_PI_H
+#define AXIOM_PI_H
 
 /**
- * @file axis2_om_processing_instruction.h
+ * @file axiom_processing_instruction.h
  * @brief represents a xml processing instruction also known as PI
  */
 
-#include <axis2_om_node.h>
-#include <axis2_om_output.h>
+#include <axiom_node.h>
+#include <axiom_output.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-    struct axis2_om_processing_instruction;
-    struct axis2_om_processing_instruction_ops;
+    struct axiom_processing_instruction;
+    struct axiom_processing_instruction_ops;
     
     
 /**
- * @defgroup axis2_om_processing_instruction OM Processing Instruction
- * @ingroup axis2_om 
+ * @defgroup axiom_processing_instruction OM Processing Instruction
+ * @ingroup axiom 
  * @{
  */
 
 
   /** 
     * @brief OM text ops struct
-    * Encapsulator struct for ops of axis2_om_processing_instruction
+    * Encapsulator struct for ops of axiom_processing_instruction
     */
-   AXIS2_DECLARE_DATA  typedef struct axis2_om_processing_instruction_ops
+   AXIS2_DECLARE_DATA  typedef struct axiom_processing_instruction_ops
     {
         /**
-         * Frees an instance of axis2_om_processing_instruction
+         * Frees an instance of axiom_processing_instruction
          * @param om_pi processing instruction 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 axis2_om_processing_instruction * om_pi,
+        free)(struct axiom_processing_instruction * om_pi,
               const axis2_env_t *env);
         /**
          * set processing instruction data
@@ -64,7 +64,7 @@
          */
          
         axis2_status_t (AXIS2_CALL *
-        set_value)(struct axis2_om_processing_instruction *om_pi,
+        set_value)(struct axiom_processing_instruction *om_pi,
                    const axis2_env_t *env,
                    const axis2_char_t* value);
         /**
@@ -77,7 +77,7 @@
          */
         
         axis2_status_t (AXIS2_CALL *
-        set_target)(struct axis2_om_processing_instruction *om_pi,
+        set_target)(struct axiom_processing_instruction *om_pi,
                     const axis2_env_t *env,
                     const axis2_char_t* target);
         /**
@@ -87,7 +87,7 @@
          * @return target text , NULL on error or if target is null
          */
         axis2_char_t* (AXIS2_CALL *
-        get_target)(struct axis2_om_processing_instruction *om_pi,
+        get_target)(struct axiom_processing_instruction *om_pi,
                     const axis2_env_t *env);
         /**
          *  get data part of processing_instruction
@@ -96,7 +96,7 @@
          * @return data text , NULL if there is no data,
          */
         axis2_char_t* (AXIS2_CALL *
-        get_value)(struct axis2_om_processing_instruction *om_pi,
+        get_value)(struct axiom_processing_instruction *om_pi,
                    const axis2_env_t *env);                                                                                                                           
                            
         /**
@@ -108,23 +108,23 @@
          *         AXIS2_FAILURE on error 
          */
         axis2_status_t (AXIS2_CALL *
-        serialize)(struct axis2_om_processing_instruction *om_pi,
+        serialize)(struct axiom_processing_instruction *om_pi,
                   const axis2_env_t *env, 
-                  axis2_om_output_t *om_output);
+                  axiom_output_t *om_output);
                                     
                                           
-    } axis2_om_processing_instruction_ops_t;
+    } axiom_processing_instruction_ops_t;
 
   /** 
     * \brief OM processing instruction
     * Handles the XML processing instructions in OM
     */
-    typedef struct axis2_om_processing_instruction
+    typedef struct axiom_processing_instruction
     {
         /** ops struct  */
-        axis2_om_processing_instruction_ops_t *ops;
+        axiom_processing_instruction_ops_t *ops;
 
-    } axis2_om_processing_instruction_t;
+    } axiom_processing_instruction_t;
 
   /**
     * Creates a processing instruction 
@@ -134,34 +134,34 @@
     * @param value value of the processing instruction.cannot be NULL.
     * @param node This is an out parameter. cannot be NULL.
     *                       Returns the node corresponding to the comment created.
-    *                       Node type will be set to AXIS2_OM_PROCESSING_INSTRUCTION
+    *                       Node type will be set to AXIOM_PROCESSING_INSTRUCTION
     * @return a pointer tonewly created processing instruction struct 
     */
-    AXIS2_EXTERN axis2_om_processing_instruction_t * AXIS2_CALL 
-        axis2_om_processing_instruction_create (const axis2_env_t *env,
-                                                axis2_om_node_t * parent,
+    AXIS2_EXTERN axiom_processing_instruction_t * AXIS2_CALL 
+        axiom_processing_instruction_create (const axis2_env_t *env,
+                                                axiom_node_t * parent,
                                                 const axis2_char_t * target,
                                                 const axis2_char_t * value,
-                                                axis2_om_node_t ** node);
+                                                axiom_node_t ** node);
 
 
 /** frees given processing instruction */
-#define AXIS2_OM_PROCESSING_INSTRUCTION_FREE(pi, env) \
+#define AXIOM_PROCESSING_INSTRUCTION_FREE(pi, env) \
         ((pi)->ops->free(pi, env))
 /** set data text of processing_instruction */        
-#define AXIS2_OM_PROCESSING_INSTRUCION_SET_VALUE(pi, env, value) \
+#define AXIOM_PROCESSING_INSTRUCION_SET_VALUE(pi, env, value) \
         ((pi)->ops->set_value(pi,env,value))
 /** get data text of processing_instruction */        
-#define AXIS2_OM_PROCESSING_INSTRUCTION_GET_VALUE(pi, env) \
+#define AXIOM_PROCESSING_INSTRUCTION_GET_VALUE(pi, env) \
         ((pi)->ops->get_value(pi, env))        
 /** set target of processing instruction */        
-#define AXIS2_OM_PROCESSING_INSTRUCION_SET_TARGET(pi, env, value) \
+#define AXIOM_PROCESSING_INSTRUCION_SET_TARGET(pi, env, value) \
         ((pi)->ops->set_target(pi, env, value))
 /** get target text */        
-#define AXIS2_OM_PROCESSING_INSTRUCTION_GET_TARGET(pi, env) \
+#define AXIOM_PROCESSING_INSTRUCTION_GET_TARGET(pi, env) \
         ((pi)->ops->get_target(pi, env))
 /** serialize */
-#define AXIS2_OM_PROCESSING_INSTRUCTION_SERIALIZE(pi, env, om_output) \
+#define AXIOM_PROCESSING_INSTRUCTION_SERIALIZE(pi, env, om_output) \
         ((pi)->ops->serialize(pi, env, om_output))
 
 /** @} */
@@ -169,4 +169,4 @@
 }
 #endif
 
-#endif                          /* AXIS2_OM_PI_H */
+#endif                          /* AXIOM_PI_H */

Copied: webservices/axis2/trunk/c/axiom/include/axiom_stax_builder.h (from r413601, webservices/axis2/trunk/c/axiom/include/axis2_om_stax_builder.h)
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/include/axiom_stax_builder.h?p2=webservices/axis2/trunk/c/axiom/include/axiom_stax_builder.h&p1=webservices/axis2/trunk/c/axiom/include/axis2_om_stax_builder.h&r1=413601&r2=413605&rev=413605&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/include/axis2_om_stax_builder.h (original)
+++ webservices/axis2/trunk/c/axiom/include/axiom_stax_builder.h Mon Jun 12 01:22:58 2006
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-#ifndef AXIS2_OM_STAX_BUILDER_H
-#define AXIS2_OM_STAX_BUILDER_H
+#ifndef AXIOM_STAX_BUILDER_H
+#define AXIOM_STAX_BUILDER_H
 
 /**
- * @file axis2_om_stax_builder.h
+ * @file axiom_stax_builder.h
  * @brief om model stax builder 
  */
 
-#include <axis2_om_node.h>
+#include <axiom_node.h>
 #include <axis2_xml_reader.h>
-#include <axis2_om_document.h>
+#include <axiom_document.h>
 #include <axis2_env.h>
 
 #ifdef __cplusplus
@@ -33,20 +33,20 @@
 #endif
 
 
-    struct axis2_om_stax_builder;
-    struct axis2_om_stax_builder_ops;
+    struct axiom_stax_builder;
+    struct axiom_stax_builder_ops;
 
 /**
- * @defgroup axis2_om_stax_builder OM Stax Builder
- * @ingroup axis2_om 
+ * @defgroup axiom_stax_builder OM Stax Builder
+ * @ingroup axiom 
  * @{
  */
 
   /** 
     * @brief OM stax builder ops struct
-    * Encapsulator struct for ops of axis2_om_stax_builder
+    * Encapsulator struct for ops of axiom_stax_builder
     */
- AXIS2_DECLARE_DATA    typedef struct axis2_om_stax_builder_ops
+ AXIS2_DECLARE_DATA    typedef struct axiom_stax_builder_ops
     {
       /**
         * Builds the next node from stream. Moves pull parser forward and reacts 
@@ -56,8 +56,8 @@
         * @return a pointer to the next node, or NULL if there are no more nodes.
         *           On erros sets the error and returns NULL.
         */
-        axis2_om_node_t*(AXIS2_CALL *
-      next) (struct axis2_om_stax_builder *builder,
+        axiom_node_t*(AXIS2_CALL *
+      next) (struct axiom_stax_builder *builder,
                const axis2_env_t *env);
 
       /**
@@ -67,7 +67,7 @@
         * @return satus of the op. AXIS2_SUCCESS on success else AXIS2_FAILURE.
         */
         axis2_status_t (AXIS2_CALL *
-      discard_current_element)(struct axis2_om_stax_builder *builder,
+      discard_current_element)(struct axiom_stax_builder *builder,
                                  const axis2_env_t *env);
         /**
          * Free op
@@ -78,75 +78,75 @@
          */
           
       axis2_status_t (AXIS2_CALL *
-      free)(struct axis2_om_stax_builder *builder,
+      free)(struct axiom_stax_builder *builder,
             const axis2_env_t *env);
         
        /** get the document associated with the builder  
-        * @param builder axis2_om_stax_builder 
+        * @param builder axiom_stax_builder 
         * @param env environment 
         * @return pointer to document struct associated with builder
         *         NULL if there is no document associated with the builder,
         *         NULL if an error occured.
         */                                             
-        axis2_om_document_t* (AXIS2_CALL *
-      get_document)(struct axis2_om_stax_builder *builder,
+        axiom_document_t* (AXIS2_CALL *
+      get_document)(struct axiom_stax_builder *builder,
                       const axis2_env_t *env);
         /**
          * builder is finished building om structure
          */        
                                              
         axis2_bool_t (AXIS2_CALL *
-      is_complete)(struct axis2_om_stax_builder* builder,
+      is_complete)(struct axiom_stax_builder* builder,
                      const axis2_env_t *env);
         /**
          * moves the reader to next event and returns the token returned
        * by the xml_reader , returns -1 on error 
          */                                                
         int (AXIS2_CALL *
-      next_with_token)(struct axis2_om_stax_builder *builder,
+      next_with_token)(struct axiom_stax_builder *builder,
                          const axis2_env_t *env);                                                                                                                                                                                                                                                 
                                                         
-    } axis2_om_stax_builder_ops_t;
+    } axiom_stax_builder_ops_t;
 
   /** 
     * \brief OM stax builder struct
     * Bulds OM document using a pull parser interface
     */
-    typedef struct axis2_om_stax_builder
+    typedef struct axiom_stax_builder
     {
         /** ops struct */
-        axis2_om_stax_builder_ops_t *ops;
+        axiom_stax_builder_ops_t *ops;
        
-    }axis2_om_stax_builder_t;
+    }axiom_stax_builder_t;
 
   /**
     * creates an stax builder
     * @param environment Environment. MUST NOT be NULL, .
     * @return a pointer to the newly created builder struct. 
     */
-    AXIS2_EXTERN axis2_om_stax_builder_t * AXIS2_CALL
-    axis2_om_stax_builder_create(const axis2_env_t *env,
+    AXIS2_EXTERN axiom_stax_builder_t * AXIS2_CALL
+    axiom_stax_builder_create(const axis2_env_t *env,
                                  axis2_xml_reader_t *parser);
 
 
 /** builds next node */
-#define AXIS2_OM_STAX_BUILDER_NEXT(builder,env) \
+#define AXIOM_STAX_BUILDER_NEXT(builder,env) \
         ((builder)->ops->next(builder, env))
 /** discards current node */
-#define AXIS2_OM_STAX_BUILDER_DISCARD_CURRENT_ELEMENT(builder,env) \
+#define AXIOM_STAX_BUILDER_DISCARD_CURRENT_ELEMENT(builder,env) \
         ((builder)->ops->discard_current_element(builder, env))
 /** free op of the builder */
-#define AXIS2_OM_STAX_BUILDER_FREE(builder,env) \
+#define AXIOM_STAX_BUILDER_FREE(builder,env) \
         ((builder)->ops->free(builder,env))
 
 /** get the document associated with the builder */  
-#define AXIS2_OM_STAX_BUILDER_GET_DOCUMENT(builder,env) \
+#define AXIOM_STAX_BUILDER_GET_DOCUMENT(builder,env) \
         ((builder)->ops->get_document(builder,env))
 /** builder is finished building */        
-#define AXIS2_OM_STAX_BUILDER_IS_COMPLETE(builder, env) \
+#define AXIOM_STAX_BUILDER_IS_COMPLETE(builder, env) \
         ((builder)->ops->is_complete(builder, env))                       
 /** moves the builder to next event */   
-#define AXIS2_OM_STAX_BUILDER_NEXT_WITH_TOKEN(builder, env) \
+#define AXIOM_STAX_BUILDER_NEXT_WITH_TOKEN(builder, env) \
         ((builder)->ops->next_with_token(builder, env))                    
 
 /** @} */
@@ -157,4 +157,4 @@
 #endif
 
 
-#endif                          /* AXIS2_OM_STAX_BUILDER_H */
+#endif                          /* AXIOM_STAX_BUILDER_H */



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message