com.android.dx.util.FixedSizeList Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of builder Show documentation
Show all versions of builder Show documentation
Library to build Android applications.
/*
* Copyright (C) 2007 The Android Open Source Project
*
* 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.android.dx.util;
import java.util.Arrays;
/**
* Simple (mostly) fixed-size list of objects, which may be made immutable.
*/
public class FixedSizeList
extends MutabilityControl implements ToHuman {
/** {@code non-null;} array of elements */
private Object[] arr;
/**
* Constructs an instance. All indices initially contain {@code null}.
*
* @param size the size of the list
*/
public FixedSizeList(int size) {
super(size != 0);
try {
arr = new Object[size];
} catch (NegativeArraySizeException ex) {
// Translate the exception.
throw new IllegalArgumentException("size < 0");
}
}
/** {@inheritDoc} */
@Override
public boolean equals(Object other) {
if (this == other) {
// Easy out.
return true;
}
if ((other == null) || (getClass() != other.getClass())) {
// Another easy out.
return false;
}
FixedSizeList list = (FixedSizeList) other;
return Arrays.equals(arr, list.arr);
}
/** {@inheritDoc} */
@Override
public int hashCode() {
return Arrays.hashCode(arr);
}
/** {@inheritDoc} */
@Override
public String toString() {
String name = getClass().getName();
return toString0(name.substring(name.lastIndexOf('.') + 1) + '{',
", ",
"}",
false);
}
/**
* {@inheritDoc}
*
* This method will only work if every element of the list
* implements {@link ToHuman}.
*/
public String toHuman() {
String name = getClass().getName();
return toString0(name.substring(name.lastIndexOf('.') + 1) + '{',
", ",
"}",
true);
}
/**
* Gets a customized string form for this instance.
*
* @param prefix {@code null-ok;} prefix for the start of the result
* @param separator {@code null-ok;} separator to insert between each item
* @param suffix {@code null-ok;} suffix for the end of the result
* @return {@code non-null;} the custom string
*/
public String toString(String prefix, String separator, String suffix) {
return toString0(prefix, separator, suffix, false);
}
/**
* Gets a customized human string for this instance. This method will
* only work if every element of the list implements {@link
* ToHuman}.
*
* @param prefix {@code null-ok;} prefix for the start of the result
* @param separator {@code null-ok;} separator to insert between each item
* @param suffix {@code null-ok;} suffix for the end of the result
* @return {@code non-null;} the custom string
*/
public String toHuman(String prefix, String separator, String suffix) {
return toString0(prefix, separator, suffix, true);
}
/**
* Gets the number of elements in this list.
*/
public final int size() {
return arr.length;
}
/**
* Shrinks this instance to fit, by removing any unset
* ({@code null}) elements, leaving the remaining elements in
* their original order.
*/
public void shrinkToFit() {
int sz = arr.length;
int newSz = 0;
for (int i = 0; i < sz; i++) {
if (arr[i] != null) {
newSz++;
}
}
if (sz == newSz) {
return;
}
throwIfImmutable();
Object[] newa = new Object[newSz];
int at = 0;
for (int i = 0; i < sz; i++) {
Object one = arr[i];
if (one != null) {
newa[at] = one;
at++;
}
}
arr = newa;
if (newSz == 0) {
setImmutable();
}
}
/**
* Gets the indicated element. It is an error to call this with the
* index for an element which was never set; if you do that, this
* will throw {@code NullPointerException}. This method is
* protected so that subclasses may offer a safe type-checked
* public interface to their clients.
*
* @param n {@code >= 0, < size();} which element
* @return {@code non-null;} the indicated element
*/
protected final Object get0(int n) {
try {
Object result = arr[n];
if (result == null) {
throw new NullPointerException("unset: " + n);
}
return result;
} catch (ArrayIndexOutOfBoundsException ex) {
// Translate the exception.
return throwIndex(n);
}
}
/**
* Gets the indicated element, allowing {@code null}s to be
* returned. This method is protected so that subclasses may
* (optionally) offer a safe type-checked public interface to
* their clients.
*
* @param n {@code >= 0, < size();} which element
* @return {@code null-ok;} the indicated element
*/
protected final Object getOrNull0(int n) {
return arr[n];
}
/**
* Sets the element at the given index, but without doing any type
* checks on the element. This method is protected so that
* subclasses may offer a safe type-checked public interface to
* their clients.
*
* @param n {@code >= 0, < size();} which element
* @param obj {@code null-ok;} the value to store
*/
protected final void set0(int n, Object obj) {
throwIfImmutable();
try {
arr[n] = obj;
} catch (ArrayIndexOutOfBoundsException ex) {
// Translate the exception.
throwIndex(n);
}
}
/**
* Throws the appropriate exception for the given index value.
*
* @param n the index value
* @return never
* @throws IndexOutOfBoundsException always thrown
*/
private Object throwIndex(int n) {
if (n < 0) {
throw new IndexOutOfBoundsException("n < 0");
}
throw new IndexOutOfBoundsException("n >= size()");
}
/**
* Helper for {@link #toString} and {@link #toHuman}, which both of
* those call to pretty much do everything.
*
* @param prefix {@code null-ok;} prefix for the start of the result
* @param separator {@code null-ok;} separator to insert between each item
* @param suffix {@code null-ok;} suffix for the end of the result
* @param human whether the output is to be human
* @return {@code non-null;} the custom string
*/
private String toString0(String prefix, String separator, String suffix,
boolean human) {
int len = arr.length;
StringBuffer sb = new StringBuffer(len * 10 + 10);
if (prefix != null) {
sb.append(prefix);
}
for (int i = 0; i < len; i++) {
if ((i != 0) && (separator != null)) {
sb.append(separator);
}
if (human) {
sb.append(((ToHuman) arr[i]).toHuman());
} else {
sb.append(arr[i]);
}
}
if (suffix != null) {
sb.append(suffix);
}
return sb.toString();
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy