/*
Реализация среды исполнения языка программирования
Объектно-ориентированный продвинутый векторный транслятор
Copyright © 2021, 2024 Малик Разработчик
Это свободная программа: вы можете перераспространять ее и/или изменять
ее на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
в каком она была опубликована Фондом свободного программного обеспечения;
либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
Эта программа распространяется в надежде, что она будет полезной,
но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
общественной лицензии GNU.
Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
вместе с этой программой. Если это не так, см.
<https://www.gnu.org/licenses/>.
*/
package avt.util;
import avt.lang.array.*;
import platform.independent.streamformat.*;
/* СДЕЛАТЬ:
* -заменить в методах reverse, subvector, append, appendf, appenda, insert, insertf, inserta, delete, trimToLength и trimToSubvector возвращаемое значение с Vector на void.
*/
public class Vector(Object, MutableDataHolder, Cloneable, DataHolder, Measureable, MutableObjectArray, ObjectArray)
{
protected int fldLength;
protected Object[] fldElements;
public () {
fldElements = new Object[0x0f];
}
public (int initialCapacity) {
fldElements = new Object[initialCapacity <= 1 ? 1 : initialCapacity];
}
protected (int length, Object[] elements) {
fldLength = length;
fldElements = elements;
}
public String toString() {
StringBuilder result = new StringBuilder() + "[ ";
for(Object[] elements = fldElements, int limit = fldLength - 1, int index = 0; index <= limit; index++)
{
result + elements[index];
if(index < limit) result + ", ";
}
return (result + " ]").toString();
}
public void clear() { setLength(0); }
public Vector clone() { return new Vector(fldLength, fldElements.clone()); }
public void ensureCapacity(int minCapacity) {
if(minCapacity >= 0)
{
Object[] elements = fldElements;
int curCapacity = elements.length;
if(minCapacity > curCapacity)
{
int newCapacity = curCapacity >= (Int.MAX_VALUE >> 1) ? Int.MAX_VALUE : curCapacity << 1 | 1;
if(minCapacity > newCapacity) newCapacity = minCapacity;
Array.copy(elements, 0, fldElements = new Object[newCapacity], 0, curCapacity);
}
}
}
public int remove(boolean element) { return deleteElement(element ? Boolean.TRUE : Boolean.FALSE); }
public int remove(char element) { return deleteElement(new Char(element)); }
public int remove(byte element) { return deleteElement(new Byte(element)); }
public int remove(byte2 element) { return deleteElement(new Byte2(element)); }
public int remove(byte4 element) { return deleteElement(new Byte4(element)); }
public int remove(byte8 element) { return deleteElement(new Byte8(element)); }
public int remove(short element) { return deleteElement(new Short(element)); }
public int remove(short2 element) { return deleteElement(new Short2(element)); }
public int remove(short4 element) { return deleteElement(new Short4(element)); }
public int remove(short8 element) { return deleteElement(new Short8(element)); }
public int remove(int element) { return deleteElement(new Int(element)); }
public int remove(int2 element) { return deleteElement(new Int2(element)); }
public int remove(int4 element) { return deleteElement(new Int4(element)); }
public int remove(int8 element) { return deleteElement(new Int8(element)); }
public int remove(long element) { return deleteElement(new Long(element)); }
public int remove(long2 element) { return deleteElement(new Long2(element)); }
public int remove(long4 element) { return deleteElement(new Long4(element)); }
public int remove(long8 element) { return deleteElement(new Long8(element)); }
public int remove(Object element) { return deleteElement(element); }
public Vector reverse() {
reverseElements();
return this;
}
public Vector subvector(int beginIndex) {
int endIndex = fldLength;
checkBounds(beginIndex, endIndex);
deleteTails(beginIndex, endIndex, false);
return this;
}
public Vector subvector(int beginIndex, int endIndex) {
checkBounds(beginIndex, endIndex);
deleteTails(beginIndex, endIndex, false);
return this;
}
public Vector append(boolean src) {
appendObject(new Boolean(src));
return this;
}
public Vector append(char src) {
appendObject(new Char(src));
return this;
}
public Vector append(byte src) {
appendObject(new Byte(src));
return this;
}
public Vector append(byte2 src) {
appendObject(new Byte2(src));
return this;
}
public Vector append(byte4 src) {
appendObject(new Byte4(src));
return this;
}
public Vector append(byte8 src) {
appendObject(new Byte8(src));
return this;
}
public Vector append(short src) {
appendObject(new Short(src));
return this;
}
public Vector append(short2 src) {
appendObject(new Short2(src));
return this;
}
public Vector append(short4 src) {
appendObject(new Short4(src));
return this;
}
public Vector append(short8 src) {
appendObject(new Short8(src));
return this;
}
public Vector append(int src) {
appendObject(new Int(src));
return this;
}
public Vector append(int2 src) {
appendObject(new Int2(src));
return this;
}
public Vector append(int4 src) {
appendObject(new Int4(src));
return this;
}
public Vector append(int8 src) {
appendObject(new Int8(src));
return this;
}
public Vector append(long src) {
appendObject(new Long(src));
return this;
}
public Vector append(long2 src) {
appendObject(new Long2(src));
return this;
}
public Vector append(long4 src) {
appendObject(new Long4(src));
return this;
}
public Vector append(long8 src) {
appendObject(new Long8(src));
return this;
}
public Vector append(float src) {
appendObject(new Float(src));
return this;
}
public Vector append(float2 src) {
appendObject(new Float2(src));
return this;
}
public Vector append(float4 src) {
appendObject(new Float4(src));
return this;
}
public Vector append(float8 src) {
appendObject(new Float8(src));
return this;
}
public Vector append(double src) {
appendObject(new Double(src));
return this;
}
public Vector append(double2 src) {
appendObject(new Double2(src));
return this;
}
public Vector append(double4 src) {
appendObject(new Double4(src));
return this;
}
public Vector append(double8 src) {
appendObject(new Double8(src));
return this;
}
public Vector append(real src) {
appendObject(new Real(src));
return this;
}
public Vector append(Object src) {
appendObject(src);
return this;
}
public Vector appendf(String form, ObjectArray data) {
appendObject(String.format(form, data));
return this;
}
public Vector appenda(ObjectArray src) {
if(src != null)
{
appendArray(src, 0, src.length);
}
return this;
}
public Vector appenda(ObjectArray src, int offset, int length) {
if(src != null)
{
int2 bounds = Array.intersectBounds(src, offset, length);
appendArray(src, bounds[0], bounds[1]);
}
return this;
}
public Vector insert(int index, boolean src) {
insertObject(index, new Boolean(src));
return this;
}
public Vector insert(int index, char src) {
insertObject(index, new Char(src));
return this;
}
public Vector insert(int index, byte src) {
insertObject(index, new Byte(src));
return this;
}
public Vector insert(int index, byte2 src) {
insertObject(index, new Byte2(src));
return this;
}
public Vector insert(int index, byte4 src) {
insertObject(index, new Byte4(src));
return this;
}
public Vector insert(int index, byte8 src) {
insertObject(index, new Byte8(src));
return this;
}
public Vector insert(int index, short src) {
insertObject(index, new Short(src));
return this;
}
public Vector insert(int index, short2 src) {
insertObject(index, new Short2(src));
return this;
}
public Vector insert(int index, short4 src) {
insertObject(index, new Short4(src));
return this;
}
public Vector insert(int index, short8 src) {
insertObject(index, new Short8(src));
return this;
}
public Vector insert(int index, int src) {
insertObject(index, new Int(src));
return this;
}
public Vector insert(int index, int2 src) {
insertObject(index, new Int2(src));
return this;
}
public Vector insert(int index, int4 src) {
insertObject(index, new Int4(src));
return this;
}
public Vector insert(int index, int8 src) {
insertObject(index, new Int8(src));
return this;
}
public Vector insert(int index, long src) {
insertObject(index, new Long(src));
return this;
}
public Vector insert(int index, long2 src) {
insertObject(index, new Long2(src));
return this;
}
public Vector insert(int index, long4 src) {
insertObject(index, new Long4(src));
return this;
}
public Vector insert(int index, long8 src) {
insertObject(index, new Long8(src));
return this;
}
public Vector insert(int index, float src) {
insertObject(index, new Float(src));
return this;
}
public Vector insert(int index, float2 src) {
insertObject(index, new Float2(src));
return this;
}
public Vector insert(int index, float4 src) {
insertObject(index, new Float4(src));
return this;
}
public Vector insert(int index, float8 src) {
insertObject(index, new Float8(src));
return this;
}
public Vector insert(int index, double src) {
insertObject(index, new Double(src));
return this;
}
public Vector insert(int index, double2 src) {
insertObject(index, new Double2(src));
return this;
}
public Vector insert(int index, double4 src) {
insertObject(index, new Double4(src));
return this;
}
public Vector insert(int index, double8 src) {
insertObject(index, new Double8(src));
return this;
}
public Vector insert(int index, real src) {
insertObject(index, new Real(src));
return this;
}
public Vector insert(int index, Object src) {
insertObject(index, src);
return this;
}
public Vector insertf(int index, String form, ObjectArray data) {
insertObject(index, String.format(form, data));
return this;
}
public Vector inserta(int index, ObjectArray src) {
if(src != null)
{
insertArray(index, src, 0, src.length);
}
return this;
}
public Vector inserta(int index, ObjectArray src, int offset, int length) {
if(src != null)
{
int2 bounds = Array.intersectBounds(src, offset, length);
insertArray(index, src, bounds[0], bounds[1]);
}
return this;
}
public Vector delete(int beginIndex, int endIndex) {
checkBounds(beginIndex, endIndex);
deletePortion(beginIndex, endIndex);
return this;
}
public Vector delete(int index) {
checkIndex(index);
deletePortion(index, index + 1);
return this;
}
public Vector trimToLength() {
deleteTails(0, fldLength, true);
return this;
}
public Vector trimToSubvector(int beginIndex) {
int endIndex = fldLength;
checkBounds(beginIndex, endIndex);
deleteTails(beginIndex, endIndex, true);
return this;
}
public Vector trimToSubvector(int beginIndex, int endIndex) {
checkBounds(beginIndex, endIndex);
deleteTails(beginIndex, endIndex, true);
return this;
}
public final boolean isEmpty() { return fldLength <= 0; }
public final void getElements(int beginIndex, int endIndex, MutableObjectArray dst, int offset) {
int length = fldLength;
Object[] elements = fldElements;
if((beginIndex | endIndex) < 0 || beginIndex > length || endIndex > length || beginIndex > endIndex)
{
throw new IndexOutOfBoundsException(avt.lang.package.getResourceString("out-of-bounds.vector-index"));
}
if(dst == null)
{
throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "dst" }));
}
if(dst == this || dst == elements)
{
throw new IllegalArgumentException(String.format(avt.lang.package.getResourceString("illegal-argument"), new Object[] { "dst" }));
}
for(Array.checkBounds(dst, offset, length = endIndex - beginIndex); length-- > 0; ) dst[offset++] = elements[beginIndex++];
}
public final void copyInto(MutableObjectArray dst, int offset) { getElements(0, fldLength, dst, offset); }
public final boolean contains(boolean element) { return contains(element ? Boolean.TRUE : Boolean.FALSE); }
public final boolean contains(char element) { return contains(new Char(element)); }
public final boolean contains(byte element) { return contains(new Byte(element)); }
public final boolean contains(byte2 element) { return contains(new Byte2(element)); }
public final boolean contains(byte4 element) { return contains(new Byte4(element)); }
public final boolean contains(byte8 element) { return contains(new Byte8(element)); }
public final boolean contains(short element) { return contains(new Short(element)); }
public final boolean contains(short2 element) { return contains(new Short2(element)); }
public final boolean contains(short4 element) { return contains(new Short4(element)); }
public final boolean contains(short8 element) { return contains(new Short8(element)); }
public final boolean contains(int element) { return contains(new Int(element)); }
public final boolean contains(int2 element) { return contains(new Int2(element)); }
public final boolean contains(int4 element) { return contains(new Int4(element)); }
public final boolean contains(int8 element) { return contains(new Int8(element)); }
public final boolean contains(long element) { return contains(new Long(element)); }
public final boolean contains(long2 element) { return contains(new Long2(element)); }
public final boolean contains(long4 element) { return contains(new Long4(element)); }
public final boolean contains(long8 element) { return contains(new Long8(element)); }
public final boolean contains(Object element) {
if(element == null)
{
return Array.lastIndexOf(null, fldElements, fldLength - 1, 0) >= 0;
}
for(Object[] elements = fldElements, int index = fldLength; index-- > 0; ) if(element.equals(elements[index]))
{
return true;
}
return false;
}
public final int indexOf(boolean element) { return indexOf(element ? Boolean.TRUE : Boolean.FALSE, 0); }
public final int indexOf(char element) { return indexOf(new Char(element), 0); }
public final int indexOf(byte element) { return indexOf(new Byte(element), 0); }
public final int indexOf(byte2 element) { return indexOf(new Byte2(element), 0); }
public final int indexOf(byte4 element) { return indexOf(new Byte4(element), 0); }
public final int indexOf(byte8 element) { return indexOf(new Byte8(element), 0); }
public final int indexOf(short element) { return indexOf(new Short(element), 0); }
public final int indexOf(short2 element) { return indexOf(new Short2(element), 0); }
public final int indexOf(short4 element) { return indexOf(new Short4(element), 0); }
public final int indexOf(short8 element) { return indexOf(new Short8(element), 0); }
public final int indexOf(int element) { return indexOf(new Int(element), 0); }
public final int indexOf(int2 element) { return indexOf(new Int2(element), 0); }
public final int indexOf(int4 element) { return indexOf(new Int4(element), 0); }
public final int indexOf(int8 element) { return indexOf(new Int8(element), 0); }
public final int indexOf(long element) { return indexOf(new Long(element), 0); }
public final int indexOf(long2 element) { return indexOf(new Long2(element), 0); }
public final int indexOf(long4 element) { return indexOf(new Long4(element), 0); }
public final int indexOf(long8 element) { return indexOf(new Long8(element), 0); }
public final int indexOf(Object element) { return indexOf(element, 0); }
public final int indexOf(boolean element, int startFromIndex) { return indexOf(element ? Boolean.TRUE : Boolean.FALSE, startFromIndex); }
public final int indexOf(char element, int startFromIndex) { return indexOf(new Char(element), startFromIndex); }
public final int indexOf(byte element, int startFromIndex) { return indexOf(new Byte(element), startFromIndex); }
public final int indexOf(byte2 element, int startFromIndex) { return indexOf(new Byte2(element), startFromIndex); }
public final int indexOf(byte4 element, int startFromIndex) { return indexOf(new Byte4(element), startFromIndex); }
public final int indexOf(byte8 element, int startFromIndex) { return indexOf(new Byte8(element), startFromIndex); }
public final int indexOf(short element, int startFromIndex) { return indexOf(new Short(element), startFromIndex); }
public final int indexOf(short2 element, int startFromIndex) { return indexOf(new Short2(element), startFromIndex); }
public final int indexOf(short4 element, int startFromIndex) { return indexOf(new Short4(element), startFromIndex); }
public final int indexOf(short8 element, int startFromIndex) { return indexOf(new Short8(element), startFromIndex); }
public final int indexOf(int element, int startFromIndex) { return indexOf(new Int(element), startFromIndex); }
public final int indexOf(int2 element, int startFromIndex) { return indexOf(new Int2(element), startFromIndex); }
public final int indexOf(int4 element, int startFromIndex) { return indexOf(new Int4(element), startFromIndex); }
public final int indexOf(int8 element, int startFromIndex) { return indexOf(new Int8(element), startFromIndex); }
public final int indexOf(long element, int startFromIndex) { return indexOf(new Long(element), startFromIndex); }
public final int indexOf(long2 element, int startFromIndex) { return indexOf(new Long2(element), startFromIndex); }
public final int indexOf(long4 element, int startFromIndex) { return indexOf(new Long4(element), startFromIndex); }
public final int indexOf(long8 element, int startFromIndex) { return indexOf(new Long8(element), startFromIndex); }
public final int indexOf(Object element, int startFromIndex) {
int length = fldLength;
if(startFromIndex < 0)
{
startFromIndex = 0;
}
if(element == null)
{
return startFromIndex >= length ? -1 : Array.indexOf(null, fldElements, startFromIndex, length - startFromIndex);
}
for(Object[] elements = fldElements; startFromIndex < length; startFromIndex++) if(element.equals(elements[startFromIndex]))
{
return startFromIndex;
}
return -1;
}
public final int lastIndexOf(boolean element) { return lastIndexOf(element ? Boolean.TRUE : Boolean.FALSE, Int.MAX_VALUE); }
public final int lastIndexOf(char element) { return lastIndexOf(new Char(element), Int.MAX_VALUE); }
public final int lastIndexOf(byte element) { return lastIndexOf(new Byte(element), Int.MAX_VALUE); }
public final int lastIndexOf(byte2 element) { return lastIndexOf(new Byte2(element), Int.MAX_VALUE); }
public final int lastIndexOf(byte4 element) { return lastIndexOf(new Byte4(element), Int.MAX_VALUE); }
public final int lastIndexOf(byte8 element) { return lastIndexOf(new Byte8(element), Int.MAX_VALUE); }
public final int lastIndexOf(short element) { return lastIndexOf(new Short(element), Int.MAX_VALUE); }
public final int lastIndexOf(short2 element) { return lastIndexOf(new Short2(element), Int.MAX_VALUE); }
public final int lastIndexOf(short4 element) { return lastIndexOf(new Short4(element), Int.MAX_VALUE); }
public final int lastIndexOf(short8 element) { return lastIndexOf(new Short8(element), Int.MAX_VALUE); }
public final int lastIndexOf(int element) { return lastIndexOf(new Int(element), Int.MAX_VALUE); }
public final int lastIndexOf(int2 element) { return lastIndexOf(new Int2(element), Int.MAX_VALUE); }
public final int lastIndexOf(int4 element) { return lastIndexOf(new Int4(element), Int.MAX_VALUE); }
public final int lastIndexOf(int8 element) { return lastIndexOf(new Int8(element), Int.MAX_VALUE); }
public final int lastIndexOf(long element) { return lastIndexOf(new Long(element), Int.MAX_VALUE); }
public final int lastIndexOf(long2 element) { return lastIndexOf(new Long2(element), Int.MAX_VALUE); }
public final int lastIndexOf(long4 element) { return lastIndexOf(new Long4(element), Int.MAX_VALUE); }
public final int lastIndexOf(long8 element) { return lastIndexOf(new Long8(element), Int.MAX_VALUE); }
public final int lastIndexOf(Object element) { return lastIndexOf(element, Int.MAX_VALUE); }
public final int lastIndexOf(boolean element, int startFromIndex) { return lastIndexOf(element ? Boolean.TRUE : Boolean.FALSE, startFromIndex); }
public final int lastIndexOf(char element, int startFromIndex) { return lastIndexOf(new Char(element), startFromIndex); }
public final int lastIndexOf(byte element, int startFromIndex) { return lastIndexOf(new Byte(element), startFromIndex); }
public final int lastIndexOf(byte2 element, int startFromIndex) { return lastIndexOf(new Byte2(element), startFromIndex); }
public final int lastIndexOf(byte4 element, int startFromIndex) { return lastIndexOf(new Byte4(element), startFromIndex); }
public final int lastIndexOf(byte8 element, int startFromIndex) { return lastIndexOf(new Byte8(element), startFromIndex); }
public final int lastIndexOf(short element, int startFromIndex) { return lastIndexOf(new Short(element), startFromIndex); }
public final int lastIndexOf(short2 element, int startFromIndex) { return lastIndexOf(new Short2(element), startFromIndex); }
public final int lastIndexOf(short4 element, int startFromIndex) { return lastIndexOf(new Short4(element), startFromIndex); }
public final int lastIndexOf(short8 element, int startFromIndex) { return lastIndexOf(new Short8(element), startFromIndex); }
public final int lastIndexOf(int element, int startFromIndex) { return lastIndexOf(new Int(element), startFromIndex); }
public final int lastIndexOf(int2 element, int startFromIndex) { return lastIndexOf(new Int2(element), startFromIndex); }
public final int lastIndexOf(int4 element, int startFromIndex) { return lastIndexOf(new Int4(element), startFromIndex); }
public final int lastIndexOf(int8 element, int startFromIndex) { return lastIndexOf(new Int8(element), startFromIndex); }
public final int lastIndexOf(long element, int startFromIndex) { return lastIndexOf(new Long(element), startFromIndex); }
public final int lastIndexOf(long2 element, int startFromIndex) { return lastIndexOf(new Long2(element), startFromIndex); }
public final int lastIndexOf(long4 element, int startFromIndex) { return lastIndexOf(new Long4(element), startFromIndex); }
public final int lastIndexOf(long8 element, int startFromIndex) { return lastIndexOf(new Long8(element), startFromIndex); }
public final int lastIndexOf(Object element, int startFromIndex) {
int length = fldLength;
if(startFromIndex >= length)
{
startFromIndex = length - 1;
}
if(element == null)
{
return startFromIndex < 0 ? -1 : Array.lastIndexOf(null, fldElements, startFromIndex, startFromIndex + 1);
}
for(Object[] elements = fldElements; startFromIndex >= 0; startFromIndex--) if(element.equals(elements[startFromIndex]))
{
return startFromIndex;
}
return -1;
}
public final Object[] toObjectArray() {
int length = fldLength;
Object[] result = fldElements;
Array.copy(result, 0, result = new Object[length], 0, length);
return result;
}
public final Object firstElement() {
if(fldLength <= 0)
{
throw new EmptyVectorException(package.getResourceString("empty.vector"));
}
return fldElements[0];
}
public final Object lastElement() {
int length = fldLength;
if(length <= 0)
{
throw new EmptyVectorException(package.getResourceString("empty.vector"));
}
return fldElements[length - 1];
}
public final Enumeration enumerateForward() { return new ArrayEnumeration(fldElements, 0, fldLength, false); }
public final Enumeration enumerateReverse() { return new ArrayEnumeration(fldElements, 0, fldLength, true); }
public final int length { read = fldLength, write = setLength }
public final int capacity { read = fldElements.length }
public void operator []=(int index, Object element) {
checkIndex(index);
writeObject(index, element);
}
public final Object operator [](int index) {
checkIndex(index);
return fldElements[index];
}
public final Vector operator +(boolean src) { return append(src); }
public final Vector operator +(char src) { return append(src); }
public final Vector operator +(byte src) { return append(src); }
public final Vector operator +(byte2 src) { return append(src); }
public final Vector operator +(byte4 src) { return append(src); }
public final Vector operator +(byte8 src) { return append(src); }
public final Vector operator +(short src) { return append(src); }
public final Vector operator +(short2 src) { return append(src); }
public final Vector operator +(short4 src) { return append(src); }
public final Vector operator +(short8 src) { return append(src); }
public final Vector operator +(int src) { return append(src); }
public final Vector operator +(int2 src) { return append(src); }
public final Vector operator +(int4 src) { return append(src); }
public final Vector operator +(int8 src) { return append(src); }
public final Vector operator +(long src) { return append(src); }
public final Vector operator +(long2 src) { return append(src); }
public final Vector operator +(long4 src) { return append(src); }
public final Vector operator +(long8 src) { return append(src); }
public final Vector operator +(float src) { return append(src); }
public final Vector operator +(float2 src) { return append(src); }
public final Vector operator +(float4 src) { return append(src); }
public final Vector operator +(float8 src) { return append(src); }
public final Vector operator +(double src) { return append(src); }
public final Vector operator +(double2 src) { return append(src); }
public final Vector operator +(double4 src) { return append(src); }
public final Vector operator +(double8 src) { return append(src); }
public final Vector operator +(real src) { return append(src); }
public final Vector operator +(Object src) { return append(src); }
protected void setLength(int newLength) {
if(newLength < 0)
{
throw new NegativeArrayLengthException(avt.lang.package.getResourceString("negative-array-length"));
}
int curLength = fldLength;
Object[] elements = fldElements;
if(newLength > elements.length) elements = madeLarger(newLength);
if(newLength < curLength) Array.fill(elements, newLength, curLength - newLength, null);
fldLength = newLength;
}
protected void reverseElements() {
int length = fldLength;
Object[] elements = fldElements;
for(int eli = length >> 1, int elj = length - eli; eli-- > 0; elj++)
{
Object element = elements[eli];
elements[eli] = elements[elj];
elements[elj] = element;
}
}
protected void writeObject(int index, Object src) {
fldElements[index] = src;
}
protected void appendObject(Object src) {
int length = fldLength;
Object[] elements = madeLarger(length + 1);
elements[length++] = src;
fldLength = length;
}
protected void appendArray(ObjectArray src, int offset, int length) {
if(length > 0)
{
int curLength = fldLength;
int newLength = curLength + length;
Object[] elements = madeLarger(newLength);
if(src instanceof Vector)
{
src = ((Vector) src).fldElements;
}
if(src instanceof Object[])
{
Array.copy((Object[]) src, offset, elements, curLength, length);
} else
{
while(length-- > 0) elements[curLength++] = src[offset++];
}
fldLength = newLength;
}
}
protected void insertObject(int index, Object src) {
int length = fldLength;
Object[] elements = madeLarger(length + 1);
if(index < 0) index = 0;
if(index > length) index = length;
Array.copy(elements, index, elements, index + 1, length++ - index);
elements[index] = src;
fldLength = length;
}
protected void insertArray(int index, ObjectArray src, int offset, int length) {
if(length > 0)
{
int curLength = fldLength;
int newLength = curLength + length;
Object[] elements = madeLarger(newLength);
Array.copy(elements, index, elements, index + length, curLength - index);
if(src instanceof Vector)
{
src = ((Vector) src).fldElements;
}
if(src instanceof Object[])
{
Array.copy((Object[]) src, offset, elements, index, length);
} else
{
while(length-- > 0) elements[index++] = src[offset++];
}
fldLength = newLength;
}
}
protected void deletePortion(int beginIndex, int endIndex) {
int length = endIndex - beginIndex;
if(length > 0)
{
int curLength = fldLength;
int newLength = curLength - length;
Object[] elements = fldElements;
Array.copy(elements, endIndex, elements, beginIndex, curLength - endIndex);
Array.fill(elements, newLength, length, null);
fldLength = newLength;
}
}
protected void deleteTails(int beginIndex, int endIndex, boolean isTrim) {
int newLength = endIndex - beginIndex;
Object[] elements = fldElements;
if(!isTrim)
{
if(beginIndex > 0) Array.copy(elements, beginIndex, elements, 0, newLength);
Array.fill(elements, newLength, fldLength - newLength, null);
fldLength = newLength;
}
else if(beginIndex > 0 || endIndex < elements.length)
{
Array.copy(elements, beginIndex, fldElements = new Object[newLength], 0, newLength);
fldLength = newLength;
}
}
protected int deleteElement(Object element) {
int index = -1;
int length = fldLength;
Object[] elements = fldElements;
if(element == null)
{
if(length > 0) index = Array.indexOf(null, elements, 0, length);
}
else for(int position = 0; position < length; position++) if(element.equals(elements[position]))
{
index = position;
break;
}
if(index >= 0)
{
Array.copy(elements, index + 1, elements, index, --length - index);
elements[fldLength = length] = null;
}
return index;
}
protected Object[] madeLarger(int minCapacity) {
if(minCapacity < 0)
{
throw new BufferTooLargeError(avt.lang.package.getResourceString("!error.buffer-too-large"));
}
Object[] elements = fldElements;
int curCapacity = elements.length;
if(minCapacity > curCapacity)
{
int newCapacity = curCapacity >= (Int.MAX_VALUE >> 1) ? Int.MAX_VALUE : curCapacity << 1 | 1;
if(minCapacity > newCapacity) newCapacity = minCapacity;
Array.copy(elements, 0, fldElements = elements = new Object[newCapacity], 0, curCapacity);
}
return elements;
}
protected final void checkBounds(int beginIndex, int endIndex) {
int length = fldLength;
if((beginIndex | endIndex) < 0 || beginIndex > length || endIndex > length || beginIndex > endIndex)
{
throw new IndexOutOfBoundsException(avt.lang.package.getResourceString("out-of-bounds.vector-index"));
}
}
protected final void checkIndex(int index) {
if(index < 0 || index >= fldLength)
{
throw new IndexOutOfBoundsException(avt.lang.package.getResourceString("out-of-bounds.vector-index"));
}
}
}
