// Copyright 2015 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.util;
import com.google.common.base.Preconditions;
import java.util.Arrays;
/**
* A list of primitive long values.
*
* <p>Grows its backing array internally when necessary and such that constant amortized addition of
* elements is guaranteed.
*
* <p>Does not shrink its array except by explicit calls to {@link #trim}.
*/
public class LongArrayList {
private static final int DEFAULT_CAPACITY = 12;
private long[] array;
private int size;
/**
* Initialize a new LongArrayList with default capacity.
*/
public LongArrayList() {
this.array = new long[DEFAULT_CAPACITY];
}
/**
* Initialize a new LongArrayList with space for elements equal to the given capacity.
* @throws IndexOutOfBoundsException if the capacity is negative
*/
public LongArrayList(int capacity) {
Preconditions.checkArgument(capacity >= 0, "Initial capacity must not be negative.");
this.array = new long[capacity];
}
/**
* Create a new LongArrayList backed by the given array. No copy is made.
*/
public LongArrayList(long[] array) {
Preconditions.checkNotNull(array);
this.array = array;
this.size = array.length;
}
/**
* Add a value at a specific position to this list. All elements at larger indices will
* shift to the right by one.
* @param position may be any index within the array or equal to the size, to append at the end
* @throws IndexOutOfBoundsException if the index is outside the interval [0, {@link #size()})
*/
public void add(int position, long value) {
Preconditions.checkPositionIndex(position, size);
copyBackAndGrow(position, 1);
set(position, value);
}
/**
* Add a value to the end of this list.
*/
public void add(long value) {
add(size, value);
}
/**
* Add all elements from another LongArrayList at the end of this one.
* @see #addAll(LongArrayList, int)
*/
public boolean addAll(LongArrayList other) {
return addAll(other.array, 0, other.size, size);
}
/**
* Add all elements from another LongArrayList at a certain position within or at the end of
* this one.
* @param other
* @param position at which position to add these elements, adds at the end if equal to the size
* @return whether this list changed
* @throws IndexOutOfBoundsException if the index is outside the interval [0, {@link #size()}]
*/
public boolean addAll(LongArrayList other, int position) {
return addAll(other.array, 0, other.size, position);
}
/**
* Add all elements from the given array to the end of this array.
* @see #addAll(long[], int, int, int)
*/
public boolean addAll(long[] array) {
return addAll(array, 0, array.length, size);
}
/**
* Add certain elements from the given array to the end of this array.
* @see #addAll(long[], int, int, int)
*/
public boolean addAll(long[] array, int fromIndex, int length) {
return addAll(array, fromIndex, length, size);
}
/**
* Add certain elements from the given array at a certain position in this list.
* @param array the array from which to take the elements
* @param fromIndex the position of the first element to add
* @param length how many elements to add
* @param position at which position to add these elements, adds at the end if equal to the size
* @return whether this list has changed
* @throws IndexOutOfBoundsException if fromIndex and length violate the boundaries of the given
* array or atIndex is not a valid index in this array or equal to the size
*/
public boolean addAll(long[] array, int fromIndex, int length, int position) {
Preconditions.checkNotNull(array);
Preconditions.checkPositionIndex(fromIndex + length, array.length);
if (length == 0) {
return false;
}
// check other positions later to allow "adding" empty arrays anywhere within this array
Preconditions.checkElementIndex(fromIndex, array.length);
Preconditions.checkPositionIndex(position, size);
copyBackAndGrow(position, length);
System.arraycopy(array, fromIndex, this.array, position, length);
return true;
}
/**
* Resize the backing array to fit at least this many elements if necessary.
*/
public void ensureCapacity(int capacity) {
if (capacity > array.length) {
long[] newArray = new long[growCapacity(capacity)];
System.arraycopy(array, 0, newArray, 0, size);
array = newArray;
}
}
/**
* @return the element at the specified index
* @throws IndexOutOfBoundsException if the index is outside the interval [0, {@link #size()})
*/
public long get(int index) {
Preconditions.checkElementIndex(index, size);
return array[index];
}
/**
* Search for the first index at which the given value is found.
* @return -1 if the value is not found, the index at which it was found otherwise
*/
public int indexOf(long value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Remove the element at the specified index and shift all elements at higher indices down by
* one.
* @return the removed element
* @throws IndexOutOfBoundsException if the index is outside the interval [0, {@link #size()})
*/
public long remove(int index) {
Preconditions.checkElementIndex(index, size);
long previous = array[index];
System.arraycopy(array, index + 1, array, index, size - index - 1);
size--;
return previous;
}
/**
* Remove the first occurrence of a value and shift all elements at higher indices down by one.
* @return true, if the list changed and thus contained the value, false otherwise
*/
public boolean remove(long value) {
int index = indexOf(value);
if (index == -1) {
return false;
}
remove(index);
return true;
}
/**
* Overwrites the element at a certain index with the given value and returns the previous
* element.
* @throws IndexOutOfBoundsException if the index is outside the interval [0, {@link #size()})
*/
public long set(int index, long value) {
Preconditions.checkElementIndex(index, size);
long previous = array[index];
array[index] = value;
return previous;
}
/**
* @return the amount of elements in this list
*/
public int size() {
return size;
}
/**
* Sort the list in ascending order.
*/
public void sort() {
Arrays.sort(array, 0, size);
}
/**
* Sort the sub list from the first index (inclusive) to the second index (exclusive) in
* ascending order.
* @see Arrays#sort(long[], int, int)
* @throws IndexOutOfBoundsException if fromIndex is outside the interval [0, {@link #size()})
* or toIndex is outside [0, {@link #size()}]
*/
public void sort(int fromIndex, int toIndex) {
Arrays.sort(array, fromIndex, toIndex);
}
/**
* Build a String of the form [0, 1, 2]
*/
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("[");
String separator = "";
for (int index = 0; index < size; index++) {
sb.append(separator);
sb.append(array[index]);
separator = ", ";
}
sb.append("]");
return sb.toString();
}
/**
* Remove any excess capacity to save space.
*/
public void trim() {
if (size < array.length) {
long[] newArray = new long[size];
System.arraycopy(array, 0, newArray, 0, size);
array = newArray;
}
}
/**
* Copy the end of the array from a certain index back to make room for length many items and
* adds length to the size.
*
* @param fromIndex may be equal to the current size, then no element needs to be copied, but the
* array may grow
*/
private void copyBackAndGrow(int fromIndex, int length) {
int newSize = size + length;
ensureCapacity(newSize);
System.arraycopy(array, fromIndex, array, fromIndex + length, size - fromIndex);
size = newSize;
}
/**
* The new capacity when growing the array to contain at least newSize many elements.
* Uses a growth factor of 1.5.
*/
private int growCapacity(int newSize) {
return newSize + (newSize >> 1);
}
}