* Copyright (c) 2000, 2012 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 Corporation - initial API and implementation

*******************************************************************************/

* Provides convenient utility methods to other types in this package.

*/

  public interface Comparable {

    /**

     * Returns 0 if this and c are equal, >0 if this is greater than c,

     * or <0 if this is less than c.

     */

    int compareTo(Comparable c);

  }

  public interface Comparer {

    /**

     * Returns 0 if a and b are equal, >0 if a is greater than b,

     * or <0 if a is less than b.

     */

    int compare(Object a, Object b);

  }

    public org.eclipse.jdt.internal.compiler.ast.ASTNode get(Binding binding);

  }

  private static final char ARGUMENTS_DELIMITER = '#';

  private static final String EMPTY_ARGUMENT = "   "; //$NON-NLS-1$

  private static char[][] JAVA_LIKE_EXTENSIONS;

  private static final char[] BOOLEAN = "boolean".toCharArray(); //$NON-NLS-1$

  private static final char[] BYTE = "byte".toCharArray(); //$NON-NLS-1$

  private static final char[] CHAR = "char".toCharArray(); //$NON-NLS-1$

  private static final char[] DOUBLE = "double".toCharArray(); //$NON-NLS-1$

  private static final char[] FLOAT = "float".toCharArray(); //$NON-NLS-1$

  private static final char[] INT = "int".toCharArray(); //$NON-NLS-1$

  private static final char[] LONG = "long".toCharArray(); //$NON-NLS-1$

  private static final char[] SHORT = "short".toCharArray(); //$NON-NLS-1$

  private static final char[] VOID = "void".toCharArray(); //$NON-NLS-1$

  private static final char[] INIT = "<init>".toCharArray(); //$NON-NLS-1$

  private static final String TASK_PRIORITIES_PROBLEM = "TASK_PRIORITIES_PB"; //$NON-NLS-1$

  private static List fgRepeatedMessages= new ArrayList(5);

  private Util() {

    // cannot be instantiated

  }

  /**

   * Returns a new array adding the second array at the end of first array.

   * It answers null if the first and second are null.

   * If the first array is null or if it is empty, then a new array is created with second.

   * If the second array is null, then the first array is returned.

   * <br>

   * <br>

   * For example:

   * <ol>

   * <li><pre>

   *    first = null

   *    second = "a"

   *    => result = {"a"}

   * </pre>

   * <li><pre>

   *    first = {"a"}

   *    second = null

   *    => result = {"a"}

   * </pre>

   * </li>

   * <li><pre>

   *    first = {"a"}

   *    second = {"b"}

   *    => result = {"a", "b"}

   * </pre>

   * </li>

   * </ol>

   *

   * @param first the first array to concatenate

   * @param second the array to add at the end of the first array

   * @return a new array adding the second array at the end of first array, or null if the two arrays are null.

   */

  public static final String[] arrayConcat(String[] first, String second) {

    if (second == null)

      return first;

    if (first == null)

      return new String[] {second};

    int length = first.length;

    if (first.length == 0) {

      return new String[] {second};

    }

    String[] result = new String[length + 1];

    System.arraycopy(first, 0, result, 0, length);

    result[length] = second;

    return result;

  }

  /**

   * Checks the type signature in String sig,

   * starting at start and ending before end (end is not included).

   * Returns the index of the character immediately after the signature if valid,

   * or -1 if not valid.

   */

  private static int checkTypeSignature(String sig, int start, int end, boolean allowVoid) {

    if (start >= end) return -1;

    int i = start;

    char c = sig.charAt(i++);

    int nestingDepth = 0;

    while (c == '[') {

      ++nestingDepth;

      if (i >= end) return -1;

      c = sig.charAt(i++);

    }

    switch (c) {

      case 'B':

      case 'C':

      case 'D':

      case 'F':

      case 'I':

      case 'J':

      case 'S':

      case 'Z':

        break;

      case 'V':

        if (!allowVoid) return -1;

        // array of void is not allowed

        if (nestingDepth != 0) return -1;

        break;

      case 'L':

        int semicolon = sig.indexOf(';', i);

        // Must have at least one character between L and ;

        if (semicolon <= i || semicolon >= end) return -1;

        i = semicolon + 1;

        break;

      default:

        return -1;

    }

    return i;

  }

  /**

   * Combines two hash codes to make a new one.

   */

  public static int combineHashCodes(int hashCode1, int hashCode2) {

    return hashCode1 * 17 + hashCode2;

  }

  /**

   * Compares two byte arrays.

   * Returns <0 if a byte in a is less than the corresponding byte in b, or if a is shorter, or if a is null.

   * Returns >0 if a byte in a is greater than the corresponding byte in b, or if a is longer, or if b is null.

   * Returns 0 if they are equal or both null.

   */

  public static int compare(byte[] a, byte[] b) {

    if (a == b)

      return 0;

    if (a == null)

      return -1;

    if (b == null)

      return 1;

    int len = Math.min(a.length, b.length);

    for (int i = 0; i < len; ++i) {

      int diff = a[i] - b[i];

      if (diff != 0)

        return diff;

    }

    if (a.length > len)

      return 1;

    if (b.length > len)

      return -1;

    return 0;

  }

  /**

   * Compares two strings lexicographically.

   * The comparison is based on the Unicode value of each character in

   * the strings.

   *

   * @return  the value <code>0</code> if the str1 is equal to str2;

   *          a value less than <code>0</code> if str1

   *          is lexicographically less than str2;

   *          and a value greater than <code>0</code> if str1 is

   *          lexicographically greater than str2.

   */

  public static int compare(char[] str1, char[] str2) {

    int len1= str1.length;

    int len2= str2.length;

    int n= Math.min(len1, len2);

    int i= 0;

    while (n-- != 0) {

      char c1= str1[i];

      char c2= str2[i++];

      if (c1 != c2) {

        return c1 - c2;

      }

    }

    return len1 - len2;

  }

  /**

   * Concatenate a String[] compound name to a continuous char[].

   */

  public static char[] concatCompoundNameToCharArray(String[] compoundName) {

    if (compoundName == null) return null;

    int length = compoundName.length;

    if (length == 0) return new char[0];

    int size = 0;

    for (int i=0; i<length; i++) {

      size += compoundName[i].length();

    }

    char[] compoundChars = new char[size+length-1];

    int pos = 0;

    for (int i=0; i<length; i++) {

      String name = compoundName[i];

      if (i > 0) compoundChars[pos++] = '.';

      int nameLength = name.length();

      name.getChars(0, nameLength, compoundChars, pos);

      pos += nameLength;

    }

    return compoundChars;

  }

  public static String concatenateName(String name1, String name2, char separator) {

    StringBuffer buf= new StringBuffer();

    if (name1 != null && name1.length() > 0) {

      buf.append(name1);

    }

    if (name2 != null && name2.length() > 0) {

      if (buf.length() > 0) {

        buf.append(separator);

      }

      buf.append(name2);

    }

    return buf.toString();

  }

  /**

   * Returns the concatenation of the given array parts using the given separator between each part.

   * <br>

   * <br>

   * For example:<br>

   * <ol>

   * <li><pre>

   *    array = {"a", "b"}

   *    separator = '.'

   *    => result = "a.b"

   * </pre>

   * </li>

   * <li><pre>

   *    array = {}

   *    separator = '.'

   *    => result = ""

   * </pre></li>

   * </ol>

   *

   * @param array the given array

   * @param separator the given separator

   * @return the concatenation of the given array parts using the given separator between each part

   */

  public static final String concatWith(String[] array, char separator) {

    StringBuffer buffer = new StringBuffer();

    for (int i = 0, length = array.length; i < length; i++) {

      buffer.append(array[i]);

      if (i < length - 1)

        buffer.append(separator);

    }

    return buffer.toString();

  }

  /**

   * Returns the concatenation of the given array parts using the given separator between each

   * part and appending the given name at the end.

   * <br>

   * <br>

   * For example:<br>

   * <ol>

   * <li><pre>

   *    name = "c"

   *    array = { "a", "b" }

   *    separator = '.'

   *    => result = "a.b.c"

   * </pre>

   * </li>

   * <li><pre>

   *    name = null

   *    array = { "a", "b" }

   *    separator = '.'

   *    => result = "a.b"

   * </pre></li>

   * <li><pre>

   *    name = " c"

   *    array = null

   *    separator = '.'

   *    => result = "c"

   * </pre></li>

   * </ol>

   *

   * @param array the given array

   * @param name the given name

   * @param separator the given separator

   * @return the concatenation of the given array parts using the given separator between each