Java ArrayReflection类代码示例

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
/** Reallocate a buffer. */
public static <T> T[] reallocateBuffer(Class<T> klass, T[] oldBuffer, int oldCapacity,
    int newCapacity) {
  assert (newCapacity > oldCapacity);
  @SuppressWarnings("unchecked")
  T[] newBuffer = (T[]) ArrayReflection.newInstance(klass, newCapacity);
  if (oldBuffer != null) {
    System.arraycopy(oldBuffer, 0, newBuffer, 0, oldCapacity);
  }
  for (int i = oldCapacity; i < newCapacity; i++) {
    try {
      newBuffer[i] = ClassReflection.newInstance(klass);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  return newBuffer;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@Override
public <T> T[] getAll(Class<T> clazz) {
	Object[] got = gotAll.get(clazz);
	if (got != null) {
		return (T[]) got;
	}

	Array<ISystem> matching = cache.getNext();
	matching.clear();
	for (int i = 0; i < systems.size; i++) {
		ISystem system = systems.items[i];
		if (clazz.isAssignableFrom(system.getClass())) {
			matching.add(system);
		}
	}
	T[] array = (T[]) ArrayReflection.newInstance(clazz, matching.size);
	System.arraycopy(matching.items, 0, array, 0, array.length);
	gotAll.put(clazz, array);
	return array;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
/** Creates a new backing array with the specified size containing the current items. */
protected T[] resize (int newSize) {
	T[] items = this.items;
	T[] newItems = (T[])ArrayReflection.newInstance(items.getClass().getComponentType(), newSize);
	System.arraycopy(items, 0, newItems, 0, Math.min(size, newItems.length));
	this.items = newItems;
	return newItems;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
/** Creates a new backing array with the specified capacity containing the current items.
 * @param newCapacity the new capacity */
protected void resize (int newCapacity) {
	@SuppressWarnings("unchecked")
	T[] newItems = (T[])ArrayReflection.newInstance(items.getClass().getComponentType(), newCapacity);
	if (tail > head) {
		System.arraycopy(items, head, newItems, 0, size);
	} else if (size > 0) { // NOTE: when head == tail the buffer can be empty or full
		System.arraycopy(items, head, newItems, 0, items.length - head);
		System.arraycopy(items, 0, newItems, items.length - head, tail);
	}
	head = 0;
	tail = size;
	items = newItems;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
protected void resize (int newSize) {
	K[] newKeys = (K[])ArrayReflection.newInstance(keys.getClass().getComponentType(), newSize);
	System.arraycopy(keys, 0, newKeys, 0, Math.min(size, newKeys.length));
	this.keys = newKeys;

	V[] newValues = (V[])ArrayReflection.newInstance(values.getClass().getComponentType(), newSize);
	System.arraycopy(values, 0, newValues, 0, Math.min(size, newValues.length));
	this.values = newValues;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@SuppressWarnings("unchecked")
<T> T[] requestParticleBuffer(Class<T> klass, T[] buffer) {
  if (buffer == null) {
    buffer = (T[]) ArrayReflection.newInstance(klass, m_internalAllocatedCapacity);
    for (int i = 0; i < m_internalAllocatedCapacity; i++) {
      try {
        buffer[i] = ClassReflection.newInstance(klass);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
  }
  return buffer;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
/**
 * Creates a new backing array with the specified size containing the current items.
 *
 * @param newSize
 * @return
 */
protected T[] resize(int newSize) {
    T[] items = this.items;
    T[] newItems = (T[]) ArrayReflection.newInstance(items.getClass().getComponentType(), newSize);
    System.arraycopy(items, 0, newItems, 0, Math.min(size, newItems.length));
    this.items = newItems;
    return newItems;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
protected void resize(int newSize) {
    K[] newKeys = (K[]) ArrayReflection.newInstance(keys.getClass().getComponentType(), newSize);
    System.arraycopy(keys, 0, newKeys, 0, Math.min(size, newKeys.length));
    this.keys = newKeys;

    V[] newValues = (V[]) ArrayReflection.newInstance(values.getClass().getComponentType(), newSize);
    System.arraycopy(values, 0, newValues, 0, Math.min(size, newValues.length));
    this.values = newValues;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
/**
 * Creates a new backing array with the specified size containing the
 * current items.
 */
protected T[] resize(int newSize) {
    T[] items = this.items;
    T[] newItems = (T[]) ArrayReflection.newInstance(items.getClass().getComponentType(), newSize);
    System.arraycopy(items, 0, newItems, 0, Math.min(size, newItems.length));
    this.items = newItems;
    return newItems;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@Override
public Object evaluate(VarsContext context)
		throws ExpressionEvaluationException {

	// First arg should be the container object
	// First argument should always be a collection or similar
	Object arg1 = first().evaluate(context);

	if (arg1.getClass().isArray()) {
		return ArrayReflection.getLength(arg1);
	} else if (arg1 instanceof Array) {
		Array array = (Array) arg1;
		return array.size;
	} else if (arg1 instanceof Map) {
		Map map = (Map) arg1;
		return map.size();
	} else if (arg1 instanceof Collection) {
		Collection collection = (Collection) arg1;
		return collection.size();
	} else if (arg1 instanceof Iterable) {
		Iterable iterable = (Iterable) arg1;
		int i = 0;
		for (Object object : iterable) {
			i++;
		}
		return i;
	} else {
		throw new ExpressionEvaluationException(
				"Could not evaluate "
						+ getName()
						+ ". Revise the first argument is a collection, array, iterable or map.",
				this);
	}

}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
/** Creates a new array with {@link #items} of the specified type.
 * @param ordered If false, methods that remove elements may change the order of other elements in the array, which avoids a
 *           memory copy.
 * @param capacity Any elements added beyond this will cause the backing array to be grown. */
public Array (boolean ordered, int capacity, Class arrayType) {
	this.ordered = ordered;
	items = (T[])ArrayReflection.newInstance(arrayType, capacity);
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
public <V> V[] toArray (Class type) {
	V[] result = (V[])ArrayReflection.newInstance(type, size);
	System.arraycopy(items, 0, result, 0, size);
	return result;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public Type[] getArray(final int size) {
    return (Type[]) ArrayReflection.newInstance(arrayType, size);
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
public ObjectChannel (int id, int strideSize, int size, Class<T> type) {
	super(id, ArrayReflection.newInstance(type, size*strideSize), strideSize);
	componentType = type;
	this.data = (T[]) super.data;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@Override
public void setCapacity (int requiredCapacity) {
	T[] newData = (T[]) ArrayReflection.newInstance(componentType, strideSize * requiredCapacity);
	System.arraycopy(data, 0, newData, 0, Math.min(data.length, newData.length));
	super.data = data = newData;
}