You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by an...@locus.apache.org on 2000/02/16 00:17:39 UTC

cvs commit: xml-xerces/c/src/dom DOM_CharacterData.hpp DOM_NamedNodeMap.hpp DOM_NodeFilter.hpp DOM_NodeIterator.hpp DOM_TreeWalker.hpp ElementImpl.cpp NameNodeFilter.hpp NodeImpl.cpp NodeIteratorImpl.hpp NotationImpl.hpp TreeWalkerImpl.hpp

andyh       00/02/15 15:17:39

  Modified:    c/src/dom DOM_CharacterData.hpp DOM_NamedNodeMap.hpp
                        DOM_NodeFilter.hpp DOM_NodeIterator.hpp
                        DOM_TreeWalker.hpp ElementImpl.cpp
                        NameNodeFilter.hpp NodeImpl.cpp
                        NodeIteratorImpl.hpp NotationImpl.hpp
                        TreeWalkerImpl.hpp
  Log:
  Update Doc++ API comments
  NameSpace bugfix and update to track W3C
  Chih Hsiang Chou
  
  Revision  Changes    Path
  1.4       +13 -10    xml-xerces/c/src/dom/DOM_CharacterData.hpp
  
  Index: DOM_CharacterData.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/DOM_CharacterData.hpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- DOM_CharacterData.hpp	2000/02/06 07:47:28	1.3
  +++ DOM_CharacterData.hpp	2000/02/15 23:17:36	1.4
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: DOM_CharacterData.hpp,v $
  + * Revision 1.4  2000/02/15 23:17:36  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.3  2000/02/06 07:47:28  rahulj
    * Year 2K copyright swat.
    *
  @@ -118,16 +123,6 @@
       */
       DOM_CharacterData & operator = (const DOM_CharacterData &other);
   
  -    //@}
  -    /** @name Destructor. */
  -    //@{
  -	 /**
  -	  * Destructor for DOM_CharacterData.  The object being destroyed
  -      * is the reference to the Character Data node, not the character
  -      * data itself.
  -	  */
  -    ~DOM_CharacterData();
  -
       /**
         * Assignment operator.  This overloaded variant is provided for
         *   the sole purpose of setting a DOM_Node reference variable to
  @@ -142,6 +137,16 @@
         * @param val.  Only a value of 0, or null, is allowed.
         */
       DOM_CharacterData & operator = (const DOM_NullPtr *val);
  +
  +    //@}
  +    /** @name Destructor. */
  +    //@{
  +	 /**
  +	  * Destructor for DOM_CharacterData.  The object being destroyed
  +      * is the reference to the Character Data node, not the character
  +      * data itself.
  +	  */
  +    ~DOM_CharacterData();
   
   
       //@}
  
  
  
  1.8       +7 -4      xml-xerces/c/src/dom/DOM_NamedNodeMap.hpp
  
  Index: DOM_NamedNodeMap.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/DOM_NamedNodeMap.hpp,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- DOM_NamedNodeMap.hpp	2000/02/10 20:20:42	1.7
  +++ DOM_NamedNodeMap.hpp	2000/02/15 23:17:36	1.8
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: DOM_NamedNodeMap.hpp,v $
  + * Revision 1.8  2000/02/15 23:17:36  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.7  2000/02/10 20:20:42  abagchi
    * Added docs for assignment operators
    *
  @@ -231,6 +236,10 @@
       */
       DOM_Node               setNamedItem(DOM_Node arg);
   
  +    //@}
  +    /** @name Get functions. */
  +    //@{
  +
       /**
       * Returns the <code>index</code>th item in the map. 
       *
  @@ -243,10 +252,6 @@
       *   index.
       */
       DOM_Node               item(unsigned int index);
  -
  -    //@}
  -    /** @name Get functions. */
  -    //@{
   
       /**
       * Retrieves a node specified by name.
  
  
  
  1.5       +44 -49    xml-xerces/c/src/dom/DOM_NodeFilter.hpp
  
  Index: DOM_NodeFilter.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/DOM_NodeFilter.hpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- DOM_NodeFilter.hpp	2000/02/10 21:47:12	1.4
  +++ DOM_NodeFilter.hpp	2000/02/15 23:17:37	1.5
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: DOM_NodeFilter.hpp,v $
  + * Revision 1.5  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.4  2000/02/10 21:47:12  abagchi
    * Added API docs
    *
  @@ -86,13 +91,13 @@
   
   
   /**
  - *  This class wraps a NodeFilterImpl object, which is reference counted. Users
  - *  are expected to subclass NodeFilterImpl to provide the desired filter. An example
  - *  of this is in NameNodeFilterImpl.[cpp,hpp]
  - *  Filters are objects that know how to "filter out" nodes. If a NodeIterator or
  - *  TreeWalker is given a filter, it applies the filter before it returns the next node. If the
  - *  filter says to accept the node, the iterator returns it; otherwise, the iterator looks for
  - *  the next node and pretends that the node that was rejected was not there.
  + * Filters are objects that know how to "filter out" nodes. If a
  + * <code>DOM_NodeIterator</code> or <code>DOM_TreeWalker</code> is given a
  + * filter, it applies the filter before it returns the next node.
  + * 
  + * If the filter says to accept the node, the iterator returns it; otherwise, the
  + * iterator looks for the next node and pretends that the node that was rejected
  + * was not there.
    *
    *  The DOM does not provide any filters. Filter is just an interface that users can
    *  implement to provide their own filters. 
  @@ -103,13 +108,11 @@
    *  One filter may be used with a number of different kinds of iterators, encouraging
    *  code reuse.
    */
  -
  -
   class CDOM_EXPORT DOM_NodeFilter
   {
  -	public:
  +    public:
   	/** @name Enumerators for Node Filter */
  -    //@{
  +        //@{
   	/**
   	  *		<table><tr><td>FILTER_ACCEPT</td>
             *            <td>Accept the node. Navigation methods defined for
  @@ -132,7 +135,7 @@
   	  *		</table>
             *
   	  */
  -	enum FilterAction {FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP};
  +        enum FilterAction {FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP};
           enum ShowType {
               SHOW_ALL                       = 0x0000FFFF,
               SHOW_ELEMENT                   = 0x00000001,
  @@ -149,47 +152,41 @@
               SHOW_NOTATION                  = 0x00000800
           };
   	//@}
  -
  -    /** @name Constructors */
  -    //@{
  -    /**
  -      * Default constructor for DOM_NodeFilter.
  -      *
  -      */
  -
  -    DOM_NodeFilter();
  -	//@}
   
  -    /** @name Destructor */
  -    //@{
  -    /**
  -      * Destructor
  -      *
  -      */
  -    virtual ~DOM_NodeFilter();
  -	//@}
  +        /** @name Constructors */
  +        //@{
  +        /**
  +          * Default constructor for DOM_NodeFilter.
  +          */
  +        DOM_NodeFilter();
  +        //@}
   
  -    /** @name Destructor */
  -    //@{
  -    /**
  -      * Test whether a specified node is visible in the logical view of a <code>TreeWalker</code>
  -      * or <code>NodeIterator</code>. This function will be called by the implementation of
  -      * TreeWalker and NodeIterator; it is not intended to be called directly from
  -      * user code.
  -      *
  -      * @param node The node to check to see if it passes the filter or not.
  -      * @return Returns a constant to determine whether the node is accepted, rejected,
  -      *          or skipped
  -      */
  -    virtual short acceptNode (DOM_Node node) =0;
  -	//@}
  +        /** @name Destructor. */
  +        //@{
  +	/**
  +	  * Destructor for DOM_NodeFilter.
  +	  */
  +        virtual ~DOM_NodeFilter();
  +        //@}
   
  -private:
  -    DOM_NodeFilter(const DOM_NodeFilter &other);
  -    DOM_NodeFilter & operator = (const DOM_NodeFilter &other);
  -    bool operator == (const DOM_NodeFilter &other) const;
  -    bool operator != (const DOM_NodeFilter &other) const;
  +        /** @name Test function. */
  +        //@{
  +	/**
  +	  * Test whether a specified node is visible in the logical view of a DOM_TreeWalker
  +	  * or DOM_NodeIterator. This function will be called by the implementation of
  +	  * DOM_TreeWalker and DOM_NodeIterator; it is not intended to be called directly from user
  +	  * code.
  +          * @param node The node to check to see if it passes the filter or not.
  +          * @return A constant to determine whether the node is accepted, rejected, or skipped.
  +	  */
  +        virtual short acceptNode (DOM_Node node) =0;
  +        //@}
   
  +    private:
  +        DOM_NodeFilter(const DOM_NodeFilter &other);
  +        DOM_NodeFilter & operator = (const DOM_NodeFilter &other);
  +        bool operator == (const DOM_NodeFilter &other) const;
  +        bool operator != (const DOM_NodeFilter &other) const;
   };
   
   #endif
  
  
  
  1.7       +121 -144  xml-xerces/c/src/dom/DOM_NodeIterator.hpp
  
  Index: DOM_NodeIterator.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/DOM_NodeIterator.hpp,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- DOM_NodeIterator.hpp	2000/02/11 18:14:11	1.6
  +++ DOM_NodeIterator.hpp	2000/02/15 23:17:37	1.7
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: DOM_NodeIterator.hpp,v $
  + * Revision 1.7  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.6  2000/02/11 18:14:11  abagchi
    * Fixed doc++ bugs
    *
  @@ -88,171 +93,145 @@
   class NodeIteratorImpl;
   
   /**
  -  *	NodeIterators are used to step through a set of nodes, e.g. the set of nodes in a
  -  * NodeList, the document subtree governed by a particular node, the results of a
  -  * query, or any other set of nodes. The set of nodes to be iterated is determined by
  -  * the implementation of the NodeIterator. DOM Level 2 specifies a single
  -  * NodeIterator implementation for document-order traversal of a document subtree.
  -  * Instances of these iterators are created by calling
  -  * <code>DocumentTraversal.createNodeIterator()</code>.
  -  */
  + * NodeIterators are used to step through a set of nodes, e.g. the set of nodes
  + * in a NodeList, the document subtree governed by a particular node, the results
  + * of a query, or any other set of nodes. The set of nodes to be iterated is
  + * determined by the implementation of the NodeIterator. DOM Level 2 specifies a
  + * single NodeIterator implementation for document-order traversal of a document
  + * subtree. Instances of these iterators are created by calling
  + * <code>DocumentTraversal.createNodeIterator()</code>.
  + */
   class CDOM_EXPORT DOM_NodeIterator
   {
  -	public:
  -    /** @name Constructors */
  -    //@{
  +    public:
  +        /** @name Constructors and assignment operator */
  +        //@{
  +        /**
  +          * Default constructor.
  +          */
  +        DOM_NodeIterator ();
   
  -	/**
  -	  * Default constructor
  -	  */
  -    DOM_NodeIterator ();
  +        /**
  +          * Copy constructor.
  +          *
  +          * @param other The object to be copied.
  +          */
  +        DOM_NodeIterator(const DOM_NodeIterator &other);
   
  -	/**
  -	  * Copy constructor
  -	  * @param other The object to be copied
  -	  */
  -    DOM_NodeIterator(const DOM_NodeIterator &other);
  -    //@}
  +        /**
  +          * Assignment operator.
  +          *
  +          * @param other The object to be copied.
  +          */
  +        DOM_NodeIterator & operator = (const DOM_NodeIterator &other);
   
  -    /** @name Assignment operators */
  -    //@{
  +        /**
  +          * Assignment operator.  This overloaded variant is provided for
  +          *   the sole purpose of setting a DOM_NodeIterator to null.
  +          *
  +          * @param val.  Only a value of 0, or null, is allowed.
  +          */
  +        DOM_NodeIterator & operator = (const DOM_NullPtr *val);
  +        //@}
  +
  +        /** @name Destructor. */
  +        //@{
   	/**
  -	  * Assignment operator
  -	  * @param other The object to be copied through assignment
  +	  * Destructor for DOM_NodeIterator.
   	  */
  -    DOM_NodeIterator & operator = (const DOM_NodeIterator &other);
  +        ~DOM_NodeIterator();
  +        //@}
   
  -	/**
  -	  * Assignment operator
  -	  *
  -	  *   This overloaded variant is provided for
  -	  *   the sole purpose of setting a DOM_Node reference variable to
  -	  *   zero.  Nulling out a reference variable in this way will decrement
  -	  *   the reference count on the underlying Node object that the variable
  -	  *   formerly referenced.  This effect is normally obtained when reference
  -	  *   variable goes out of scope, but zeroing them can be useful for
  -	  *   global instances, or for local instances that will remain in scope
  -	  *   for an extended time,  when the storage belonging to the underlying
  -          *   node needs to be reclaimed.
  -	  * @param val Only a value of 0, or null, is allowed.
  -	  */
  -    DOM_NodeIterator & operator = (const DOM_NullPtr *val);
  -    //@}
  +        /** @name Equality and Inequality operators. */
  +        //@{
  +        /**
  +         * The equality operator.
  +         *
  +         * @param other The object reference with which <code>this</code> object is compared
  +         * @returns True if both <code>DOM_NodeIterator</code>s refer to the same
  +         *  actual node, or are both null; return false otherwise.
  +         */
  +        bool operator == (const DOM_NodeIterator & other)const;
   
  -    /** @name Destructor */
  -    //@{
  -	/**
  -	  * Destructor
  -	  */
  -    ~DOM_NodeIterator();
  -    //@}
  +        /**
  +          *  Compare with a pointer.  Intended only to allow a convenient
  +          *    comparison with null.
  +          */
  +        bool operator == (const DOM_NullPtr *other) const;
   
  -    /** @name Equality operators */
  -    //@{
  -    /**
  -     *  Test whether this NodeIterator reference refers to the same underlying
  -     *  node iterator as the other reference object.  This does not
  -     *  compare the contents of two different objects.
  -     *
  -     *  @param other The value to be compared
  -     *  @return Returns true if the underlying node iterator is same
  -     */
  -    bool operator == (const DOM_NodeIterator & other)const;
  -
  -    /**
  -     *  Use this comparison operator to test whether a Node Iterator reference
  -     *  is null.
  -     *
  -     *  @param other The value to be compared, which must be 0 or null.
  -     *  @return Returns true if the node iterator is null
  -     */
  -    bool operator == (const DOM_NullPtr *other) const;
  -    //@}
  -
  -    /** @name Inequality operators */
  -    //@{
  -    /**
  -     *  Test whether this NodeIterator reference refers to the same underlying
  -     *  node iterator as the other reference object.  This does not
  -     *  compare the contents of two different objects.
  -     *
  -     *  @param other The value to be compared
  -     *  @return Returns true if the underlying node iterator is different
  -     */
  -    bool operator != (const DOM_NodeIterator & other) const;
  -    /**
  -     *  Use this comparison operator to test whether a Node Iterator reference
  -     *  is null.
  -     *
  -     *  @param other The value to be compared, which must be 0 or null.
  -     *  @return Returns true if the node iterator is NOT null
  -     */
  -    bool operator != (const DOM_NullPtr * other) const;
  -    //@}
  +        /**
  +         * The inequality operator.  See operator ==.
  +         */
  +        bool operator != (const DOM_NodeIterator & other) const;
  +
  +         /**
  +          *  Compare with a pointer.  Intended only to allow a convenient
  +          *    comparison with null.
  +          *
  +          */
  +        bool operator != (const DOM_NullPtr * other) const;
  +        //@}
   
  -    /** @name Get Functions */
  -    //@{
  -	/**
  -	  *	 Returns the value of <code>whatToShow</code>
  -	  *  This attribute determines which node types are presented via the
  -          *  iterator. The available set of constants is defined in the Filters
  -          *  interface.
  -	  */
  -    unsigned long       getWhatToShow();
  +        /** @name Get functions. */
  +        //@{
  +        /**
  +          * Return which node types are presented via the iterator.
  +          * The available set of constants is defined in the DOM_NodeFilter interface.
  +          */
  +        unsigned long       getWhatToShow();
   
  -    /**
  -      *  Get the <code>expandEntity</code> reference flag.
  -      *  The value of this flag determines whether the children of entity
  -      *  reference nodes are visible to the iterator. If false, they will be skipped
  -      *  over.
  -      *
  -      *  To produce a view of the document that has entity references
  -      *  expanded and does not expose the entity reference node itself, use
  -      *  the <code>whatToShow</code> flags to hide the entity reference node and set
  -      *  <code>expandEntityReferences</code> to true when creating the iterator. To
  -      *  produce a view of the document that has entity reference nodes but
  -      *  no entity expansion, use the <code>whatToShow</code> flags to show the entity
  -      *  reference node and set <code>expandEntityReferences</code> to false.
  -      */
  -    bool getExpandEntityReferences();
  +        /**
  +          * Return The filter used to screen nodes.
  +          */
  +        DOM_NodeFilter*     getFilter();
   
  -	/**
  -	  *	Get the filter used to screen nodes.
  -	  */
  -    DOM_NodeFilter*     getFilter();
  -    //@}
  +        /**
  +          * Return the expandEntityReferences flag.
  +          * The value of this flag determines whether the children of entity reference
  +          * nodes are visible to the DOM_NodeFilter. If false, they will be skipped over.
  +          */
  +        bool getExpandEntityReferences();
   
  -    /** @name Iterator Methods */
  -    //@{
  -	/**
  -	  *	 Returns the next node in the set and advances the position of the
  -          *  iterator in the set. After a NodeIterator is created, the first call to
  -          *  <code>nextNode()</code> returns the first node in the set.
  -	  *  @return Returns the next node in the set
  -	  */
  -    DOM_Node            nextNode();
  +        /**
  +          * Returns the next node in the set and advances the position of the iterator
  +          * in the set. After a DOM_NodeIterator is created, the first call to nextNode()
  +          * returns the first node in the set.
  +          *
  +          * @exception DOMException
  +          *   INVALID_STATE_ERR: Raised if this method is called after the
  +          *   <code>detach</code> method was invoked.
  +          */
  +        DOM_Node            nextNode();
   
           /**
  -	  *  Returns the previous node in the set and moves the position of the
  -          *  iterator backwards in the set.
  -	  *  @return Returns the previous node in the set
  -	  */
  -    DOM_Node            previousNode();
  +          * Returns the previous node in the set and moves the position of the iterator
  +          * backwards in the set.
  +          *
  +          * @exception DOMException
  +          *   INVALID_STATE_ERR: Raised if this method is called after the
  +          *   <code>detach</code> method was invoked.
  +          */
  +        DOM_Node            previousNode();
  +        //@}
   
  -    /**
  -      *	 Detaches the iterator from the set which it iterated over, releasing any
  -      *  computational resources and placing the iterator in the INVALID state.
  -      *  After detach has been invoked, calls to nextNode or previousNode
  -      *  will raise the exception <code>INVALID_STATE_ERR</code>.
  -      */
  +        /** @name Detaching functions. */
  +        //@{
  +        /**
  +          * Detaches the iterator from the set which it iterated over, releasing any
  +          * computational resources and placing the iterator in the INVALID state. After
  +          * <code>detach</code> has been invoked, calls to <code>nextNode</code> or
  +          * <code>previousNode</code> will raise the exception INVALID_STATE_ERR.
  +          */
   	void				detach();
  -	//@}
  +        //@}
   
  -      DOM_NodeIterator (NodeIteratorImpl* impl);
  +    protected:
  +        DOM_NodeIterator (NodeIteratorImpl* impl);
   
  -    private:
  -      NodeIteratorImpl*                 fImpl;
  +        friend class DOM_Document;
   
  +    private:
  +        NodeIteratorImpl*                 fImpl;
   };
   
   #endif
  
  
  
  1.6       +119 -157  xml-xerces/c/src/dom/DOM_TreeWalker.hpp
  
  Index: DOM_TreeWalker.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/DOM_TreeWalker.hpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- DOM_TreeWalker.hpp	2000/02/11 03:01:04	1.5
  +++ DOM_TreeWalker.hpp	2000/02/15 23:17:37	1.6
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: DOM_TreeWalker.hpp,v $
  + * Revision 1.6  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.5  2000/02/11 03:01:04  abagchi
    * Made protected method public to compile, must be fixed later
    *
  @@ -84,239 +89,198 @@
   
   class TreeWalkerImpl;
   
  -   /**
  -     * TreeWalker objects are used to navigate a document tree or subtree using the view of
  -     * the document defined by its <code>whatToShow</code> flags and any filters that are defined for the
  -     * TreeWalker. Any function which performs navigation using a TreeWalker will
  -     * automatically support any view defined by a TreeWalker.
  -     *
  -     * Omitting nodes from the logical view of a subtree can result in a structure that is
  -     * substantially different from the same subtree in the complete, unfiltered document. Nodes
  -     * that are siblings in the TreeWalker view may be children of different, widely separated
  -     * nodes in the original view. For instance, consider a Filter that skips all nodes except for
  -     * Text nodes and the root node of a document. In the logical view that results, all text
  -     * nodes will be siblings and appear as direct children of the root node, no matter how
  -     * deeply nested the structure of the original document.
  -     */
   
  +/**
  + * <code>DOM_TreeWalker</code> objects are used to navigate a document tree or
  + * subtree using the view of the document defined by its <code>whatToShow</code>
  + * flags and any filters that are defined for the <code>DOM_TreeWalker</code>. Any
  + * function which performs navigation using a <code>DOM_TreeWalker</code> will
  + * automatically support any view defined by a <code>DOM_TreeWalker</code>.
  + *
  + * Omitting nodes from the logical view of a subtree can result in a structure that is
  + * substantially different from the same subtree in the complete, unfiltered document. Nodes
  + * that are siblings in the DOM_TreeWalker view may be children of different, widely separated
  + * nodes in the original view. For instance, consider a Filter that skips all nodes except for
  + * Text nodes and the root node of a document. In the logical view that results, all text
  + * nodes will be siblings and appear as direct children of the root node, no matter how
  + * deeply nested the structure of the original document.
  + */
   class CDOM_EXPORT DOM_TreeWalker {
  -
       public:
  -			
  -        /** @name Constructors */
  +        /** @name Constructors and assignment operator */
           //@{
  -
           /**
  -          * Default constructor
  +          * Default constructor.
             */
  -        DOM_TreeWalker ();
  +        DOM_TreeWalker();
   
           /**
  -          * Copy constructor
  -          * @param other The object to be copied
  +          * Copy constructor.
  +          *
  +          * @param other The object to be copied.
             */
           DOM_TreeWalker(const DOM_TreeWalker &other);
  -        //@}
   
  -        /** @name Destructor */
  -        //@{
           /**
  -          * Destructor
  -          */
  -        ~DOM_TreeWalker();
  -        //@}
  -
  -        /** @name Assignment operators */
  -        //@{
  -        /**
  -          * Assignment operator
  -          * @param other The object to be copied through assignment
  +          * Assignment operator.
  +          *
  +          * @param other The object to be copied.
             */
           DOM_TreeWalker & operator = (const DOM_TreeWalker &other);
   
           /**
  -          * Assignment operator
  +          * Assignment operator.  This overloaded variant is provided for
  +          *   the sole purpose of setting a DOM_NodeIterator to null.
             *
  -          *   This overloaded variant is provided for
  -          *   the sole purpose of setting a DOM_Node reference variable to
  -          *   zero.  Nulling out a reference variable in this way will decrement
  -          *   the reference count on the underlying Node object that the variable
  -          *   formerly referenced.  This effect is normally obtained when reference
  -          *   variable goes out of scope, but zeroing them can be useful for
  -          *   global instances, or for local instances that will remain in scope
  -          *   for an extended time,  when the storage belonging to the underlying
  -          *   node needs to be reclaimed.
  -          * @param val Only a value of 0, or null, is allowed.
  +          * @param val.  Only a value of 0, or null, is allowed.
             */
           DOM_TreeWalker & operator = (const DOM_NullPtr *val);
           //@}
   
  -        /** @name Equality operators */
  +        /** @name Destructor. */
           //@{
  +	/**
  +	  * Destructor for DOM_TreeWalker.
  +	  */
  +        ~DOM_TreeWalker();
  +        //@}
  +
  +        /** @name Equality and Inequality operators. */
  +        //@{
           /**
  -         *  Test whether this TreeWalker reference refers to the same underlying
  -         *  tree walker as the other reference object.  This does not
  -         *  compare the contents of two different objects.
  +         * The equality operator.
            *
  -         *  @param other The value to be compared
  -         *  @return Returns true if the underlying tree walker object is same
  +         * @param other The object reference with which <code>this</code> object is compared
  +         * @returns True if both <code>DOM_TreeWalker</code>s refer to the same
  +         *  actual node, or are both null; return false otherwise.
            */
           bool operator == (const DOM_TreeWalker & other)const;
   
           /**
  -         *  Use this comparison operator to test whether a tree walker reference
  -         *  is null.
  -         *
  -         *  @param other The value to be compared, which must be 0 or null.
  -         *  @return Returns true if the node iterator is null
  -         */
  +          *  Compare with a pointer.  Intended only to allow a convenient
  +          *    comparison with null.
  +          */
           bool operator == (const DOM_NullPtr *other) const;
  -        //@}
   
  -        /** @name Inequality operators */
  -        //@{
  -
           /**
  -         *  Test whether this TreeWalker reference refers to the same underlying
  -         *  tree walker as the other reference object.  This does not
  -         *  compare the contents of two different objects.
  -         *
  -         *  @param other The value to be compared
  -         *  @return Returns true if the underlying tree walker is different
  +         * The inequality operator.  See operator ==.
            */
           bool operator != (const DOM_TreeWalker & other) const;
   
  -        /**
  -         *  Use this comparison operator to test whether a tree walker reference
  -         *  is null.
  -         *
  -         *  @param other The value to be compared, which must be 0 or null.
  -         *  @return Returns true if the node iterator is NOT null
  -         */
  +         /**
  +          *  Compare with a pointer.  Intended only to allow a convenient
  +          *    comparison with null.
  +          *
  +          */
           bool operator != (const DOM_NullPtr * other) const;
           //@}
   
  -        /** @name Get Functions */
  +        /** @name Get functions. */
           //@{
           /**
  -          *	 Returns the value of <code>whatToShow</code>
  -          *  This attribute determines which node types are presented via the
  -          *  <code>TreeWalker</code>. The available set of constants is defined in the Filters
  -          *  interface.
  +          * Return which node types are presented via the DOM_TreeWalker.
  +          * These constants are defined in the DOM_NodeFilter interface.
             */
  -        unsigned long   				getWhatToShow();
  +        unsigned long   	getWhatToShow();
  +
           /**
  -          *	Get the filter used to screen nodes.
  +          * Return The filter used to screen nodes.
             */
  -        DOM_NodeFilter*					getFilter();
  +        DOM_NodeFilter*		getFilter();
  +
           /**
  -          * Gets the node at which the tree walker is currently positioned.
  -          *
  -          * The value must not be null. Alterations to the DOM tree may cause the
  -          * current node to no longer be accepted by the TreeWalker's associated
  -          * filter. <code>currentNode</code> may also be explicitly set to any node, whether or not it
  -          * is within the subtree specified by the root node or would be accepted by
  -          * the filter and <code>whatToShow</code> flags. Further traversal occurs relative to
  -          * currentNode even if it is not part of the current view by applying the filters
  -          * in the requested direction (not changing <code>currentNode</code> where no traversal is
  -          * possible).
  +          * Return the expandEntityReferences flag.
  +          * The value of this flag determines whether the children of entity reference
  +          * nodes are visible to the DOM_TreeWalker. If false, they will be skipped over.
             */
  -        DOM_Node						getCurrentNode();
  -        //@}
  +        bool getExpandEntityReferences();
   
  -        /** @name Set Functions */
  -        //@{
           /**
  -          *  Sets the current node of the DOM tree in tree walker
  -          *
  -          * To know more about the current node see <code>getCurrentNode</code> description.
  -          * @see #getCurrentNode
  +          * Return the node at which the DOM_TreeWalker is currently positioned.
             */
  -        void							setCurrentNode(DOM_Node currentNode);
  -        //@}
  -
  -        /** @name Iterator Methods */
  -        //@{
  +        DOM_Node		getCurrentNode();
   
           /**
             * Moves to and returns the closest visible ancestor node of the current node.
  -          * If the search for parentNode attempts to step upward from the
  -          * TreeWalker's root node, or if it fails to find a visible ancestor node, this
  -          * method retains the current position and returns null.
  -          *
  -          * @return The new parent node, or null if the current node has no parent in
  -          *         the TreeWalker's logical view.
  +          * If the search for parentNode attempts to step upward from the DOM_TreeWalker's root
  +          * node, or if it fails to find a visible ancestor node, this method retains the
  +          * current position and returns null.
             */
  -        DOM_Node						parentNode();
  +        DOM_Node		parentNode();
   
           /**
  -          * Moves the TreeWalker to the first child of the current node, and returns the new node.
  -          * If the current node has no children, returns null, and retains
  -          * the current node
  -          * @return       The new node, or null if the current node has no children.
  +          * Moves the <code>DOM_TreeWalker</code> to the first child of the current node,
  +          * and returns the new node. If the current node has no children, returns
  +          * <code>null</code>, and retains the current node.
             */
  -        DOM_Node						firstChild();
  +        DOM_Node		firstChild();
   
           /**
  -          * Moves the TreeWalker to the last child of the current node, and returns the new node.
  -          * If the current node has no children, returns null, and retains
  -          * the current node.
  -          *
  -          * @return The new node, or null if the current node has no children.
  +          * Moves the <code>DOM_TreeWalker</code> to the last child of the current node, and
  +          * returns the new node. If the current node has no children, returns
  +          * <code>null</code>, and retains the current node.
             */
  -        DOM_Node						lastChild();
  +        DOM_Node		lastChild();
   
           /**
  -          * Moves the TreeWalker to the previous sibling of the current node, and returns the new node.
  -          * If the current node has no previous sibling, returns
  +          * Moves the <code>DOM_TreeWalker</code> to the previous sibling of the current
  +          * node, and returns the new node. If the current node has no previous sibling,
  +          * returns <code>null</code>, and retains the current node.
  +          */
  +        DOM_Node		previousSibling();
  +
  +        /**
  +          * Moves the <code>DOM_TreeWalker</code> to the next sibling of the current node,
  +          * and returns the new node. If the current node has no next sibling, returns
             * <code>null</code>, and retains the current node.
  -          *
  -          * @return  The new node, or null if the current node has no previous sibling.
             */
  -        DOM_Node						previousSibling();
  +        DOM_Node		nextSibling();
   
           /**
  -          * Moves the TreeWalker to the next sibling of the current node, and returns the new node.
  -          * If the current node has no next sibling, returns <code>null</code>, and
  -          * retains the current node.
  -          *
  -          * @return The new node, or null if the current node has no next sibling.
  +          * Moves the <code>DOM_TreeWalker</code> to the previous visible node in document
  +          * order relative to the current node, and returns the new node. If the current
  +          * node has no previous node, 
  +          * or if the search for previousNode attempts to step upward from the DOM_TreeWalker's
  +          * root node, returns <code>null</code>, and retains the current node. 
             */
  -        DOM_Node						nextSibling();
  +        DOM_Node		previousNode();
   
           /**
  -          * Moves the TreeWalker to the previous visible node in document order relative to the current node, and returns the new node.
  -          * If the current node
  -          * has no previous node, or if the search for previousNode attempts to step
  -          * upward from the TreeWalker's root node, returns <code>null</code>, and retains the
  -          * current node.
  -          *
  -          * @return  The new node, or null if the current <code>node</code> has no previous node.
  +          * Moves the <code>DOM_TreeWalker</code> to the next visible node in document order
  +          * relative to the current node, and returns the new node. If the current node has
  +          * no next node, 
  +          * or if the search for nextNode attempts to step upward from the DOM_TreeWalker's
  +          * root node, returns <code>null</code>, and retains the current node.
             */
  -        DOM_Node						previousNode();
  +        DOM_Node		nextNode();
  +        //@}
   
  +        /** @name Set functions. */
  +        //@{
           /**
  -          * Moves the TreeWalker to the next visible node in document order relative to the current node, and returns the new node.
  -          * If the current node has no
  -          * next node, or if the search for nextNode attempts to step upward from the
  -          * TreeWalker's root node, returns null, and retains the current node.
  -          * @return The new node, or <code>null</code> if the current node has no next node.
  +          * Set the node at which the DOM_TreeWalker is currently positioned.
             */
  -        DOM_Node						nextNode();
  +        void			setCurrentNode(DOM_Node currentNode);
  +        //@}
   
  +        /** @name Detaching functions. */
  +        //@{
           /**
  -          *	 Detaches the iterator from the set which it iterated over, releasing any computational resources and placing the iterator in the INVALID state.
  -          *  After detach has been invoked, calls to <code>nextNode</code> or <code>previousNode</code>
  -          *  will raise the exception <code>INVALID_STATE_ERR</code>.
  +          * Detaches the iterator from the set which it iterated over, releasing any
  +          * computational resources and placing the iterator in the INVALID state. After
  +          * <code>detach</code> has been invoked, calls to <code>nextNode</code> or
  +          * <code>previousNode</code> will raise the exception INVALID_STATE_ERR.
             */
  -        void							detach();
  +        void			detach();
           //@}
   
  -        DOM_TreeWalker (TreeWalkerImpl* impl);
  -    private:
  -        TreeWalkerImpl*                 fImpl;
  +    protected:
  +        DOM_TreeWalker(TreeWalkerImpl* impl);
   
  -};
  +        friend class DOM_Document;
   
  +    private:
  +        TreeWalkerImpl*         fImpl;
  +};
   
   #endif
  
  
  
  1.6       +4 -1      xml-xerces/c/src/dom/ElementImpl.cpp
  
  Index: ElementImpl.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/ElementImpl.cpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- ElementImpl.cpp	2000/02/06 07:47:32	1.5
  +++ ElementImpl.cpp	2000/02/15 23:17:37	1.6
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: ElementImpl.cpp,v $
  + * Revision 1.6  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.5  2000/02/06 07:47:32  rahulj
    * Year 2K copyright swat.
    *
  @@ -365,7 +370,7 @@
   	oldAttr->setOwnerElement(null);
       
       // This will throw INUSE if necessary
  -    attributes->setNamedItem(newAttr);
  +    attributes->setNamedItemNS(newAttr);
       
       // Attr node reference counting note:
       // If oldAttr's refcount is zero at this point, here's what happens...
  
  
  
  1.3       +9 -8      xml-xerces/c/src/dom/NameNodeFilter.hpp
  
  Index: NameNodeFilter.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/NameNodeFilter.hpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- NameNodeFilter.hpp	2000/02/06 07:47:33	1.2
  +++ NameNodeFilter.hpp	2000/02/15 23:17:37	1.3
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: NameNodeFilter.hpp,v $
  + * Revision 1.3  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.2  2000/02/06 07:47:33  rahulj
    * Year 2K copyright swat.
    *
  @@ -87,20 +92,18 @@
   		NameNodeFilter();
   		virtual ~NameNodeFilter();
   
  -    /** The name to compare with the node name. If null, all node names
  -     *  are successfully matched.
  -     */
  +    // The name to compare with the node name. If null, all node names
  +    //  are successfully matched.
       void setName(DOMString name);
   
  -    /** Return the name to compare with node name. */
  +    // Return the name to compare with node name.
       DOMString getName();
   
  -    /** If match is true, the node name is accepted when it matches.
  -     *  If match is false, the node name is accepted when does not match.
  -     */
  +    // If match is true, the node name is accepted when it matches.
  +    //  If match is false, the node name is accepted when does not match.
       void setMatch(bool match) ;
   
  -    /** Return match value */
  +    // Return match value.
       bool getMatch();
   
       virtual DOM_NodeFilter::FilterAction acceptNode(DOM_Node n);
  
  
  
  1.12      +2 -1      xml-xerces/c/src/dom/NodeImpl.cpp
  
  Index: NodeImpl.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/NodeImpl.cpp,v
  retrieving revision 1.11
  retrieving revision 1.12
  diff -u -r1.11 -r1.12
  --- NodeImpl.cpp	2000/02/10 23:35:11	1.11
  +++ NodeImpl.cpp	2000/02/15 23:17:37	1.12
  @@ -56,9 +56,10 @@
   
   /**
   * $Log: NodeImpl.cpp,v $
  -* Revision 1.11  2000/02/10 23:35:11  andyh
  -* Update DOM_DOMImplementation::CreateDocumentType and
  -* DOM_DocumentType to match latest from W3C
  +* Revision 1.12  2000/02/15 23:17:37  andyh
  +* Update Doc++ API comments
  +* NameSpace bugfix and update to track W3C
  +* Chih Hsiang Chou
   *
   * Revision 1.10  2000/02/06 07:47:33  rahulj
   * Year 2K copyright swat.
  @@ -738,6 +739,7 @@
       DOMString xml = DStringPool::getStaticString("xml", &s_xml);
       DOMString xmlURI = DStringPool::getStaticString("http://www.w3.org/XML/1998/namespace", &s_xmlURI);
       DOMString xmlns = DStringPool::getStaticString("xmlns", &s_xmlns);
  +    DOMString xmlnsURI = DStringPool::getStaticString("http://www.w3.org/2000/xmlns/", &s_xmlnsURI);
   
       if (readOnly)
   	throw DOM_DOMException(DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
  @@ -757,7 +759,7 @@
   	if (*p++ == chColon)	//prefix is malformed
   	    throw DOM_DOMException(DOM_DOMException::NAMESPACE_ERR, null);
       if (fPrefix.equals(xml) && !namespaceURI.equals(xmlURI) ||
  -	fPrefix.equals(xmlns) && namespaceURI != null && namespaceURI.length() != 0)
  +	fPrefix.equals(xmlns) && !namespaceURI.equals(xmlnsURI))
   	throw DOM_DOMException(DOM_DOMException::NAMESPACE_ERR, null);
   
       name = this -> prefix = fPrefix;
  
  
  
  1.4       +14 -12    xml-xerces/c/src/dom/NodeIteratorImpl.hpp
  
  Index: NodeIteratorImpl.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/NodeIteratorImpl.hpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- NodeIteratorImpl.hpp	2000/02/06 07:47:33	1.3
  +++ NodeIteratorImpl.hpp	2000/02/15 23:17:37	1.4
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: NodeIteratorImpl.hpp,v $
  + * Revision 1.4  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.3  2000/02/06 07:47:33  rahulj
    * Year 2K copyright swat.
    *
  @@ -114,7 +119,7 @@
   
   		void detach ();
   
  -        /** Get the expandEntity reference flag. */
  +        // Get the expandEntity reference flag.
           bool getExpandEntityReferences();
   
   
  @@ -122,16 +127,16 @@
   		//
   		// Data
   		//
  -		/** The root. */
  +		// The root.
   		DOM_Node fRoot;
   
  -		/** The whatToShow mask. */
  +		// The whatToShow mask.
   		unsigned long fWhatToShow;
   
  -		/** The NodeFilter reference. */
  +		// The NodeFilter reference.
   		DOM_NodeFilter* fNodeFilter;
   
  -        /** The expandEntity reference flag. */
  +        // The expandEntity reference flag.
           bool  fExpandEntityReferences;
   
   		bool fDetached;
  @@ -147,15 +152,14 @@
   		// (usually akin to whether the node was returned via nextNode())
   		// (eg fForward = true) or previousNode() (eg fForward = false).
   
  -		/** The last Node returned. */
  +		// The last Node returned.
   		DOM_Node fCurrentNode;
   
  -		/** The direction of the iterator on the fCurrentNode.
  -		 *  <pre>
  -		 *  nextNode()  ==      fForward = true;
  -		 *  previousNode() ==   fForward = false;
  -		 *  </pre>
  -		 */
  +		// The direction of the iterator on the fCurrentNode.
  +		//  <pre>
  +		//  nextNode()  ==      fForward = true;
  +		//  previousNode() ==   fForward = false;
  +		//  </pre>
   		bool fForward;
   
   
  
  
  
  1.4       +14 -15    xml-xerces/c/src/dom/NotationImpl.hpp
  
  Index: NotationImpl.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/NotationImpl.hpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- NotationImpl.hpp	2000/02/06 07:47:34	1.3
  +++ NotationImpl.hpp	2000/02/15 23:17:37	1.4
  @@ -58,6 +58,11 @@
   
   /**
    * $Log: NotationImpl.hpp,v $
  + * Revision 1.4  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.3  2000/02/06 07:47:34  rahulj
    * Year 2K copyright swat.
    *
  @@ -104,32 +109,28 @@
       
       virtual NodeImpl *cloneNode(bool deep);
       
  -    /**
  -    * The Public Identifier for this Notation. If no public identifier
  -    * was specified, this will be null.  
  -    */
  +    //
  +    // The Public Identifier for this Notation. If no public identifier
  +    // was specified, this will be null.  
       virtual DOMString getPublicId();
       
  -    /**
  -    * The System Identifier for this Notation. If no system identifier
  -    * was specified, this will be null.  
  -    */
  +    // The System Identifier for this Notation. If no system identifier
  +    // was specified, this will be null.  
       virtual DOMString getSystemId();
       
       
  -    /** Notations never have a nodeValue.
  -    @throws DOMException(NO_MODIFICATION_ALLOWED_ERR)
  -    */
  +    // Notations never have a nodeValue.
  +    // @throws DOMException(NO_MODIFICATION_ALLOWED_ERR)
       virtual void setNodeValue(const DOMString &arg);
       
       
  -    /** NON-DOM: The Public Identifier for this Notation. If no public
  -    identifier was specified, this will be null.  */
  +    // NON-DOM: The Public Identifier for this Notation. If no public
  +    // identifier was specified, this will be null.  */
       virtual void setPublicId(const DOMString &arg);
       
       
  -    /** NON-DOM: The System Identifier for this Notation. If no system
  -    identifier was specified, this will be null.  */
  +    // NON-DOM: The System Identifier for this Notation. If no system
  +    // identifier was specified, this will be null.  */
       virtual void setSystemId(const DOMString &arg);
       
   };
  
  
  
  1.4       +56 -67    xml-xerces/c/src/dom/TreeWalkerImpl.hpp
  
  Index: TreeWalkerImpl.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/dom/TreeWalkerImpl.hpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- TreeWalkerImpl.hpp	2000/02/06 07:47:34	1.3
  +++ TreeWalkerImpl.hpp	2000/02/15 23:17:37	1.4
  @@ -56,6 +56,11 @@
   
   /**
    * $Log: TreeWalkerImpl.hpp,v $
  + * Revision 1.4  2000/02/15 23:17:37  andyh
  + * Update Doc++ API comments
  + * NameSpace bugfix and update to track W3C
  + * Chih Hsiang Chou
  + *
    * Revision 1.3  2000/02/06 07:47:34  rahulj
    * Year 2K copyright swat.
    *
  @@ -95,124 +100,110 @@
       TreeWalkerImpl (const TreeWalkerImpl& twi);
       TreeWalkerImpl& operator= (const TreeWalkerImpl& twi);
   
  -    /** Return the whatToShow value */
  +    // Return the whatToShow value.
       unsigned long  getWhatToShow ();
   
  -    /** Return the NodeFilter */
  +    // Return the NodeFilter.
       DOM_NodeFilter* getFilter ();
   
   	void detach ();
   
  -    /** Return the current DOM_Node. */
  +    // Return the current DOM_Node.
       DOM_Node getCurrentNode ();
   
  -    /** Return the current Node. */
  +    // Return the current Node.
       void setCurrentNode (DOM_Node node);
   
  -    /** Return the parent Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
  +    // Return the parent Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
       DOM_Node parentNode ();
  -
  -    /** Return the first child Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
   
  +    // Return the first child Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
       DOM_Node firstChild ();
  -
  -    /** Return the last child Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
   
  +    // Return the last child Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
       DOM_Node lastChild ();
   
  -    /** Return the previous sibling Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
  -
  +    // Return the previous sibling Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
       DOM_Node previousSibling ();
  +
  +    // Return the next sibling Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
   
  -    /** Return the next sibling Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
       DOM_Node nextSibling ();
  -    /** Return the previous Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
  +    // Return the previous Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
       DOM_Node previousNode ();
   
  -    /** Return the next Node from the current node,
  -     *  after applying filter, whatToshow.
  -     *  If result is not null, set the current Node.
  -     */
  +    // Return the next Node from the current node,
  +    //  after applying filter, whatToshow.
  +    //  If result is not null, set the current Node.
       DOM_Node nextNode ();
   
       void unreferenced ();
       
  -    /** Get the expandEntity reference flag. */
  +    // Get the expandEntity reference flag.
       bool getExpandEntityReferences();
   
   protected:
   
  -    /** Internal function.
  -     *  Return the parent Node, from the input node
  -     *  after applying filter, whatToshow.
  -     *  The current node is not consulted or set.
  -     */
  +    // Internal function.
  +    //  Return the parent Node, from the input node
  +    //  after applying filter, whatToshow.
  +    //  The current node is not consulted or set.
       DOM_Node getParentNode (DOM_Node node);
   
  -    /** Internal function.
  -     *  Return the nextSibling Node, from the input node
  -     *  after applying filter, whatToshow.
  -     *  The current node is not consulted or set.
  -     */
  +    // Internal function.
  +    //  Return the nextSibling Node, from the input node
  +    //  after applying filter, whatToshow.
  +    //  The current node is not consulted or set.
       DOM_Node getNextSibling (DOM_Node node);
   
  -    /** Internal function.
  -     *  Return the previous sibling Node, from the input node
  -     *  after applying filter, whatToshow.
  -     *  The current node is not consulted or set.
  -     */
  +    // Internal function.
  +    //  Return the previous sibling Node, from the input node
  +    //  after applying filter, whatToshow.
  +    //  The current node is not consulted or set.
       DOM_Node getPreviousSibling (DOM_Node node);
   
  -    /** Internal function.
  -     *  Return the first child Node, from the input node
  -     *  after applying filter, whatToshow.
  -     *  The current node is not consulted or set.
  -     */
  +    // Internal function.
  +    //  Return the first child Node, from the input node
  +    //  after applying filter, whatToshow.
  +    //  The current node is not consulted or set.
       DOM_Node getFirstChild (DOM_Node node);
   
  -    /** Internal function.
  -     *  Return the last child Node, from the input node
  -     *  after applying filter, whatToshow.
  -     *  The current node is not consulted or set.
  -     */
  +    // Internal function.
  +    //  Return the last child Node, from the input node
  +    //  after applying filter, whatToshow.
  +    //  The current node is not consulted or set.
       DOM_Node getLastChild (DOM_Node node);
   
  -    /** The node is accepted if it passes the whatToShow and the filter. */
  +    // The node is accepted if it passes the whatToShow and the filter.
       short acceptNode (DOM_Node node);
   
       		
   private:
  -    /** The whatToShow mask. */
  +    // The whatToShow mask.
       unsigned long fWhatToShow;
   
  -    /** The NodeFilter reference. */
  +    // The NodeFilter reference.
       DOM_NodeFilter* fNodeFilter;
   
  -    /** The current Node. */
  +    // The current Node.
       DOM_Node fCurrentNode;
   
  -    /** The root Node. */
  +    // The root Node.
       DOM_Node fRoot;
   
  -    /** The expandEntity reference flag. */
  +    // The expandEntity reference flag.
       bool fExpandEntityReferences;
   
   	bool fDetached;