//-< ArrayOfChar.java >----------------------------------------------*--------*
// GOODS                      Version 2.02       (c) 1998  GARRET    *     ?  *
// (Generic Object Oriented Database System)                         *   /\|  *
// GOODS Persistent Class Library                                    *  /  \  *
//                          Created:      1-Oct-98    K.A. Knizhnik  * / [] \ *
//                          Last update: 15-Oct-98    K.A. Knizhnik  * GARRET *
//-------------------------------------------------------------------*--------*
// Dynamic array of chars
//-------------------------------------------------------------------*--------*

package goodslib;
import  goodsjpi.*;

/**
 *  <code>ArrayOfChar</code> is just that, an array of chars.  It is fully 
 * persistent, as it it's derived from Persistent. All reads cause a fetch of the
 * data, all writes mark it dirty and to be saved.
 *
 * @author   K.A. Knizhnik
 * @version 1.0
 */
public class ArrayOfChar extends AnyArray implements Comparable { 
  /**
   *  <code>array</code> holds the chars in an  []
   */
    protected char[] array;

  /**
   * Creates a new <code>ArrayOfChar</code> instance.
   *
   * @param size  is the initial size, (length)
   */
    public ArrayOfChar(int size) {
	this(size, size == 0 ? 16 : size);
    }

  /**
   * Creates a new <code>ArrayOfChar</code> instance. (Full of false)
   *
   * @param size , or length of the array
   * @param allocatedSize is the size it can grow to without re-sizing
   */
     public ArrayOfChar(int size, int allocatedSize) {
	Assert.that(size <= allocatedSize);
	array = new char[allocatedSize];
	used = size;
    }
    
  /**
   * Creates a new <code>ArrayOfChar</code> instance, as a copy of the given 
   * char[]
   *
   * @param src a <code>char[]</code> that will be copied
   */
    public ArrayOfChar(char[] src) { 
	int length = src.length;
	array = new char[length];
	used = length;
	System.arraycopy(src, 0, array, 0, length);
    }

  /**
   * Creates a new <code>ArrayOfChar</code> instance.
   *
   * @param str a <code>String</code> value
   */
  public ArrayOfChar(String str) { 
	int length = str.length();
	array = new char[length];
	used = length;
	str.getChars(0, length, array, 0);
    }

  /**
   * Put a char value at a given index
   *
   * @param index an <code>int</code> value, where the value should be set 
   * @param value the <code>char</code> value to be set
   */
    public synchronized void putAt(int index, char value) { 
        if (index < 0 || index >= used) { 
	    throw new ArrayIndexOutOfBoundsException(index);
	}
	Metaobject.modify();
	array[index] = value;
    }

  /**
   * Get a char at the specified index
   *
   * @param index of the char you want
   * @return a <code>char</code> value, at index "index"
   */
     public synchronized char getAt(int index) { 
        if (index < 0 || index >= used) { 
	    throw new ArrayIndexOutOfBoundsException(index);
	}
	return array[index];
    }
    

  /**
   * Resize the amount of space taken by the array. Either grow or shrink as 
   * necessary. You get an IndexOutOfBoundException for negative values. <br>
   * of course the old data is copied.
   *
   * @param newSize an <code>int</code> denoting the new size.
   */
     public synchronized void changeSize(int newSize) { 
        if (newSize < 0) { 
	    throw new ArrayIndexOutOfBoundsException(newSize);
	}
        int allocated = array.length;
	if (newSize > allocated) {
	    allocated = (allocated*2 > newSize) ? allocated*2 : newSize;
	    char[] newArray = new char[allocated];
	    System.arraycopy(array, 0, newArray, 0, used);
	    array = newArray;
	} else if (newSize < used) { 
	    for (int i = used; --i >= newSize; array[i] = 0);
	}
	used = newSize;
    }


  /**
   *  <code>insert</code> a "count" amount of values  at a given index. Throws an 
   * IndexOutOfBoundsException for too small (<0) or too big (>length) count or index.
   *
   * @param index , where to start inserting value(s)
   * @param count , how many values to insert
   * @param value a <code>char</code> value to insert
   */
   public synchronized void insert(int index, int count, char value) { 
	if (count < 0) { 
	    throw new ArrayIndexOutOfBoundsException(count);
	} else if (index < 0 || index > used) { 
	    throw new ArrayIndexOutOfBoundsException(index);
	}
	changeSize(used+count);
	System.arraycopy(array, index, array, index+count, used-index-count);
	while (--count >= 0) { 
	    array[index++] = value;
	}
    }

  /**
   * <code>remove</code> a number of values. The array shrinks in it's length, but no
   * resizing is done. Get an IndexOutOfBoundsException for inappropriate index or
   * count values.
   *
   * @param index , where to start removing
   * @param count , how many values to remove
   */
    public synchronized void remove(int index, int count) {
	if (count < 0) { 
	    throw new ArrayIndexOutOfBoundsException(count);
	} else if (index < 0) { 
	    throw new ArrayIndexOutOfBoundsException(index);
	} else if (index+count > used) { 
	    throw new ArrayIndexOutOfBoundsException(index+count);
	}
	System.arraycopy(array, index+count, array, index, used-count-index);
	changeSize(used-count);
    }


  /**
   *  Use the array as a stack with the <code>push</code> method.
   *
   * @param value , a <code>char</code> to push to the stack
   */
    public synchronized void push(char value) { 
	changeSize(used+1);
	array[used-1] = value;
    }

  /**
   * Use the array as a stack and <code>pop</code> a value. (Value is removed)
   * IndexOutOfBoundsExceptions comes when array has hit 0 length.
   *
   * @return the top most <code>char</code> value
   */
    public synchronized char pop() { 
	if (used == 0) { 
	    throw new ArrayIndexOutOfBoundsException(0);
	}
	char value = array[--used];
	array[used] = 0;
	return value;
    }

   /**
   * Check the top boolean with the <code>top</code> method. This returns what 
   * <code>pop</code> returns, just it doesn't remove the value. In other stack
   * implementations it may be called peek()
   *
   * @return a <code>char</code> value
   */
    public synchronized char top() { 
	if (used == 0) { 
	    throw new ArrayIndexOutOfBoundsException(0);
	}
	return array[used-1];
    }


  /**
   *  <code>append</code> add the given values to the end of the array
   *
   * @param tail a <code>char[]</code> that will be appended
   */
    public synchronized void append(char[] tail) { 
        int size = used;
        changeSize(size + tail.length);
	System.arraycopy(tail, 0, array, size, tail.length);
    }

  /**
   *  <code>append</code> the given String at the end
   *
   * @param tail a <code>String</code> value
   */
    public synchronized void append(String tail) { 
        int size = used;
	int length = tail.length();
        changeSize(size + length);
	tail.getChars(0, length, array, size);
    }

  /**
   *  <code>toArray</code> converts the internal representation to a char[] , of 
   *  correct size. Ie: the .length of the return == this.size()
   *
   * @return a <code>char[]</code> value
   */
    public synchronized char[] toArray() { 
        char[] arr = new char[used];
	System.arraycopy(array, 0, arr, 0, used);
        return arr;
    }
 
  /**
   *  <code>toString</code> makes a String out of the bytes
   *
   * @return a <code>String</code> representation of the bytes
   */
    public synchronized String toString() { 
        return new String(array, 0, used);
    }
  
  /**
   *  <code>copy</code> into this array from a destination, a given amount of values.
   * Get a IndexOutOfBounds if the src or count don't fit
   *
   * @param dstIndex , the index (of this array) where to copy to
   * @param src a <code>char[]</code> , where to copy from
   * @param srcIndex an <code>int</code> , where to start copying from
   * @param count an <code>int</code> , how many values to copy
   */
    public synchronized void copy(int dstIndex, char[] src, int srcIndex, 
				  int count) 
    { 
        if (dstIndex < 0) { 
	    throw new ArrayIndexOutOfBoundsException(dstIndex);
	} else if (dstIndex+count > used) { 
	    throw new ArrayIndexOutOfBoundsException(dstIndex+count);
	} 
	Metaobject.modify();
	System.arraycopy(src, srcIndex, array, dstIndex, count);
    }

  /**
   *  <code>compareTo</code> calls the other compare functions, depending on the 
   * given object
   *
   * @param o an <code>Object</code> to compare against
   * @return an <code>int</code> , the result
   */
    public int compareTo(Object o) { 
	if (o instanceof String) { 
	    return compare((String)o);
	} 
	if (o instanceof ArrayOfChar) { 
	    return compare((ArrayOfChar)o);
	}
	throw new ClassCastException();
    }
	
  /**
   *  <code>compare</code> works like the compare(ArrayOfChar)
   *
   * @param s a <code>String</code> value to compare against
   * @return an <code>int</code> , the result
   */
    public synchronized int compare(String s) { 
        int len = s.length();
	int n = len < used ? len : used;

	for (int i = 0; i < n; i++) { 
  	    int diff = array[i] - s.charAt(i);
	    if (diff != 0) { 
	        return diff;
	    }
	}
	return used - len;
    }

  /**
   *  <code>compare</code> compares two object. In that it works like the 
   * equals method. But compare returns more than just a boolean yes/no,
   * it also introduces an ordering between the objects.
   *
   * @param  a <code>ArrayOfChar</code> to compare against
   * @return an <code>int</code> , 0 if equal, negative if the object is smaller and 
   * positive if it is bigger.
   */
    public synchronized int compare(ArrayOfChar a) { 
        int len = a.used;
	char[] s = a.array;
	int n = len < used ? len : used;

	for (int i = 0; i < n; i++) { 
  	    int diff = array[i] - s[i];
	    if (diff != 0) {
		return diff;
	    }
	}
	return used - len;
    }

  /**
   * Return a <code>hashCode</code> 
   *
   * @return an <code>int</code> value, the hash
   */
    public synchronized int hashCode() {
	return new String(array, 0, used).hashCode();
	/*
	int h = 0;
	for (int i = 0, len = used; i < len; i++) { 
	    h = 31*h + array[i];
	}
	return h;
	*/
    }


  /**
   *  <code>equals</code> checks whether the given object is equivalent to this.
   * Ie. If it has the same data representation. It does not have to be the same,
   * which is checked by == operator.
   *
   * @param obj an <code>Object</code> to check
   * @return a <code>boolean</code> indicating whether obj is equivalent
   */
    public synchronized boolean equals(Object obj) { 
	if (obj == this) {
	    return true;
	}
	if (obj == null) { 
	    return false;
	}
	if (obj instanceof String) { 
	    String s = (String)obj;
	    int len = s.length();
	    if (len != used) { 
		return false;
	    }
	    for (int i = 0; i < len; i++) { 
		if (array[i] != s.charAt(i)) { 
		    return false;
		}
	    }
	} else if (obj instanceof char[]) { 
	    char[] s = (char[])obj;
	    int len = s.length;
	    if (len != used) { 
		return false;
	    }
	    for (int i = 0; i < len; i++) { 
		if (array[i] != s[i]) { 
		    return false;
		}
	    }
	} else if (obj instanceof ArrayOfChar) { 
	    ArrayOfChar a = (ArrayOfChar)obj;
	    int len = a.used;
	    if (used != len) { 
		return false;
	    }
	    for (int i = 0; i < len; i++) { 
		if (array[i] != a.array[i]) { 
		    return false;
		}
	    }
	} else { 
	    return false;
	}
	return true;
    }


  /**
   *  <code>indexOf</code> returns the first occurrence of val
   *
   * @param ch a <code>char</code> to be looked for
   * @return an <code>int</code>, where the value was found, or -1
   */
    public synchronized int indexOf(char ch) { 
        for (int i = 0; i < used; i++) { 
	    if (array[i] == ch) { 
		return i;
	    }
	}
	return -1;
    }

  /**
   * Find the <code>lastIndexOf</code> a given value
   *
   * @param ch a <code>char</code> value to be found (from the back)
   * @return an <code>int</code> , where the value was found, or -1
   */
    public synchronized int lastIndexOf(char ch) { 
        for (int i = used; --i >= 0;) { 
	    if (array[i] == ch) { 
		return i;
	    }
	}
	return -1;
    }
}