/*
* 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.dexgen.rop.type;
import com.android.dexgen.util.FixedSizeList;
/**
* Standard implementation of {@link TypeList}.
*/
public final class StdTypeList
extends FixedSizeList implements TypeList {
/** {@code non-null;} no-element instance */
public static final StdTypeList EMPTY = new StdTypeList(0);
/** {@code non-null;} the list {@code [int]} */
public static final StdTypeList INT = StdTypeList.make(Type.INT);
/** {@code non-null;} the list {@code [long]} */
public static final StdTypeList LONG = StdTypeList.make(Type.LONG);
/** {@code non-null;} the list {@code [float]} */
public static final StdTypeList FLOAT = StdTypeList.make(Type.FLOAT);
/** {@code non-null;} the list {@code [double]} */
public static final StdTypeList DOUBLE = StdTypeList.make(Type.DOUBLE);
/** {@code non-null;} the list {@code [Object]} */
public static final StdTypeList OBJECT = StdTypeList.make(Type.OBJECT);
/** {@code non-null;} the list {@code [ReturnAddress]} */
public static final StdTypeList RETURN_ADDRESS
= StdTypeList.make(Type.RETURN_ADDRESS);
/** {@code non-null;} the list {@code [Throwable]} */
public static final StdTypeList THROWABLE =
StdTypeList.make(Type.THROWABLE);
/** {@code non-null;} the list {@code [int, int]} */
public static final StdTypeList INT_INT =
StdTypeList.make(Type.INT, Type.INT);
/** {@code non-null;} the list {@code [long, long]} */
public static final StdTypeList LONG_LONG =
StdTypeList.make(Type.LONG, Type.LONG);
/** {@code non-null;} the list {@code [float, float]} */
public static final StdTypeList FLOAT_FLOAT =
StdTypeList.make(Type.FLOAT, Type.FLOAT);
/** {@code non-null;} the list {@code [double, double]} */
public static final StdTypeList DOUBLE_DOUBLE =
StdTypeList.make(Type.DOUBLE, Type.DOUBLE);
/** {@code non-null;} the list {@code [Object, Object]} */
public static final StdTypeList OBJECT_OBJECT =
StdTypeList.make(Type.OBJECT, Type.OBJECT);
/** {@code non-null;} the list {@code [int, Object]} */
public static final StdTypeList INT_OBJECT =
StdTypeList.make(Type.INT, Type.OBJECT);
/** {@code non-null;} the list {@code [long, Object]} */
public static final StdTypeList LONG_OBJECT =
StdTypeList.make(Type.LONG, Type.OBJECT);
/** {@code non-null;} the list {@code [float, Object]} */
public static final StdTypeList FLOAT_OBJECT =
StdTypeList.make(Type.FLOAT, Type.OBJECT);
/** {@code non-null;} the list {@code [double, Object]} */
public static final StdTypeList DOUBLE_OBJECT =
StdTypeList.make(Type.DOUBLE, Type.OBJECT);
/** {@code non-null;} the list {@code [long, int]} */
public static final StdTypeList LONG_INT =
StdTypeList.make(Type.LONG, Type.INT);
/** {@code non-null;} the list {@code [int[], int]} */
public static final StdTypeList INTARR_INT =
StdTypeList.make(Type.INT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [long[], int]} */
public static final StdTypeList LONGARR_INT =
StdTypeList.make(Type.LONG_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [float[], int]} */
public static final StdTypeList FLOATARR_INT =
StdTypeList.make(Type.FLOAT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [double[], int]} */
public static final StdTypeList DOUBLEARR_INT =
StdTypeList.make(Type.DOUBLE_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [Object[], int]} */
public static final StdTypeList OBJECTARR_INT =
StdTypeList.make(Type.OBJECT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [boolean[], int]} */
public static final StdTypeList BOOLEANARR_INT =
StdTypeList.make(Type.BOOLEAN_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [byte[], int]} */
public static final StdTypeList BYTEARR_INT =
StdTypeList.make(Type.BYTE_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [char[], int]} */
public static final StdTypeList CHARARR_INT =
StdTypeList.make(Type.CHAR_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [short[], int]} */
public static final StdTypeList SHORTARR_INT =
StdTypeList.make(Type.SHORT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [int, int[], int]} */
public static final StdTypeList INT_INTARR_INT =
StdTypeList.make(Type.INT, Type.INT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [long, long[], int]} */
public static final StdTypeList LONG_LONGARR_INT =
StdTypeList.make(Type.LONG, Type.LONG_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [float, float[], int]} */
public static final StdTypeList FLOAT_FLOATARR_INT =
StdTypeList.make(Type.FLOAT, Type.FLOAT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [double, double[], int]} */
public static final StdTypeList DOUBLE_DOUBLEARR_INT =
StdTypeList.make(Type.DOUBLE, Type.DOUBLE_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [Object, Object[], int]} */
public static final StdTypeList OBJECT_OBJECTARR_INT =
StdTypeList.make(Type.OBJECT, Type.OBJECT_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [int, boolean[], int]} */
public static final StdTypeList INT_BOOLEANARR_INT =
StdTypeList.make(Type.INT, Type.BOOLEAN_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [int, byte[], int]} */
public static final StdTypeList INT_BYTEARR_INT =
StdTypeList.make(Type.INT, Type.BYTE_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [int, char[], int]} */
public static final StdTypeList INT_CHARARR_INT =
StdTypeList.make(Type.INT, Type.CHAR_ARRAY, Type.INT);
/** {@code non-null;} the list {@code [int, short[], int]} */
public static final StdTypeList INT_SHORTARR_INT =
StdTypeList.make(Type.INT, Type.SHORT_ARRAY, Type.INT);
/**
* Makes a single-element instance.
*
* @param type {@code non-null;} the element
* @return {@code non-null;} an appropriately-constructed instance
*/
public static StdTypeList make(Type type) {
StdTypeList result = new StdTypeList(1);
result.set(0, type);
return result;
}
/**
* Makes a two-element instance.
*
* @param type0 {@code non-null;} the first element
* @param type1 {@code non-null;} the second element
* @return {@code non-null;} an appropriately-constructed instance
*/
public static StdTypeList make(Type type0, Type type1) {
StdTypeList result = new StdTypeList(2);
result.set(0, type0);
result.set(1, type1);
return result;
}
/**
* Makes a three-element instance.
*
* @param type0 {@code non-null;} the first element
* @param type1 {@code non-null;} the second element
* @param type2 {@code non-null;} the third element
* @return {@code non-null;} an appropriately-constructed instance
*/
public static StdTypeList make(Type type0, Type type1, Type type2) {
StdTypeList result = new StdTypeList(3);
result.set(0, type0);
result.set(1, type1);
result.set(2, type2);
return result;
}
/**
* Makes a four-element instance.
*
* @param type0 {@code non-null;} the first element
* @param type1 {@code non-null;} the second element
* @param type2 {@code non-null;} the third element
* @param type3 {@code non-null;} the fourth element
* @return {@code non-null;} an appropriately-constructed instance
*/
public static StdTypeList make(Type type0, Type type1, Type type2,
Type type3) {
StdTypeList result = new StdTypeList(4);
result.set(0, type0);
result.set(1, type1);
result.set(2, type2);
result.set(3, type3);
return result;
}
/**
* Returns the given list as a comma-separated list of human forms. This
* is a static method so as to work on arbitrary {@link TypeList}
* instances.
*
* @param list {@code non-null;} the list to convert
* @return {@code non-null;} the human form
*/
public static String toHuman(TypeList list) {
int size = list.size();
if (size == 0) {
return "<empty>";
}
StringBuffer sb = new StringBuffer(100);
for (int i = 0; i < size; i++) {
if (i != 0) {
sb.append(", ");
}
sb.append(list.getType(i).toHuman());
}
return sb.toString();
}
/**
* Returns a hashcode of the contents of the given list. This
* is a static method so as to work on arbitrary {@link TypeList}
* instances.
*
* @param list {@code non-null;} the list to inspect
* @return {@code non-null;} the hash code
*/
public static int hashContents(TypeList list) {
int size = list.size();
int hash = 0;
for (int i = 0; i < size; i++) {
hash = (hash * 31) + list.getType(i).hashCode();
}
return hash;
}
/**
* Compares the contents of the given two instances for equality. This
* is a static method so as to work on arbitrary {@link TypeList}
* instances.
*
* @param list1 {@code non-null;} one list to compare
* @param list2 {@code non-null;} another list to compare
* @return whether the two lists contain corresponding equal elements
*/
public static boolean equalContents(TypeList list1, TypeList list2) {
int size = list1.size();
if (list2.size() != size) {
return false;
}
for (int i = 0; i < size; i++) {
if (! list1.getType(i).equals(list2.getType(i))) {
return false;
}
}
return true;
}
/**
* Compares the contents of the given two instances for ordering. This
* is a static method so as to work on arbitrary {@link TypeList}
* instances.
*
* @param list1 {@code non-null;} one list to compare
* @param list2 {@code non-null;} another list to compare
* @return the order of the two lists
*/
public static int compareContents(TypeList list1, TypeList list2) {
int size1 = list1.size();
int size2 = list2.size();
int size = Math.min(size1, size2);
for (int i = 0; i < size; i++) {
int comparison = list1.getType(i).compareTo(list2.getType(i));
if (comparison != 0) {
return comparison;
}
}
if (size1 == size2) {
return 0;
} else if (size1 < size2) {
return -1;
} else {
return 1;
}
}
/**
* Constructs an instance. All indices initially contain {@code null}.
*
* @param size the size of the list
*/
public StdTypeList(int size) {
super(size);
}
/** {@inheritDoc} */
public Type getType(int n) {
return get(n);
}
/** {@inheritDoc} */
public int getWordCount() {
int sz = size();
int result = 0;
for (int i = 0; i < sz; i++) {
result += get(i).getCategory();
}
return result;
}
/** {@inheritDoc} */
public TypeList withAddedType(Type type) {
int sz = size();
StdTypeList result = new StdTypeList(sz + 1);
for (int i = 0; i < sz; i++) {
result.set0(i, get0(i));
}
result.set(sz, type);
result.setImmutable();
return result;
}
/**
* 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}.
*
* @param n {@code >= 0, < size();} which element
* @return {@code non-null;} the indicated element
*/
public Type get(int n) {
return (Type) get0(n);
}
/**
* Sets the type at the given index.
*
* @param n {@code >= 0, < size();} which element
* @param type {@code non-null;} the type to store
*/
public void set(int n, Type type) {
set0(n, type);
}
/**
* Returns a new instance, which is the same as this instance,
* except that it has an additional type prepended to the
* original.
*
* @param type {@code non-null;} the new first element
* @return {@code non-null;} an appropriately-constructed instance
*/
public StdTypeList withFirst(Type type) {
int sz = size();
StdTypeList result = new StdTypeList(sz + 1);
result.set0(0, type);
for (int i = 0; i < sz; i++) {
result.set0(i + 1, getOrNull0(i));
}
return result;
}
}
|
