Vector.avt

/*
    Исходный код среды исполнения ПВТ-ОО.

    Этот исходный код является частью проекта ПВТ-ОО.

    Copyright © 2021 Малик Разработчик

    Это свободная программа: вы можете перераспространять её и/или
    изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
    в каком она была опубликована Фондом свободного программного обеспечения;
    либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.

    Эта программа распространяется в надежде, что она может быть полезна,
    но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
    или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
    общественной лицензии GNU.

    Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
    вместе с этой программой. Если это не так, см.
    <http://www.gnu.org/licenses/>.
*/

package avt.util;

import avt.lang.array.*;
import platform.independent.streamformat.*;

public class Vector(Object, MutableDataHolder, DataHolder, Cloneable, Measureable, MutableObjectArray, ObjectArray)
{
    protected int fldLength;
    protected Object[] fldElements;

    public () { fldElements = new Object[15]; }

    public (int initialCapacity) { fldElements = new Object[initialCapacity <= 1 ? 1 : initialCapacity]; }

    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() {
        Array.fill(fldElements, 0, fldLength, null);
        fldLength = 0;
    }

    public boolean isEmpty() { return fldLength <= 0; }

    public Vector clone() {
        int length = fldLength;
        Vector result = new Vector(length);
        Array.copy(fldElements, 0, result.fldElements, 0, length);
        return result;
    }

    public void getElements(int beginIndex, int endIndex, MutableObjectArray dst, int offset) {
        int length = fldLength;
        if((beginIndex | endIndex) < 0 || beginIndex > length || endIndex > length || beginIndex > endIndex)
        {
            throw new IndexOutOfBoundsException("индекс элемента вектора выходит из диапазона");
        }
        if(dst == null)
        {
            throw new NullPointerException("аргумент dst равен нулевой ссылке");
        }
        if(dst == this)
        {
            throw new IllegalArgumentException("аргумент dst равен этому вектору");
        }
        Array.checkBounds(dst, offset, length = endIndex - beginIndex);
        for(Object[] elements = fldElements; length-- > 0; ) dst[offset++] = elements[beginIndex++];
    }

    public void copyInto(MutableObjectArray dst, int offset) {
        if(dst == null)
        {
            throw new NullPointerException("аргумент dst равен нулевой ссылке");
        }
        if(dst == this)
        {
            throw new IllegalArgumentException("аргумент dst равен этому вектору");
        }
        int length = fldLength;
        Array.checkBounds(dst, offset, length);
        for(Object[] elements = fldElements, int index = 0; length-- > 0; ) dst[offset++] = elements[index++];
    }

    public boolean contains(boolean element) { return findForward(element ? Boolean.TRUE : Boolean.FALSE, 0) >= 0; }

    public boolean contains(char element) { return findForward(new Char(element), 0) >= 0; }

    public boolean contains(byte element) { return findForward(new Byte(element), 0) >= 0; }

    public boolean contains(byte2 element) { return findForward(new Byte2(element), 0) >= 0; }

    public boolean contains(byte4 element) { return findForward(new Byte4(element), 0) >= 0; }

    public boolean contains(byte8 element) { return findForward(new Byte8(element), 0) >= 0; }

    public boolean contains(short element) { return findForward(new Short(element), 0) >= 0; }

    public boolean contains(short2 element) { return findForward(new Short2(element), 0) >= 0; }

    public boolean contains(short4 element) { return findForward(new Short4(element), 0) >= 0; }

    public boolean contains(short8 element) { return findForward(new Short8(element), 0) >= 0; }

    public boolean contains(int element) { return findForward(new Int(element), 0) >= 0; }

    public boolean contains(int2 element) { return findForward(new Int2(element), 0) >= 0; }

    public boolean contains(int4 element) { return findForward(new Int4(element), 0) >= 0; }

    public boolean contains(int8 element) { return findForward(new Int8(element), 0) >= 0; }

    public boolean contains(long element) { return findForward(new Long(element), 0) >= 0; }

    public boolean contains(long2 element) { return findForward(new Long2(element), 0) >= 0; }

    public boolean contains(long4 element) { return findForward(new Long4(element), 0) >= 0; }

    public boolean contains(long8 element) { return findForward(new Long8(element), 0) >= 0; }

    public boolean contains(Object element) { return findForward(element, 0) >= 0; }

    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 int indexOf(boolean element) { return findForward(element ? Boolean.TRUE : Boolean.FALSE, 0); }

    public int indexOf(char element) { return findForward(new Char(element), 0); }

    public int indexOf(byte element) { return findForward(new Byte(element), 0); }

    public int indexOf(byte2 element) { return findForward(new Byte2(element), 0); }

    public int indexOf(byte4 element) { return findForward(new Byte4(element), 0); }

    public int indexOf(byte8 element) { return findForward(new Byte8(element), 0); }

    public int indexOf(short element) { return findForward(new Short(element), 0); }

    public int indexOf(short2 element) { return findForward(new Short2(element), 0); }

    public int indexOf(short4 element) { return findForward(new Short4(element), 0); }

    public int indexOf(short8 element) { return findForward(new Short8(element), 0); }

    public int indexOf(int element) { return findForward(new Int(element), 0); }

    public int indexOf(int2 element) { return findForward(new Int2(element), 0); }

    public int indexOf(int4 element) { return findForward(new Int4(element), 0); }

    public int indexOf(int8 element) { return findForward(new Int8(element), 0); }

    public int indexOf(long element) { return findForward(new Long(element), 0); }

    public int indexOf(long2 element) { return findForward(new Long2(element), 0); }

    public int indexOf(long4 element) { return findForward(new Long4(element), 0); }

    public int indexOf(long8 element) { return findForward(new Long8(element), 0); }

    public int indexOf(Object element) { return findForward(element, 0); }

    public int indexOf(boolean element, int startFromIndex) { return findForward(element ? Boolean.TRUE : Boolean.FALSE, startFromIndex); }

    public int indexOf(char element, int startFromIndex) { return findForward(new Char(element), startFromIndex); }

    public int indexOf(byte element, int startFromIndex) { return findForward(new Byte(element), startFromIndex); }

    public int indexOf(byte2 element, int startFromIndex) { return findForward(new Byte2(element), startFromIndex); }

    public int indexOf(byte4 element, int startFromIndex) { return findForward(new Byte4(element), startFromIndex); }

    public int indexOf(byte8 element, int startFromIndex) { return findForward(new Byte8(element), startFromIndex); }

    public int indexOf(short element, int startFromIndex) { return findForward(new Short(element), startFromIndex); }

    public int indexOf(short2 element, int startFromIndex) { return findForward(new Short2(element), startFromIndex); }

    public int indexOf(short4 element, int startFromIndex) { return findForward(new Short4(element), startFromIndex); }

    public int indexOf(short8 element, int startFromIndex) { return findForward(new Short8(element), startFromIndex); }

    public int indexOf(int element, int startFromIndex) { return findForward(new Int(element), startFromIndex); }

    public int indexOf(int2 element, int startFromIndex) { return findForward(new Int2(element), startFromIndex); }

    public int indexOf(int4 element, int startFromIndex) { return findForward(new Int4(element), startFromIndex); }

    public int indexOf(int8 element, int startFromIndex) { return findForward(new Int8(element), startFromIndex); }

    public int indexOf(long element, int startFromIndex) { return findForward(new Long(element), startFromIndex); }

    public int indexOf(long2 element, int startFromIndex) { return findForward(new Long2(element), startFromIndex); }

    public int indexOf(long4 element, int startFromIndex) { return findForward(new Long4(element), startFromIndex); }

    public int indexOf(long8 element, int startFromIndex) { return findForward(new Long8(element), startFromIndex); }

    public int indexOf(Object element, int startFromIndex) { return findForward(element, startFromIndex); }

    public int lastIndexOf(boolean element) { return findBackward(element ? Boolean.TRUE : Boolean.FALSE, Int.MAX_VALUE); }

    public int lastIndexOf(char element) { return findBackward(new Char(element), Int.MAX_VALUE); }

    public int lastIndexOf(byte element) { return findBackward(new Byte(element), Int.MAX_VALUE); }

    public int lastIndexOf(byte2 element) { return findBackward(new Byte2(element), Int.MAX_VALUE); }

    public int lastIndexOf(byte4 element) { return findBackward(new Byte4(element), Int.MAX_VALUE); }

    public int lastIndexOf(byte8 element) { return findBackward(new Byte8(element), Int.MAX_VALUE); }

    public int lastIndexOf(short element) { return findBackward(new Short(element), Int.MAX_VALUE); }

    public int lastIndexOf(short2 element) { return findBackward(new Short2(element), Int.MAX_VALUE); }

    public int lastIndexOf(short4 element) { return findBackward(new Short4(element), Int.MAX_VALUE); }

    public int lastIndexOf(short8 element) { return findBackward(new Short8(element), Int.MAX_VALUE); }

    public int lastIndexOf(int element) { return findBackward(new Int(element), Int.MAX_VALUE); }

    public int lastIndexOf(int2 element) { return findBackward(new Int2(element), Int.MAX_VALUE); }

    public int lastIndexOf(int4 element) { return findBackward(new Int4(element), Int.MAX_VALUE); }

    public int lastIndexOf(int8 element) { return findBackward(new Int8(element), Int.MAX_VALUE); }

    public int lastIndexOf(long element) { return findBackward(new Long(element), Int.MAX_VALUE); }

    public int lastIndexOf(long2 element) { return findBackward(new Long2(element), Int.MAX_VALUE); }

    public int lastIndexOf(long4 element) { return findBackward(new Long4(element), Int.MAX_VALUE); }

    public int lastIndexOf(long8 element) { return findBackward(new Long8(element), Int.MAX_VALUE); }

    public int lastIndexOf(Object element) { return findBackward(element, Int.MAX_VALUE); }

    public int lastIndexOf(boolean element, int startFromIndex) { return findBackward(element ? Boolean.TRUE : Boolean.FALSE, startFromIndex); }

    public int lastIndexOf(char element, int startFromIndex) { return findBackward(new Char(element), startFromIndex); }

    public int lastIndexOf(byte element, int startFromIndex) { return findBackward(new Byte(element), startFromIndex); }

    public int lastIndexOf(byte2 element, int startFromIndex) { return findBackward(new Byte2(element), startFromIndex); }

    public int lastIndexOf(byte4 element, int startFromIndex) { return findBackward(new Byte4(element), startFromIndex); }

    public int lastIndexOf(byte8 element, int startFromIndex) { return findBackward(new Byte8(element), startFromIndex); }

    public int lastIndexOf(short element, int startFromIndex) { return findBackward(new Short(element), startFromIndex); }

    public int lastIndexOf(short2 element, int startFromIndex) { return findBackward(new Short2(element), startFromIndex); }

    public int lastIndexOf(short4 element, int startFromIndex) { return findBackward(new Short4(element), startFromIndex); }

    public int lastIndexOf(short8 element, int startFromIndex) { return findBackward(new Short8(element), startFromIndex); }

    public int lastIndexOf(int element, int startFromIndex) { return findBackward(new Int(element), startFromIndex); }

    public int lastIndexOf(int2 element, int startFromIndex) { return findBackward(new Int2(element), startFromIndex); }

    public int lastIndexOf(int4 element, int startFromIndex) { return findBackward(new Int4(element), startFromIndex); }

    public int lastIndexOf(int8 element, int startFromIndex) { return findBackward(new Int8(element), startFromIndex); }

    public int lastIndexOf(long element, int startFromIndex) { return findBackward(new Long(element), startFromIndex); }

    public int lastIndexOf(long2 element, int startFromIndex) { return findBackward(new Long2(element), startFromIndex); }

    public int lastIndexOf(long4 element, int startFromIndex) { return findBackward(new Long4(element), startFromIndex); }

    public int lastIndexOf(long8 element, int startFromIndex) { return findBackward(new Long8(element), startFromIndex); }

    public int lastIndexOf(Object element, int startFromIndex) { return findBackward(element, startFromIndex); }

    public Object[] toObjectArray() {
        int length = fldLength;
        Object[] result = new Object[length];
        Array.copy(fldElements, 0, result, 0, length);
        return result;
    }

    public Object firstElement() {
        if(fldLength < 1)
        {
            throw new EmptyVectorException("вектор пуст");
        }
        return fldElements[0];
    }

    public Object lastElement() {
        int length = fldLength;
        if(length-- < 1)
        {
            throw new EmptyVectorException("вектор пуст");
        }
        return fldElements[length];
    }

    public Vector trimToLength() {
        trim();
        return this;
    }

    public Vector insert(int index, boolean src) {
        insertElement(index, src ? Boolean.TRUE : Boolean.FALSE);
        return this;
    }

    public Vector insert(int index, char src) {
        insertElement(index, new Char(src));
        return this;
    }

    public Vector insert(int index, byte src) {
        insertElement(index, new Byte(src));
        return this;
    }

    public Vector insert(int index, byte2 src) {
        insertElement(index, new Byte2(src));
        return this;
    }

    public Vector insert(int index, byte4 src) {
        insertElement(index, new Byte4(src));
        return this;
    }

    public Vector insert(int index, byte8 src) {
        insertElement(index, new Byte8(src));
        return this;
    }

    public Vector insert(int index, short src) {
        insertElement(index, new Short(src));
        return this;
    }

    public Vector insert(int index, short2 src) {
        insertElement(index, new Short2(src));
        return this;
    }

    public Vector insert(int index, short4 src) {
        insertElement(index, new Short4(src));
        return this;
    }

    public Vector insert(int index, short8 src) {
        insertElement(index, new Short8(src));
        return this;
    }

    public Vector insert(int index, int src) {
        insertElement(index, new Int(src));
        return this;
    }

    public Vector insert(int index, int2 src) {
        insertElement(index, new Int2(src));
        return this;
    }

    public Vector insert(int index, int4 src) {
        insertElement(index, new Int4(src));
        return this;
    }

    public Vector insert(int index, int8 src) {
        insertElement(index, new Int8(src));
        return this;
    }

    public Vector insert(int index, long src) {
        insertElement(index, new Long(src));
        return this;
    }

    public Vector insert(int index, long2 src) {
        insertElement(index, new Long2(src));
        return this;
    }

    public Vector insert(int index, long4 src) {
        insertElement(index, new Long4(src));
        return this;
    }

    public Vector insert(int index, long8 src) {
        insertElement(index, new Long8(src));
        return this;
    }

    public Vector insert(int index, float src) {
        insertElement(index, new Float(src));
        return this;
    }

    public Vector insert(int index, float2 src) {
        insertElement(index, new Float2(src));
        return this;
    }

    public Vector insert(int index, float4 src) {
        insertElement(index, new Float4(src));
        return this;
    }

    public Vector insert(int index, float8 src) {
        insertElement(index, new Float8(src));
        return this;
    }

    public Vector insert(int index, double src) {
        insertElement(index, new Double(src));
        return this;
    }

    public Vector insert(int index, double2 src) {
        insertElement(index, new Double2(src));
        return this;
    }

    public Vector insert(int index, double4 src) {
        insertElement(index, new Double4(src));
        return this;
    }

    public Vector insert(int index, double8 src) {
        insertElement(index, new Double8(src));
        return this;
    }

    public Vector insert(int index, real src) {
        insertElement(index, new Real(src));
        return this;
    }

    public Vector insert(int index, Object src) {
        insertElement(index, src);
        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 insertf(int index, String form, ObjectArray data) {
        insertElement(index, String.format(form, data));
        return this;
    }

    public Vector delete(int beginIndex, int endIndex) {
        deletePortion(beginIndex, endIndex);
        return this;
    }

    public Vector delete(int index) {
        deletePortion(index, index + 1);
        return this;
    }

    public Vector append(boolean src) {
        appendElement(src ? Boolean.TRUE : Boolean.FALSE);
        return this;
    }

    public Vector append(char src) {
        appendElement(new Char(src));
        return this;
    }

    public Vector append(byte src) {
        appendElement(new Byte(src));
        return this;
    }

    public Vector append(byte2 src) {
        appendElement(new Byte2(src));
        return this;
    }

    public Vector append(byte4 src) {
        appendElement(new Byte4(src));
        return this;
    }

    public Vector append(byte8 src) {
        appendElement(new Byte8(src));
        return this;
    }

    public Vector append(short src) {
        appendElement(new Short(src));
        return this;
    }

    public Vector append(short2 src) {
        appendElement(new Short2(src));
        return this;
    }

    public Vector append(short4 src) {
        appendElement(new Short4(src));
        return this;
    }

    public Vector append(short8 src) {
        appendElement(new Short8(src));
        return this;
    }

    public Vector append(int src) {
        appendElement(new Int(src));
        return this;
    }

    public Vector append(int2 src) {
        appendElement(new Int2(src));
        return this;
    }

    public Vector append(int4 src) {
        appendElement(new Int4(src));
        return this;
    }

    public Vector append(int8 src) {
        appendElement(new Int8(src));
        return this;
    }

    public Vector append(long src) {
        appendElement(new Long(src));
        return this;
    }

    public Vector append(long2 src) {
        appendElement(new Long2(src));
        return this;
    }

    public Vector append(long4 src) {
        appendElement(new Long4(src));
        return this;
    }

    public Vector append(long8 src) {
        appendElement(new Long8(src));
        return this;
    }

    public Vector append(float src) {
        appendElement(new Float(src));
        return this;
    }

    public Vector append(float2 src) {
        appendElement(new Float2(src));
        return this;
    }

    public Vector append(float4 src) {
        appendElement(new Float4(src));
        return this;
    }

    public Vector append(float8 src) {
        appendElement(new Float8(src));
        return this;
    }

    public Vector append(double src) {
        appendElement(new Double(src));
        return this;
    }

    public Vector append(double2 src) {
        appendElement(new Double2(src));
        return this;
    }

    public Vector append(double4 src) {
        appendElement(new Double4(src));
        return this;
    }

    public Vector append(double8 src) {
        appendElement(new Double8(src));
        return this;
    }

    public Vector append(real src) {
        appendElement(new Real(src));
        return this;
    }

    public Vector append(Object src) {
        appendElement(src);
        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 appendf(String form, ObjectArray data) {
        appendElement(String.format(form, data));
        return this;
    }

    public Enumeration enumerateForward() { return new VectorEnumeration(this, false); }

    public Enumeration enumerateReverse() { return new VectorEnumeration(this, true); }

    public int length { read = fldLength, write = setLength }

    public final int capacity { read = getCapacity }

    public void operator []=(int index, Object element) {
        if(index < 0 || index >= fldLength)
        {
            throw new IndexOutOfBoundsException("индекс элемента вектора выходит из диапазона");
        }
        fldElements[index] = element;
    }

    public Object operator [](int index) {
        if(index < 0 || index >= fldLength)
        {
            throw new IndexOutOfBoundsException("индекс элемента вектора выходит из диапазона");
        }
        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 trim() {
        int length = fldLength;
        Object[] elements = fldElements;
        if(length < elements.length)
        {
            Array.copy(elements, 0, fldElements = new Object[length], 0, length);
        }
    }

    protected void setLength(int newLength) {
        if(newLength < 0)
        {
            throw new NegativeArrayLengthException("длина не может быть отрицательной");
        }
        int length = fldLength;
        Object[] elements = fldElements;
        if(newLength > elements.length) elements = madeLarger(newLength);
        if(newLength > length) Array.fill(elements, length, newLength - length, null);
        fldLength = newLength;
    }

    protected void insertArray(int index, ObjectArray src, int offset, int length) {
        if(length > 0)
        {
            int currentLength = fldLength;
            int newLength = currentLength + length;
            Object[] elements = madeLarger(newLength);
            if(index < 0) index = 0;
            if(index > currentLength) index = currentLength;
            Array.copy(elements, index, elements, index + length, currentLength - index);
            if(src instanceof Object[])
            {
                Array.copy((Object[]) src, offset, elements, index, length);
            } else
            {
                while(length-- > 0) elements[index++] = src[offset++];
            }
            fldLength = newLength;
        }
    }

    protected void insertElement(int index, Object src) {
        int currentLength = fldLength;
        int newLength = currentLength + 1;
        Object[] elements = madeLarger(newLength);
        if(index < 0) index = 0;
        if(index > currentLength) index = currentLength;
        Array.copy(elements, index, elements, index + 1, currentLength - index);
        elements[index] = src;
        fldLength = newLength;
    }

    protected void appendArray(ObjectArray src, int offset, int length) {
        if(length > 0)
        {
            int currentLength = fldLength;
            int newLength = currentLength + length;
            Object[] elements = madeLarger(newLength);
            if(src instanceof Object[])
            {
                Array.copy((Object[]) src, offset, elements, currentLength, length);
            } else
            {
                while(length-- > 0) elements[currentLength++] = src[offset++];
            }
            fldLength = newLength;
        }
    }

    protected void appendElement(Object src) {
        int currentLength = fldLength;
        int newLength = currentLength + 1;
        Object[] elements = madeLarger(newLength);
        elements[currentLength] = src;
        fldLength = newLength;
    }

    protected void deletePortion(int beginIndex, int endIndex) {
        int length = fldLength;
        if((beginIndex | endIndex) < 0 || beginIndex > length || endIndex > length || beginIndex > endIndex)
        {
            throw new IndexOutOfBoundsException("индекс элемента вектора выходит из диапазона");
        }
        Object[] elements = fldElements;
        int quantity = endIndex - beginIndex;
        Array.copy(elements, endIndex, elements, beginIndex, length - endIndex);
        Array.fill(elements, length -= quantity, quantity, null);
        fldLength = length;
    }

    protected int deleteElement(Object element) {
        int length = fldLength;
        if(length > 0)
        {
            int index = -1;
            Object[] elements = fldElements;
            if(element == null)
            {
                index = Array.indexOf(null, elements, 0, length);
            } else
            {
                for(int i = 0; i < length; i++) if(element.equals(elements[i]))
                {
                    index = i;
                    break;
                }
            }
            if(index >= 0)
            {
                Array.copy(elements, index + 1, elements, index, --length - index);
                elements[fldLength = length] = null;
            }
            return index;
        }
        return -1;
    }

    protected int findForward(Object element, int startFromIndex) {
        int length = fldLength;
        if(startFromIndex < 0) startFromIndex = 0;
        if(startFromIndex < length)
        {
            Object[] elements = fldElements;
            if(element == null)
            {
                return Array.indexOf(null, elements, 0, length - startFromIndex);
            } else
            {
                for(int index = startFromIndex; index < length; index++) if(element.equals(elements[index])) return index;
            }
        }
        return -1;
    }

    protected int findBackward(Object element, int startFromIndex) {
        int limit = fldLength - 1;
        if(startFromIndex > limit) startFromIndex = limit;
        if(startFromIndex > -1)
        {
            Object[] elements = fldElements;
            if(element == null)
            {
                return Array.lastIndexOf(null, elements, startFromIndex, startFromIndex + 1);
            } else
            {
                for(int index = startFromIndex; index > -1; index--) if(element.equals(elements[index])) return index;
            }
        }
        return -1;
    }

    protected Object elementAt(int index) { return index < 0 || index >= fldLength ? null : fldElements[index]; }

    protected final Object[] madeLarger(int minimumCapacity) {
        if(minimumCapacity < 0)
        {
            throw new BufferTooLargeError("объём буфера очень велик");
        }
        Object[] elements = fldElements;
        int currentCapacity = elements.length;
        if(currentCapacity < minimumCapacity)
        {
            int newCapacity = currentCapacity >= (Int.MAX_VALUE >> 1) ? Int.MAX_VALUE : (currentCapacity << 1) + 1;
            if(newCapacity < minimumCapacity) newCapacity = minimumCapacity;
            Array.copy(elements, 0, fldElements = elements = new Object[newCapacity], 0, currentCapacity);
        }
        return elements;
    }

    private int getCapacity() { return fldElements.length; }
}

class VectorEnumeration(Enumeration)
{
    private int fldIndex;
    private final boolean fldReverse;
    private final Vector fldVector;

    public (Vector vector, boolean reverse) {
        fldIndex = reverse ? vector.length - 1 : 0;
        fldReverse = reverse;
        fldVector = vector;
    }

    public boolean hasMoreElements() { return fldReverse ? fldIndex >= 0 : fldIndex < fldVector.length; }

    public Object nextElement() {
        int index = fldIndex;
        Vector vector = fldVector;
        if(index < 0 || index >= vector.length) return super.nextElement();
        Object result = vector.elementAt(index);
        fldIndex = fldReverse ? index - 1 : index + 1;
        return result;
    }
}