org.mvel2.util.FastList Maven / Gradle / Ivy
/**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* 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 org.mvel2.util;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import org.mvel2.ImmutableElementException;
public class FastList extends AbstractList implements Externalizable {
private E[] elements;
private int size = 0;
private boolean updated = false;
public FastList(int size) {
elements = (E[]) new Object[size == 0 ? 1 : size];
}
public FastList(E[] elements) {
this.size = (this.elements = elements).length;
}
public FastList() {
this(10);
}
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(size);
for (int i = 0; i < size; i++) {
out.writeObject(elements[i]);
}
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
elements = (E[]) new Object[size = in.readInt()];
for (int i = 0; i < size; i++) {
elements[i] = (E) in.readObject();
}
}
public E get(int index) {
return (E) elements[index];
}
public int size() {
return size;
}
public boolean add(E o) {
if (size == elements.length) {
increaseSize(elements.length * 2);
}
elements[size++] = o;
return true;
}
public E set(int i, E o) {
if (!updated) copyArray();
E old = elements[i];
elements[i] = o;
return old;
}
public void add(int i, E o) {
if (size == elements.length) {
increaseSize(elements.length * 2);
}
for (int c = size; c != i; c--) {
elements[c] = elements[c - 1];
}
elements[i] = o;
size++;
}
public E remove(int i) {
E old = elements[i];
for (int c = i + 1; c < size; c++) {
elements[c - 1] = elements[c];
elements[c] = null;
}
size--;
return old;
}
public int indexOf(Object o) {
if (o == null) return -1;
for (int i = 0; i < elements.length; i++) {
if (o.equals(elements[i])) return i;
}
return -1;
}
public int lastIndexOf(Object o) {
if (o == null) return -1;
for (int i = elements.length - 1; i != -1; i--) {
if (o.equals(elements[i])) return i;
}
return -1;
}
public void clear() {
elements = (E[]) new Object[1];
size = 0;
}
public boolean addAll(int i, Collection collection) {
int offset = collection.size();
ensureCapacity(offset + size);
if (i != 0) {
// copy forward all elements that the insertion is occuring before
for (int c = i; c != (i + offset); c++) {
elements[c + offset + 1] = elements[c];
}
}
int c = size == 0 ? -1 : 0;
for (E o : collection) {
elements[offset + c++] = o;
}
size += offset;
return true;
}
public Iterator iterator() {
final int size = this.size;
return new Iterator() {
private int cursor = 0;
public boolean hasNext() {
return cursor < size;
}
public Object next() {
return elements[cursor++];
}
public void remove() {
throw new ImmutableElementException("cannot change elements in immutable list");
}
};
}
public ListIterator listIterator() {
return new ListIterator() {
private int i = -1;
public boolean hasNext() {
return i < size - 1;
}
public E next() {
return elements[++i];
}
public boolean hasPrevious() {
return i > 0;
}
public E previous() {
return elements[--i];
}
public int nextIndex() {
return i++;
}
public int previousIndex() {
return i--;
}
public void remove() {
throw new java.lang.UnsupportedOperationException();
}
public void set(E o) {
elements[i] = o;
}
public void add(Object o) {
throw new java.lang.UnsupportedOperationException();
}
};
}
public ListIterator listIterator(int i) {
return super.listIterator(i);
}
public List subList(int i, int i1) {
return super.subList(i, i1);
}
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof List)) return false;
ListIterator e1 = listIterator();
ListIterator e2 = ((List) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
Object o1 = e1.next();
Object o2 = e2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2))) return false;
}
return !(e1.hasNext() || e2.hasNext());
}
public int hashCode() {
return super.hashCode();
}
protected void removeRange(int i, int i1) {
throw new RuntimeException("not implemented");
}
public boolean isEmpty() {
return size == 0;
}
public boolean contains(Object o) {
return indexOf(o) != -1;
}
public Object[] toArray() {
return toArray(new Object[size]);
}
public Object[] toArray(Object[] objects) {
if (objects.length < size) objects = new Object[size];
for (int i = 0; i < size; i++) {
objects[i] = elements[i];
}
return objects;
}
public boolean remove(Object o) {
throw new RuntimeException("not implemented");
}
public boolean containsAll(Collection collection) {
throw new RuntimeException("not implemented");
}
public boolean addAll(Collection collection) {
return addAll(size, collection);
}
public boolean removeAll(Collection collection) {
throw new RuntimeException("not implemented");
}
public boolean retainAll(Collection collection) {
throw new RuntimeException("not implemented");
}
private void ensureCapacity(int additional) {
if ((size + additional) > elements.length) increaseSize((size + additional) * 2);
}
private void copyArray() {
increaseSize(elements.length);
}
private void increaseSize(int newSize) {
E[] newElements = (E[]) new Object[newSize];
for (int i = 0; i < elements.length; i++)
newElements[i] = elements[i];
elements = newElements;
updated = true;
}
public String toString() {
return super.toString();
}
}