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;
}
 

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

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@Override
public void create () {
	font = new BitmapFont();
	batch = new SpriteBatch();

	try {
		Vector2 fromDefaultConstructor = ClassReflection.newInstance(Vector2.class);
		println("From default constructor: " + fromDefaultConstructor);

		Method mSet = ClassReflection.getMethod(Vector2.class, "set", float.class, float.class);
		mSet.invoke(fromDefaultConstructor, 10, 11);
		println("Set to 10/11: " + fromDefaultConstructor);

		Constructor copyConstroctor = ClassReflection.getConstructor(Vector2.class, Vector2.class);
		Vector2 fromCopyConstructor = (Vector2)copyConstroctor.newInstance(fromDefaultConstructor);
		println("From copy constructor: " + fromCopyConstructor);

		Method mMul = ClassReflection.getMethod(Vector2.class, "scl", float.class);
		println("Multiplied by 2; " + mMul.invoke(fromCopyConstructor, 2));

		Method mNor = ClassReflection.getMethod(Vector2.class, "nor");
		println("Normalized: " + mNor.invoke(fromCopyConstructor));

		Vector2 fieldCopy = new Vector2();
		Field fx = ClassReflection.getField(Vector2.class, "x");
		Field fy = ClassReflection.getField(Vector2.class, "y");
		fx.set(fieldCopy, fx.get(fromCopyConstructor));
		fy.set(fieldCopy, fy.get(fromCopyConstructor));
		println("Copied field by field: " + fieldCopy);

		Json json = new Json();
		String jsonString = json.toJson(fromCopyConstructor);
		Vector2 fromJson = json.fromJson(Vector2.class, jsonString);
		println("JSON serialized: " + jsonString);
		println("JSON deserialized: " + fromJson);
		fromJson.x += 1;
		fromJson.y += 1;
		println("JSON deserialized + 1/1: " + fromJson);

		Object array = ArrayReflection.newInstance(int.class, 5);
		ArrayReflection.set(array, 0, 42);
		println("Array int: length=" + ArrayReflection.getLength(array) + ", access=" + ArrayReflection.get(array, 0));

		array = ArrayReflection.newInstance(String.class, 5);
		ArrayReflection.set(array, 0, "test string");
		println("Array String: length=" + ArrayReflection.getLength(array) + ", access=" + ArrayReflection.get(array, 0));
	} catch (Exception e) {
		message = "FAILED: " + e.getMessage() + "\n";
		message += e.getClass();
	}
}
 

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包/类
public ArrayIterable(Object anArray) {
	this.arrayLength = ArrayReflection.getLength(anArray);
	this.innerArray = anArray;
}
 

import com.badlogic.gdx.utils.reflect.ArrayReflection; //导入依赖的package包/类
@Override
public Expression next() {
	currentElement.value = ArrayReflection.get(innerArray,
			arrayPosition++);
	return currentElement;
}