Source code: com/aendvari/common/osm/OsmReader.java

   /*
    * OsmReader.java
    *
    * Copyright (c) 2001, 2002 Aendvari, Ltd. All Rights Reserved.
    *
    * See the file LICENSE for terms of use.
    *
    */
   
  package com.aendvari.common.osm;
  
  import java.io.Reader;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.StringTokenizer;
  
  import com.aendvari.common.osm.*;
  import com.aendvari.common.util.*;
  
  
  /**
   * <p>This class reads an "XML-like" file and converts it into an Osm tree.</p>
   *
   * <p>
   * NOTE: The file uses a subset of the XML syntax. This class is <b>NOT</b> an
   * XML parser, but instead the files used by this reader are able to be read
   * by other XML parsers.
   * </p>
   *
   * @author  Scott Milne
   *
   */
  
  public class OsmReader
  {
    /* Attributes */
  
    /** The current line number being read. */
    protected static int currentLine;
  
    /** The line number of the last known "open" tag. */
    protected static int lastOpenTagLine;
  
    /** The name of the last known "open" tag. */
    protected static String lastOpenTag;
  
  
    /* Constants. */
  
  
    /** Special characters that need to be converted into their text values */
    protected static String specialCharacters[][] = {
  
      { "&amp;", "&" },
      { "&lt;", "<" },
      { "&gt;", ">" },
      { "&quot;", "\"" },
      { "&apos;", "'" },
  
    };
  
    /** An interface for setting the current state of a read. */
    protected interface State
    {
      public static final int Normal  = 1;
      public static final int Tag    = 2;
      public static final int Body  = 3;
      public static final int Ignore  = 4;
    }
  
  
    /**
     * Parses a buffered stream into the reader.
     *
     * @param    bufferedReader        A {@link Reader} instance.
     *
     * @throws                  Exception if parse fails.
     *
     */
  
    public static Osm read( Reader bufferedReader )
      throws Exception
    {
      return executeRead(bufferedReader);
    }
  
    /**
     * Initializes the OSM with the data from the reader.
     *
     * @param    bufferedReader        A {@link Reader} instance.
     *
     */
  
    private static Osm executeRead( Reader bufferedReader )
      throws Exception
    {
      Osm rootOsm = new Osm();
  
     readBuffer( bufferedReader, rootOsm, State.Normal );
 
     return rootOsm;
   }
 
   /**
    * Reads the buffer character by character matching with < and > to determine
    * tags, and their contents.
    *
    * @param    reader          A {@link Reader} instance.
    * @param    node          A {@link OsmNode} instance.
    * @param    readState        The state in which the read is currently in.
    *
    */
 
   private static void readBuffer( Reader reader, OsmNode node, int readState )
     throws Exception
   {
     int read;
     char ch;
     String data = "";
 
     // as long as we're not at the end of the buffer
     while ((read = reader.read()) != -1)
     {
       ch = (char)read;
 
       //
       // adjust the current line if possible
       //
 
       // \r\n
       if (ch == '\r' && peekMatch(reader, "\n"))
       {
         data += ch;
         currentLine++;
       }
       // \r only
       else if (ch == '\r' && !peekMatch(reader, "\n"))
       {
         data += ch;
         currentLine++;
       }
       // \n only
       else if (ch == '\n' && !data.endsWith("\r") )
       {
         data += ch;
         currentLine++;
       }
 
 
       //
       // collect each <tag> their body, and their children
       //
 
       // if a < is found we're opening a tag
       if (ch == '<')
       {
         // check to see if this is a comment
         if (peekMatch(reader, "!--") || peekMatch(reader, "?"))
         {
           // continue reading, but set the state to ignore
           readBuffer(reader,node,State.Ignore);
         }
         // as long as the current read state is not ignore
         else if (readState != State.Ignore)
         {
           // if we were working on a body, then this is the start of the end tag for that body
           if (readState == State.Body)
           {
             // get the current data from the node
             String value = (String)node.getNodeValue();
 
             // convert the special characters of the body
             // and add it to the previous node data
             value += convertSpecialCharacters(data);
 
             // set the new body data into the node
             node.setNodeValue(value);
 
             // reset the data string for the next tag
             data = "";
           }
 
           // add this character to the data string in case were also
           // building another tag
           data += ch;
         }
         // we're currently ignoring this data, so collect it up without parsing it
         else
         {
           data += ch;
         }
       }
       // if this character is found, we're closing a tag
       else if (ch == '>')
       {
         data += ch;
 
         // check to see if the characters before this were within a comment
         // if so, break out of this loop so that the ignore state will be reset
         if ( data.endsWith("-->") || data.endsWith("?>") )
         {
           break;
         }
         // if the read state is not currently ignore
         else if (readState != State.Ignore)
         {
           // check to see if this is a closing tag
           // if so, then we are ending a body
           if (data.startsWith("</"))
           {
             // get the name of the node from the tag
             String nodeName = nodeNameFromTag(data);
 
             // if this tag is the same as the parent of the current node
             // then we don't have a correct closing tag. Throw and error.
             if (nodeName.equals(node.getParentNode().getNodeName()))
             {
               throw new Exception("Opening tag \""+lastOpenTag+"\" does not have a closing tag. Line "+lastOpenTagLine+".");
             }
 
             break;
           }
           // otherwise we are starting a body
           else
           {
             // create the new node
             OsmNode newNode = nodeFromTag(node.getOwnerOsm(), data);
             node.appendChild(newNode);
 
             // if this tag has a body, get it
             if (!data.endsWith("/>"))
             {
               String nodeName = nodeNameFromTag(data);
               lastOpenTag = nodeName;
               lastOpenTagLine = currentLine;
 
               // continue reading, but set the state flag to body
               readBuffer(reader,newNode,State.Body);
             }
 
             // now extract the attributes from the tag
             extractTagAttributes( newNode, data );
 
             // reset the data string for the next tag
             data = "";
           }
         }
       }
       // collect every other character (usually body or ignored content)
       else
       {
         data += ch;
       }
     }
   }
 
   /**
    * Extracts the name of a node from the tag.
    *
    * @param    tag            The &lt;tag&gt; to extract the name from.
    *
    * @return                The value within the tag representing the node name.
    *
    */
 
   private static String nodeNameFromTag( String tag )
   {
     String trimTag = tag.trim();
 
     // we only want the text up to the first space
     // ie: <mytag attr="something">
     // we only want "<mytag"
     int endIndex = trimTag.indexOf(" ");
     if (endIndex == -1)
     {
       // if there was a "/>" adjust the end index to before it
       endIndex = trimTag.indexOf("/>");
       if (endIndex == -1)
       {
         // othewise set the end index to the last character ">"
         endIndex = trimTag.length() - 1;
       }
     }
 
     // determine where to start
     int startIndex = 1;
     if (trimTag.startsWith("</"))
     {
       startIndex = 2;
     }
 
     String nodeName = trimTag.substring(startIndex,endIndex);
 
     return nodeName;
   }
 
   /**
    * Create a new OsmNode from the given &lt;tag&gt;.
    *
    * @param    node          The {@link Osm} to create a new {@link OsmNode} from.
    * @param    tag            The &lt;tag&gt; to create an {@link OsmNode} from.
    *
    * @return                The new {@link OsmNode}.
    *
    */
 
   private static OsmNode nodeFromTag( Osm osm, String tag )
   {
     String nodeName = nodeNameFromTag(tag);
     OsmNode newNode = osm.createNode(nodeName, "");
     return newNode;
   }
 
   /**
    * Extract the attributes from a &lt;tag&gt;.
    *
    * @param    node          The {@link OsmNode} to place the attributes into.
    * @param    tag            The &lt;tag&gt; to extract the attributes from.
    *
    */
 
   private static void extractTagAttributes( OsmNode node, String tag )
     throws Exception
   {
     // strip off the < and /> from the tag
     tag = tag.replace('<',' ');
     tag = tag.replace('>',' ');
     tag = tag.trim();
 
     // now that the brackets are gone, remove the / trailing or leading
 
     // ie: </tag> --> /tag
     if (tag.startsWith("/"))
     {
       tag = tag.substring(1);
     }
 
     // ie: <tag/> --> tag/
     if (tag.endsWith("/"))
     {
       tag = tag.substring(0, tag.length()-1);
     }
     
     // trim all whitespace again
     tag = tag.trim();
 
     // parse path
     StringTokenizer tokens = new StringTokenizer(tag, " ", false);
 
     while (tokens.hasMoreTokens())
     {
       // get attribute
       String attribute = tokens.nextToken();
 
       if (attribute.equals(node.getNodeName()))
       {
         continue;
       }
 
       // get the attribute name
       int index;
 
       index = attribute.indexOf("=\"");
       if (index != -1)
       {
         String attrName = attribute.substring(0, index);
 
         // get the attribute value
         int oldIndex = index + 2;
         index = attribute.indexOf("\"", oldIndex);
         if (index != -1)
         {
           String attrValue = attribute.substring(oldIndex, index);
 
           // set the attribute into the node
           node.setAttribute( attrName, attrValue );
         }
         else
         {
           throw new Exception("Invalid attribute definition 1. Line "+currentLine+".");
         }
       }
       else
       {
         throw new Exception("Invalid attribute definition 2. Line "+currentLine+".");
       }
     }
   }
 
   /**
    * Peeks into the read stream to see if the given string matches the same number of characters
    * in the upcoming stream.
    *
    * @param    reader          The <code>Reader</code> stream to peek into.
    * @param    match          The string to attempt to match with.
    *
    * @return                True if the string matches.
    *
    */
 
   private static boolean peekMatch( Reader reader, String match )
     throws Exception
   {
     String value = "";
     int len = match.length();
 
     char ch;
     int index = 0;
 
     // mark the buffer so we can return to the correct location
     reader.mark(len+1);
 
     while ((ch=(char)reader.read())!=-1 && index<len)
     {
       // if the end of the file was found
       if (ch == -1)
       {
         return false;
       }
 
       value += ch;
       index++;
     }
 
     // reset back to original location
     reader.reset();
 
     return value.equals(match);
   }
 
   /**
    * Converts the special characters of a string into their secondary form.
    *
    * @param    data          The string to convert special characters of.
    *
    * @return                Alternative form of string.
    *
    */
 
   private static String convertSpecialCharacters( String data )
   {
     int i;
 
     for (i=0; i<specialCharacters.length; i++)
     {
       data = replaceAll(data, specialCharacters[i][0], specialCharacters[i][1]);
     }
 
     return data;
   }
 
   /**
    * Replaces all the matching values of a string with their replacement value.
    *
    * @param    source          The string to replace the values of.
    * @param    original        The original value to search for.
    * @param    replace          The string to replace the original value with.
    *
    * @return                Updated string.
    *
    */
 
   private static String replaceAll( String source, String original, String replace )
   {
     int index;
 
     while ((index=source.indexOf(original)) != -1)
     {
       String start = source.substring(0, index);
       String end = source.substring(index+original.length(), source.length());
 
       source = start + replace + end;
     }
 
     return source;
   }
 }