//-< ArrayOfFloat.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 floats
//-------------------------------------------------------------------*--------*

package goodslib;
import  goodsjpi.*;

/**
 *  <code>ArrayOfFloat</code> is just that, an array of floats.  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 ArrayOfFloat extends AnyArray { 
  /**
   *  <code>array</code> holds the floats in an  []
   */
    protected float[] array;

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

  /**
   * Creates a new <code>ArrayOfFloat</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 ArrayOfFloat(int size, int allocatedSize) {
	Assert.that(size <= allocatedSize);
	array = new float[allocatedSize];
	used = size;
    }
    
  /**
   * Creates a new <code>ArrayOfFloat</code> instance, as a copy of the given 
   * float[]
   *
   * @param src a <code>float[]</code> that will be copied
   */
    public ArrayOfFloat(float[] src) { 
	int length = src.length;
	array = new float[length];
	used = length;
	System.arraycopy(src, 0, array, 0, length);
    }

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

  /**
   * Get a float at the specified index
   *
   * @param index of the float you want
   * @return a <code>float</code> value, at index "index"
   */
    public synchronized float 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;
	    float[] newArray = new float[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>float</code> value to insert
   */
     public synchronized void insert(int index, int count, float 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>float</code> to push to the stack
   */
     public synchronized void push(float 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>float</code> value
   */
    public synchronized float pop() { 
	if (used == 0) { 
	    throw new ArrayIndexOutOfBoundsException(0);
	}
	float 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>float</code> value
   */
    public synchronized float 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>float[]</code> that will be appended
   */
    public synchronized void append(float[] tail) { 
        int size = used;
        changeSize(size + tail.length);
	System.arraycopy(tail, 0, array, size, tail.length);
    }

  /**
   *  <code>toArray</code> converts the internal representation to a float[] , of 
   *  correct size. Ie: the .length of the return == this.size()
   *
   * @return a <code>float[]</code> value
   */
    public synchronized float[] toArray() { 
        float[] arr = new float[used];
	System.arraycopy(array, 0, arr, 0, used);
        return arr;
    }
  
  /**
   *  <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>float[]</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, float[] 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>indexOf</code> returns the first occurrence of val
   *
   * @param val a <code>float</code> to be looked for
   * @return an <code>int</code>, where the value was found, or -1
   */
    public synchronized int indexOf(float val) { 
        for (int i = 0; i < used; i++) { 
	    if (array[i] == val) { 
		return i;
	    }
	}
	return -1;
    }

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