import org.andengine.util.IMatcher; //导入依赖的package包/类
public static <T> T[] filter(final T[] pArray, final Class<T[]> pClass, final IMatcher<T> pMatcher) {
	final int arrayLength = pArray.length;

	int filteredArrayLength = 0;
	for (int i = arrayLength - 1; i >= 0; i--) {
		if (pMatcher.matches(pArray[i])) {
			filteredArrayLength++;
		}
	}

	final T[] filteredArray = ArrayUtils.newArray(pClass, filteredArrayLength);
	int resultIndex = 0;
	for (int i = 0; i < arrayLength; i++) {
		if (pMatcher.matches(pArray[i])) {
			filteredArray[resultIndex] = pArray[i];
			resultIndex++;
		}
	}

	return filteredArray;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public <L extends List<T>> L getItemsAndItemsBelow(final IMatcher<T> pMatcher, final L pResult) {
	if (this.mItems != null) {
		for (final T item : this.mItems) { // TODO Check if iteration is allocation free.
			if (pMatcher.matches(item)) {
				pResult.add(item);
			}
		}
	}

	if (this.mTopLeftChild != null) {
		this.mTopLeftChild.getItemsAndItemsBelow(pMatcher, pResult);
	}
	if (this.mTopRightChild != null) {
		this.mTopRightChild.getItemsAndItemsBelow(pMatcher, pResult);
	}
	if (this.mBottomLeftChild != null) {
		this.mBottomLeftChild.getItemsAndItemsBelow(pMatcher, pResult);
	}
	if (this.mBottomRightChild != null) {
		this.mBottomRightChild.getItemsAndItemsBelow(pMatcher, pResult);
	}

	return pResult;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public <L extends List<T>> L query(final B pBounds, final IMatcher<T> pMatcher, final L pResult) {
	/* Test against all items in this node. */
	if (this.mItems != null) {
		for (final T item : this.mItems) {
			if (this.intersects(pBounds, item.getBounds()) && pMatcher.matches(item)) {
				pResult.add(item);
			}
		}
	}

	/* Check children. */
	if (this.queryChild(pBounds, pMatcher, pResult, this.mTopLeftChild)) {
		return pResult;
	} else if (this.queryChild(pBounds, pMatcher, pResult, this.mTopRightChild)) {
		return pResult;
	} else if (this.queryChild(pBounds, pMatcher, pResult, this.mBottomLeftChild)) {
		return pResult;
	} else if (this.queryChild(pBounds, pMatcher, pResult, this.mBottomRightChild)) {
		return pResult;
	} else {
		return pResult;
	}
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <L extends List<S>, S extends T> L queryForSubclass(final B pBounds, final IMatcher<T> pMatcher, final L pResult) throws ClassCastException {
	/* Test against all items in this node. */
	if (this.mItems != null) {
		for (final T item : this.mItems) {
			if (this.intersects(pBounds, item.getBounds()) && pMatcher.matches(item)) {
				pResult.add((S) item);
			}
		}
	}

	/* Check children. */
	if (this.queryChildForSubclass(pBounds, pMatcher, pResult, this.mTopLeftChild)) {
		return pResult;
	} else if (this.queryChildForSubclass(pBounds, pMatcher, pResult, this.mTopRightChild)) {
		return pResult;
	} else if (this.queryChildForSubclass(pBounds, pMatcher, pResult, this.mBottomLeftChild)) {
		return pResult;
	} else if (this.queryChildForSubclass(pBounds, pMatcher, pResult, this.mBottomRightChild)) {
		return pResult;
	} else {
		return pResult;
	}
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
/**
 * @param pBounds
 * @param pMatcher
 * @param pResult
 * @param pChild
 * @return <code>true</code> when the child contains pBounds, <code>false</code> otherwise.
 */
private <L extends List<S>, S extends T> boolean queryChildForSubclass(final B pBounds, final IMatcher<T> pMatcher, final L pResult, final QuadTreeNode pChild) throws ClassCastException {
	if(pChild == null) {
		return false;
	}

	if(pChild.contains(pBounds)) {
		pChild.queryForSubclass(pBounds, pMatcher, pResult);
		return true;
	}

	if(pChild.containedBy(pBounds)) {
		pChild.getItemsAndItemsBelowForSubclass(pMatcher, pResult);
	} else if(pChild.intersects(pBounds)) {
		pChild.queryForSubclass(pBounds, pMatcher, pResult);
	}

	return false;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public boolean containsAny(final B pBounds, final IMatcher<T> pMatcher) {
	/* Test against all items in this node. */
	if (this.mItems != null) {
		final int itemCount = this.mItems.size();
		for (int i = 0; i < itemCount; i++) {
			final T item = this.mItems.get(i);
			if (this.intersects(pBounds, item.getBounds()) && pMatcher.matches(item)) {
				return true;
			}
		}
	}

	/* Check children. */
	if (this.containsAnyChild(pBounds, pMatcher, this.mTopLeftChild)) {
		return true;
	} else if (this.containsAnyChild(pBounds, pMatcher, this.mTopRightChild)) {
		return true;
	} else if (this.containsAnyChild(pBounds, pMatcher, this.mBottomLeftChild)) {
		return true;
	} else if (this.containsAnyChild(pBounds, pMatcher, this.mBottomRightChild)) {
		return true;
	} else {
		return false;
	}
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
/**
 * @param pBounds
 * @param pMatcher
 * @param pResult
 * @param pChild
 * @return <code>true</code> when the child contains pBounds, <code>false</code> otherwise.
 */
private <L extends List<T>> boolean queryChild(final B pBounds, final IMatcher<T> pMatcher, final L pResult, final QuadTreeNode pChild) {
	if (pChild == null) {
		return false;
	}

	if (pChild.contains(pBounds)) {
		pChild.query(pBounds, pMatcher, pResult);
		return true;
	}

	if (pChild.containedBy(pBounds)) {
		pChild.getItemsAndItemsBelow(pMatcher, pResult);
	} else if (pChild.intersects(pBounds)) {
		pChild.query(pBounds, pMatcher, pResult);
	}

	return false;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
/**
 * @param pBounds
 * @param pMatcher
 * @param pResult
 * @param pChild
 * @return <code>true</code> when the child contains pBounds, <code>false</code> otherwise.
 */
private <L extends List<S>, S extends T> boolean queryChildForSubclass(final B pBounds, final IMatcher<T> pMatcher, final L pResult, final QuadTreeNode pChild) throws ClassCastException {
	if (pChild == null) {
		return false;
	}

	if (pChild.contains(pBounds)) {
		pChild.queryForSubclass(pBounds, pMatcher, pResult);
		return true;
	}

	if (pChild.containedBy(pBounds)) {
		pChild.getItemsAndItemsBelowForSubclass(pMatcher, pResult);
	} else if (pChild.intersects(pBounds)) {
		pChild.queryForSubclass(pBounds, pMatcher, pResult);
	}

	return false;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public T get(final IMatcher<T> pMatcher) {
	final int size = this.size();
	for (int i = 0; i < size; i++) {
		final T item = this.get(i);
		if (pMatcher.matches(item)) {
			return item;
		}
	}
	return null;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public boolean removeAll(final IMatcher<T> pMatcher) {
	boolean result = false;
	for (int i = this.size() - 1; i >= 0; i--) {
		if (pMatcher.matches(this.get(i))) {
			this.remove(i);
			result = true;
		}
	}
	return result;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public <L extends List<T>> L query(final IMatcher<T> pMatcher, final L pResult) {
	final int size = this.size();
	for (int i = 0; i < size; i++) {
		final T item = this.get(i);
		if (pMatcher.matches(item)) {
			pResult.add(item);
		}
	}

	return pResult;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <L extends List<S>, S extends T> L queryForSubclass(final IMatcher<T> pMatcher, final L pResult) {
	final int size = this.size();
	for (int i = 0; i < size; i++) {
		final T item = this.get(i);
		if (pMatcher.matches(item)) {
			pResult.add((S) item);
		}
	}

	return pResult;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public T remove(final IMatcher<T> pMatcher) {
	for (int i = 0; i < this.size(); i++) {
		if (pMatcher.matches(this.get(i))) {
			return this.remove(i);
		}
	}
	return null;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <L extends List<S>, S extends T> L getItemsAndItemsBelowForSubclass(final IMatcher<T> pMatcher, final L pResult) throws ClassCastException {
	if(this.mItems != null) {
		final int itemCount = this.mItems.size();
		for(int i = 0; i < itemCount; i++) {
			final T item = this.mItems.get(i);
			if(pMatcher.matches(item)) {
				pResult.add((S)item);
			}
		}
	}

	if(this.mTopLeftChild != null) {
		this.mTopLeftChild.getItemsAndItemsBelowForSubclass(pMatcher, pResult);
	}
	if(this.mTopRightChild != null) {
		this.mTopRightChild.getItemsAndItemsBelowForSubclass(pMatcher, pResult);
	}
	if(this.mBottomLeftChild != null) {
		this.mBottomLeftChild.getItemsAndItemsBelowForSubclass(pMatcher, pResult);
	}
	if(this.mBottomRightChild != null) {
		this.mBottomRightChild.getItemsAndItemsBelowForSubclass(pMatcher, pResult);
	}

	return pResult;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
private boolean containsAnyChild(final B pBounds, final IMatcher<T> pMatcher, final QuadTreeNode pChild) {
	if(pChild == null) {
		return false;
	}

	if(pChild.intersects(pBounds) && pChild.containsAny(pBounds, pMatcher)) {
		return true;
	}

	return false;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
private boolean containsAnyChild(final B pBounds, final IMatcher<T> pMatcher, final QuadTreeNode pChild) {
	if (pChild == null) {
		return false;
	}

	if (pChild.intersects(pBounds) && pChild.containsAny(pBounds, pMatcher)) {
		return true;
	}

	return false;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
/**
 * @param pMatcher to find the items.
 * @param pParameterCallable to be called with each matched item after it was removed.
 */
public boolean removeAll(final IMatcher<T> pMatcher, final ParameterCallable<T> pParameterCallable) {
	boolean result = false;
	for (int i = this.size() - 1; i >= 0; i--) {
		if (pMatcher.matches(this.get(i))) {
			final T removed = this.remove(i);
			pParameterCallable.call(removed);
			result = true;
		}
	}
	return result;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public void call(final IMatcher<T> pMatcher, final ParameterCallable<T> pParameterCallable) {
	for (int i = this.size() - 1; i >= 0; i--) {
		final T item = this.get(i);
		if (pMatcher.matches(item)) {
			pParameterCallable.call(item);
		}
	}
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public static final <T> ArrayList<T> filter(final List<T> pItems, final IMatcher<T> pMatcher) {
	final ArrayList<T> out = new ArrayList<T>();
	final int itemCount = pItems.size();
	for (int i = 0; i < itemCount; i++) {
		final T item = pItems.get(i);
		if (pMatcher.matches(item)) {
			out.add(item);
		}
	}
	return out;
}
 

import org.andengine.util.IMatcher; //导入依赖的package包/类
public int lastIndexOf(final IMatcher<T> pMatcher) {
	for (int i = this.size() - 1; i >= 0; i--) {
		final T item = this.get(i);
		if (pMatcher.matches(item)) {
			return i;
		}
	}
	return -1;
}