/*******************************************************************************
 * Copyright (c) 2002-2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   IBM - Initial API and implementation
 ********************************************************************************/
package org.eclipse.wst.wsi.internal.core.util;

/**
 * String tokenizer.
 * 
 * @author: Kulik
 */
final public class StringTokenizer
{
  private char[] spaceDel;
  private char[] del;
  private char[] allDel;

  /**
   * Enumeration of strings.
  * @author Kulik
   */
  private class StringTokenizerEnumeration implements java.util.Enumeration
  {
    private final char[] str;
    private final int size;
    private int index;

    /**
     * Constructor.
     * @param s
     */
    StringTokenizerEnumeration(char[] s)
    {
      str = s;
      size = str.length;
      index = 0;

      // skip space delimiters
      while (index < size && contain(str[index], spaceDel))
        index++;
    }

    /**
     * @see java.util.Enumeration#hasMoreElements()
     */
    public boolean hasMoreElements()
    {
      return (index < size);
    }

    /**
     * @see java.util.Enumeration#nextElement()
     */
    public Object nextElement()
    {
      if (index >= size)
        throw new java.util.NoSuchElementException(
          "StringTokenizer enumeration");

      // skip delimiters
      int begStr = index;
      if (index < size && contain(str[index], del))
        index++;

      // skip word
      if (begStr == index)
        while (index < size && !contain(str[index], allDel))
          index++;

      int endStr = index;

      // skip space delimiters
      while (index < size && contain(str[index], spaceDel))
        index++;

      return String.copyValueOf(str, begStr, endStr - begStr);
    }

    /**
     * @see java.lang.Object#toString()
     */
    public String toString()
    {
      int i = index;
      String s = (String) nextElement();
      index = i;
      return s;
    }
  }

  /**
   * StringTokenizer constructor.
     * @param spaceDelimiters the set of delimiters to be ignored
     * @param delimiters the set of delimiters to be remained.
   */
  public StringTokenizer(char[] spaceDelimiters, char[] delimiters)
  {
    super();

    if (spaceDelimiters != null)
    {
      spaceDel = new char[spaceDelimiters.length];
      System.arraycopy(spaceDelimiters, 0, spaceDel, 0, spaceDelimiters.length);
      sort(spaceDel);
    }
    else
      spaceDel = null;

    if (delimiters != null)
    {
      del = new char[delimiters.length];
      System.arraycopy(delimiters, 0, del, 0, delimiters.length);
      sort(del);
    }
    else
      del = null;

    if (del != null && spaceDel != null)
    {
      allDel = new char[del.length + spaceDel.length];
      System.arraycopy(del, 0, allDel, 0, del.length);
      System.arraycopy(spaceDel, 0, allDel, del.length, spaceDel.length);
    }
    else if (del != null)
      allDel = del;
    else
      allDel = spaceDel;

    sort(allDel);
  }
  /**
   * Parses string.
   * @return java.util.Enumeration
   * @param s java.lang.String
   */
  public java.util.Enumeration parse(String s)
  {
    if (s == null)
      throw new IllegalArgumentException("StringTokenizer : String cannot be NULL");

    return new StringTokenizerEnumeration(s.toCharArray());
  }

  /**
   * Binary search.
   * @return boolean
   * @param c char
   */
  private static boolean contain(char c, char[] a)
  {
    if (a == null)
      return false;

    int l = 0, r = a.length - 1, center;
    while (l < r)
    {
      center = (l + r) / 2;
      if (c > a[center])
        l = center + 1;
      else
        r = center;
    }

    return a[l] == c;
  }
  /**
   * Heap sort
   * @param c char[]
   */
  static private void sort(char[] c)
  {
    if (c != null)
    {
      int j, k;
      char ci;

      // push heap
      for (int i = 1; i < c.length; i++)
      {
        j = ((k = i) - 1) / 2;
        ci = c[i];
        while (k > 0 && c[j] < ci)
        {
          c[k] = c[j];
          j = ((k = j) - 1) / 2;
        }
        c[k] = ci;
      }

      // pop heap
      for (int i = c.length - 1; i > 0; i--)
      {
        j = 2;
        k = 0;
        ci = c[0];
        while (j <= i)
        {
          c[k] = (c[j - 1] > c[j]) ? c[--j] : c[j];
          j = ((k = j) + 1) * 2;
        }
        c[k] = c[i];
        c[i] = ci;
      }
    }
  }
}