org.j3d.util.ObjectArray Maven / Gradle / Ivy
/*****************************************************************************
* J3D.org Copyright (c) 2000
* Java Source
*
* This source is licensed under the GNU LGPL v2.1
* Please read http://www.gnu.org/copyleft/lgpl.html for more information
*
* This software comes with the standard NO WARRANTY disclaimer for any
* purpose. Use it at your own risk. If there's a problem you get to fix it.
*
****************************************************************************/
package org.j3d.util;
// External imports
// None
// Local imports
// None
/**
* Simple dynamic array structure that holds Object instances.
*
*
* Idea is to save implementation weight when we don't really want to use a
* full java.util collections class, but don't want to have to re-implement
* the node copy/paste stuff every time.
*
*
* Code is sourced from the Xj3D project.
*
* @author Justin Couch
* @version $Revision: 1.1 $
*/
public class ObjectArray
{
/** The default size of this array */
private static final int DEFAULT_SIZE = 512;
/** The increment size of the array */
private static final int INCREMENT_SIZE = 256;
/** The number of items in this array currently */
private int valueCount;
/** The contents of this array */
private Object[] array;
/**
* Create a new default array with size 512 items
*/
public ObjectArray()
{
this(DEFAULT_SIZE);
}
/**
* Create an array with the given initial size.
*
* @param initialSize The size to start with
*/
public ObjectArray(int initialSize)
{
array = new Object[initialSize];
valueCount = 0;
}
/**
* Get the count of the number of items in the array.
*
* @return The number of items in the array
*/
public int size()
{
return valueCount;
}
/**
* Clear the array so that it contains no values
*/
public void clear()
{
for(int i = 0; i < valueCount; i++)
array[i] = null;
valueCount = 0;
}
/**
* Add a new value to the array. Will resize the array if needed to
* accommodate new values.
*
* @param newNode the value to be added
*/
public void add(Object newNode)
{
if(valueCount == array.length)
{
Object[] newArray =
new Object[array.length + INCREMENT_SIZE];
System.arraycopy(array, 0, newArray, 0, array.length);
array = newArray;
}
array[valueCount++] = newNode;
}
/**
* Add an array of values in bulk to the array. The array should not
* be null.
*
* @param values The values to be added
*/
public void add(Object[] values)
{
int req_size = valueCount + values.length;
if(req_size >= array.length)
{
Object[] newArray = new Object[req_size];
System.arraycopy(array, 0, newArray, 0, array.length);
array = newArray;
}
System.arraycopy(values, 0, array, valueCount, values.length);
valueCount = req_size;
}
/**
* Get the value at the given index.
*
* @param index The position to get values from
* @return The value at that index
* @throws IndexOutOfBoundsException The index was not legal
*/
public Object get(int index)
{
if((index < 0) || (index >= valueCount))
throw new IndexOutOfBoundsException();
return array[index];
}
/**
* Set the value at the given index. If the index is out of the range
* of the current items, it will generate an index exception.
*
* @param index The position to get values from
* @param value The new value to set
* @throws IndexOutOfBoundsException The index was not legal
*/
public void set(int index, Object value)
{
if((index < 0) || (index >= valueCount))
throw new IndexOutOfBoundsException();
array[index] = value;
}
/**
* Remove the value at the given index.
*
* @param index The position to remove the value from
* @return The value at that index
* @throws IndexOutOfBoundsException The index was not legal
*/
public Object remove(int index)
{
if((index < 0) || (index >= valueCount))
throw new IndexOutOfBoundsException();
Object ret_val = array[index];
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
valueCount--;
return ret_val;
}
/**
* Remove the first instance of the object found from this array. The
* object equivalence is found by first using a == compare and then if
* that fails, using the .equals() comparison. If this object is in the
* array multiple times, only the first instance is deleted.
*
* @param obj The object instance to remove
* @return The object removed, if found. Null if not found
*/
public Object remove(Object obj)
{
// go looking for it:
int found_index = -1;
for(int i = 0; (i < valueCount) && (found_index != -1); i++)
{
if((array[i] == obj) || array[i].equals(obj));
found_index = i;
}
Object ret_val = null;
if(found_index != -1)
ret_val = remove(found_index);
return ret_val;
}
/**
* Turn the values of this array into a real array. Returns an array with
* the exact number of items in it. This is a separate copy of the internal
* array.
*
* @return The array of values
*/
public Object[] toArray()
{
Object[] ret_val = new Object[valueCount];
System.arraycopy(array, 0, ret_val, 0, valueCount);
return ret_val;
}
/**
* Turn the values of this array into a real array by copying them into
* the given array if possible. If the array is big enough then it will
* copy the values straight in. If not, it will ignore that array and
* create it's own copy and return that. If the passed array is used, the
* return value will be a reference to the passed array, otherwise it will
* be the new copy.
*
* @param values The array to copy values to
* @return The array of values
*/
public Object[] toArray(Object[] values)
{
Object[] ret_val = null;
if(values.length >= valueCount)
ret_val = values;
else
ret_val = new Object[valueCount];
System.arraycopy(array, 0, ret_val, 0, valueCount);
return ret_val;
}
}