package net.sf.logdistiller.xml;
   
   /*
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  
  /**
   * Miscellaneous utilities for DOM.
   */
  public class DOMUtils
  {
      private DOMUtils()
      {
      }
  
      public static String getPCDATAByTagName( Element elmt, String tagName )
      {
          return getPCDATAByTagName( elmt, tagName, false );
      }
  
      public static String getPCDATAByTagName( Element elmt, String tagName, boolean normalize )
      {
          Iterator<Element> iter = getChildElementsByTagName( elmt, tagName );
          if ( !iter.hasNext() )
          {
              return null;
          }
          return getPCDATA( (Element) iter.next(), normalize );
      }
  
      /**
       * Computes the resulting string of a <code>#PCDATA</code> element: it can consist in the XML document of a
       * combination of nodes Text, EntityReference and CDATASection, with Comment.
       *
       * @param normalize normalize the element before computing?
       */
      public static String getPCDATA( Element element, boolean normalize )
      {
          if ( normalize )
          {
              element.normalize();
          }
          StringBuffer buff = new StringBuffer();
          NodeList list = element.getChildNodes();
          int len = list.getLength();
          for ( int i = 0; i < len; i++ )
          {
              Node n = list.item( i );
              switch ( n.getNodeType() )
              {
                  case Node.TEXT_NODE:
                  case Node.CDATA_SECTION_NODE:
                      buff.append( n.getNodeValue() );
                      break;
                  case Node.ENTITY_REFERENCE_NODE:
                      buff.append( n.getFirstChild().getNodeValue() );
                      break;
                  case Node.COMMENT_NODE:
                      break; // ignore comments
                  default: // should not occur if really #PCDATA
                      throw new IllegalArgumentException( "element '" + element.getNodeName()
                          + "' is not #PCDATA because it " + "contains a " + getNodeTypeAsString( n ) + " node" );
              }
          }
          return buff.toString();
      }
  
      public static String getPCDATA( Element elmt )
      {
          return getPCDATA( elmt, false );
      }
  
      public static Iterator<Element> getChildElementsByTagName( Element element, String tagName )
      {
          return new ElementIterator( element.getChildNodes(), tagName );
      }
  
      public static String getNodeTypeAsString( Node node )
      {
          int type = node.getNodeType();
          switch ( type )
          {
              case Node.ELEMENT_NODE:
                 return "Element";
             case Node.ATTRIBUTE_NODE:
                 return "Attribute";
             case Node.TEXT_NODE:
                 return "Text";
             case Node.CDATA_SECTION_NODE:
                 return "CDATASection";
             case Node.ENTITY_REFERENCE_NODE:
                 return "EntityReference";
             case Node.ENTITY_NODE:
                 return "Entity";
             case Node.PROCESSING_INSTRUCTION_NODE:
                 return "ProcessingInstruction";
             case Node.COMMENT_NODE:
                 return "Comment";
             case Node.DOCUMENT_NODE:
                 return "Document";
             case Node.DOCUMENT_TYPE_NODE:
                 return "DocumentType";
             case Node.DOCUMENT_FRAGMENT_NODE:
                 return "DocumentFragment";
             case Node.NOTATION_NODE:
                 return "Notation";
             default:
         }
         return "Unknown node type: " + type;
     }
 
     private static class ElementIterator
         implements Iterator<Element>
     {
         private final NodeList nodeList;
 
         private final String tagName;
 
         private int index;
 
         private Element next;
 
         public ElementIterator( NodeList nodeList, String tagName )
         {
             this.nodeList = nodeList;
             this.tagName = tagName;
             findNext();
         }
 
         public boolean hasNext()
         {
             return ( next != null );
         }
 
         private void findNext()
         {
             while ( index < nodeList.getLength() )
             {
                 Node node = nodeList.item( index );
                 index++;
                 if ( ( node.getNodeType() == Node.ELEMENT_NODE )
                     && ( ( tagName == null ) || node.getNodeName().equals( tagName ) ) )
                 {
                     // next element found
                     next = (Element) node;
                     return;
                 }
             }
             // no element available any more
             next = null;
         }
 
         public Element next()
         {
             if ( next == null )
             {
                 throw new NoSuchElementException();
             }
             Element returnValue = next;
             findNext();
             return returnValue;
         }
 
         public void remove()
         {
             throw new UnsupportedOperationException();
         }
     }
 }