import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Removes elements of this type-specific list using optimized system calls.
 *
 * @param from the start index (inclusive).
 * @param to the end index (exclusive).
 */
public void removeElements( final int from, final int to ) {
 Arrays.ensureFromTo( size, from, to );
 System.arraycopy( a, to, a, from, size - to );
 size -= ( to - from );
 int i = to - from;
 while( i-- != 0 ) a[ size + i ] = null;
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
private static List<Map.Entry<String, FacetCounter>> limitOrderBy(FacetField facetField,
		List<Map.Entry<String, FacetCounter>> list) {
	final FacetSorter facetSorter = FacetSorter.getSorter(list, facetField.getOrderBy());
	if (facetSorter == null)
		return list;
	Arrays.quickSort(0, list.size(), facetSorter, facetSorter);
	final Integer limit = facetField.getLimit();
	if (limit == null)
		return list;
	if (list.size() <= limit)
		return list;
	return list.subList(0, limit);

}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public int hashCode( final K[] o ) {
 return java.util.Arrays.hashCode( o );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public boolean equals( final K[] a, final K[] b ) {
 return java.util.Arrays.equals( a, b );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public int hashCode( final long[] o ) {
 return java.util.Arrays.hashCode( o );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public boolean equals( final long[] a, final long[] b ) {
 return java.util.Arrays.equals( a, b );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public int hashCode( final int[] o ) {
 return java.util.Arrays.hashCode( o );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public boolean equals( final int[] a, final int[] b ) {
 return java.util.Arrays.equals( a, b );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public int hashCode( final boolean[] o ) {
 return java.util.Arrays.hashCode( o );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public boolean equals( final boolean[] a, final boolean[] b ) {
 return java.util.Arrays.equals( a, b );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Removes elements of this type-specific list using optimized system calls.
 *
 * @param from the start index (inclusive).
 * @param to the end index (exclusive).
 */
public void removeElements( final int from, final int to ) {
 Arrays.ensureFromTo( size, from, to );
 System.arraycopy( a, to, a, from, size - to );
 size -= ( to - from );
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public void quickSort(Timer timer) {
	int numFound = collector.getSize();
	Timer t = new Timer(timer, "Sort (quicksort): " + numFound);
	Arrays.parallelQuickSort(0, numFound, this, collector);
	t.end(null);
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
private SnippetVectorSort(final SnippetVector[] vectors) {
	this.vectors = vectors;
	Arrays.quickSort(0, vectors.length, this, this);
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
public void sortByOffset() {
	Arrays.quickSort(0, termQueryItems.size(), this, this);
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Grows the given array to the maximum between the given length and
 * the current length multiplied by two, provided that the given
 * length is larger than the current length.
 *
 * <P>If you want complete control on the array growth, you
 * should probably use <code>ensureCapacity()</code> instead.
 *
 * @param array an array.
 * @param length the new minimum length for this array.
 * @return <code>array</code>, if it can contain <code>length</code>
 * entries; otherwise, an array with
 * max(<code>length</code>,<code>array.length</code>/&phi;) entries whose first
 * <code>array.length</code> entries are the same as those of <code>array</code>.
 * */
public static <K> K[] grow( final K[] array, final int length ) {
 if ( length > array.length ) {
  final int newLength = (int)Math.max( Math.min( 2L * array.length, Arrays.MAX_ARRAY_SIZE ), length );
  final K t[] =
   newArray( array, newLength );
  System.arraycopy( array, 0, t, 0, array.length );
  return t;
 }
 return array;
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Grows the given array to the maximum between the given length and
 * the current length multiplied by two, provided that the given
 * length is larger than the current length.
 *
 * <P>If you want complete control on the array growth, you
 * should probably use <code>ensureCapacity()</code> instead.
 *
 * @param array an array.
 * @param length the new minimum length for this array.
 * @return <code>array</code>, if it can contain <code>length</code>
 * entries; otherwise, an array with
 * max(<code>length</code>,<code>array.length</code>/&phi;) entries whose first
 * <code>array.length</code> entries are the same as those of <code>array</code>.
 * */
public static long[] grow( final long[] array, final int length ) {
 if ( length > array.length ) {
  final int newLength = (int)Math.max( Math.min( 2L * array.length, Arrays.MAX_ARRAY_SIZE ), length );
  final long t[] =
   new long[ newLength ];
  System.arraycopy( array, 0, t, 0, array.length );
  return t;
 }
 return array;
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Grows the given array to the maximum between the given length and
 * the current length multiplied by two, provided that the given
 * length is larger than the current length.
 *
 * <P>If you want complete control on the array growth, you
 * should probably use <code>ensureCapacity()</code> instead.
 *
 * @param array an array.
 * @param length the new minimum length for this array.
 * @return <code>array</code>, if it can contain <code>length</code>
 * entries; otherwise, an array with
 * max(<code>length</code>,<code>array.length</code>/&phi;) entries whose first
 * <code>array.length</code> entries are the same as those of <code>array</code>.
 * */
public static int[] grow( final int[] array, final int length ) {
 if ( length > array.length ) {
  final int newLength = (int)Math.max( Math.min( 2L * array.length, Arrays.MAX_ARRAY_SIZE ), length );
  final int t[] =
   new int[ newLength ];
  System.arraycopy( array, 0, t, 0, array.length );
  return t;
 }
 return array;
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Grows the given array to the maximum between the given length and
 * the current length multiplied by two, provided that the given
 * length is larger than the current length.
 *
 * <P>If you want complete control on the array growth, you
 * should probably use <code>ensureCapacity()</code> instead.
 *
 * @param array an array.
 * @param length the new minimum length for this array.
 * @return <code>array</code>, if it can contain <code>length</code>
 * entries; otherwise, an array with
 * max(<code>length</code>,<code>array.length</code>/&phi;) entries whose first
 * <code>array.length</code> entries are the same as those of <code>array</code>.
 * */
public static boolean[] grow( final boolean[] array, final int length ) {
 if ( length > array.length ) {
  final int newLength = (int)Math.max( Math.min( 2L * array.length, Arrays.MAX_ARRAY_SIZE ), length );
  final boolean t[] =
   new boolean[ newLength ];
  System.arraycopy( array, 0, t, 0, array.length );
  return t;
 }
 return array;
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/**
 * Removes elements of this type-specific list using optimized system calls.
 * 
 * @param from
 *            the start index (inclusive).
 * @param to
 *            the end index (exclusive).
 */

public void removeElements(final int from, final int to) {
	Arrays.ensureFromTo(size, from, to);
	System.arraycopy(a, to, a, from, size - to);
	size -= to - from;
}
 

import it.unimi.dsi.fastutil.Arrays; //导入依赖的package包/类
/** Ensures that a range given by its first (inclusive) and last (exclusive) elements fits an array.
 *
 * <P>This method may be used whenever an array range check is needed.
 *
 * @param a an array.
 * @param from a start index (inclusive).
 * @param to an end index (exclusive).
 * @throws IllegalArgumentException if <code>from</code> is greater than <code>to</code>.
 * @throws ArrayIndexOutOfBoundsException if <code>from</code> or <code>to</code> are greater than the array length or negative.
 */
public static <K> void ensureFromTo( final K[] a, final int from, final int to ) {
 Arrays.ensureFromTo( a.length, from, to );
}