/*
Исходный код среды исполнения ПВТ-ОО.
Этот исходный код является частью проекта ПВТ-ОО.
Copyright © 2021 Малик Разработчик
Это свободная программа: вы можете перераспространять её и/или
изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
в каком она была опубликована Фондом свободного программного обеспечения;
либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
Эта программа распространяется в надежде, что она может быть полезна,
но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
общественной лицензии GNU.
Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
вместе с этой программой. Если это не так, см.
<http://www.gnu.org/licenses/>.
*/
package avt.lang;
import avt.lang.array.*;
public final class Array(Object)
{
public static void fill(boolean[] dst, int offset, int length, boolean value) { if(length > 0) fillByByte(dst, offset, length, value ? 1 : 0, 1); }
public static void fill(char[] dst, int offset, int length, char value) { if(length > 0) fillByShort(dst, offset, length, (short) value, 1); }
public static void fill(byte[] dst, int offset, int length, byte value) { if(length > 0) fillByByte(dst, offset, length, value, 1); }
public static void fill(byte2[] dst, int offset, int length, byte2 value) { if(length > 0) fillByByte(dst, offset, length, value, 2); }
public static void fill(byte4[] dst, int offset, int length, byte4 value) { if(length > 0) fillByByte(dst, offset, length, value, 4); }
public static void fill(byte8[] dst, int offset, int length, byte8 value) { if(length > 0) fillByByte(dst, offset, length, value, 8); }
public static void fill(short[] dst, int offset, int length, short value) { if(length > 0) fillByShort(dst, offset, length, value, 1); }
public static void fill(short2[] dst, int offset, int length, short2 value) { if(length > 0) fillByShort(dst, offset, length, value, 2); }
public static void fill(short4[] dst, int offset, int length, short4 value) { if(length > 0) fillByShort(dst, offset, length, value, 4); }
public static void fill(short8[] dst, int offset, int length, short8 value) { if(length > 0) fillByShort(dst, offset, length, value, 8); }
public static void fill(int[] dst, int offset, int length, int value) { if(length > 0) fillByInt(dst, offset, length, value, 1); }
public static void fill(int2[] dst, int offset, int length, int2 value) { if(length > 0) fillByInt(dst, offset, length, value, 2); }
public static void fill(int4[] dst, int offset, int length, int4 value) { if(length > 0) fillByInt(dst, offset, length, value, 4); }
public static void fill(int8[] dst, int offset, int length, int8 value) { if(length > 0) fillByInt(dst, offset, length, value, 8); }
public static void fill(long[] dst, int offset, int length, long value) { if(length > 0) fillByLong(dst, offset, length, value, 1); }
public static void fill(long2[] dst, int offset, int length, long2 value) { if(length > 0) fillByLong(dst, offset, length, value, 2); }
public static void fill(long4[] dst, int offset, int length, long4 value) { if(length > 0) fillByLong(dst, offset, length, value, 4); }
public static void fill(long8[] dst, int offset, int length, long8 value) { if(length > 0) fillByLong(dst, offset, length, value, 8); }
public static void fill(float[] dst, int offset, int length, float value) { if(length > 0) fillByFloat(dst, offset, length, value, 1); }
public static void fill(float2[] dst, int offset, int length, float2 value) { if(length > 0) fillByFloat(dst, offset, length, value, 2); }
public static void fill(float4[] dst, int offset, int length, float4 value) { if(length > 0) fillByFloat(dst, offset, length, value, 4); }
public static void fill(float8[] dst, int offset, int length, float8 value) { if(length > 0) fillByFloat(dst, offset, length, value, 8); }
public static void fill(double[] dst, int offset, int length, double value) { if(length > 0) fillByDouble(dst, offset, length, value, 1); }
public static void fill(double2[] dst, int offset, int length, double2 value) { if(length > 0) fillByDouble(dst, offset, length, value, 2); }
public static void fill(double4[] dst, int offset, int length, double4 value) { if(length > 0) fillByDouble(dst, offset, length, value, 4); }
public static void fill(double8[] dst, int offset, int length, double8 value) { if(length > 0) fillByDouble(dst, offset, length, value, 8); }
public static void fill(real[] dst, int offset, int length, real value) { if(length > 0) fillByReal(dst, offset, length, value); }
public static void fill(Object[] dst, int offset, int length, Object value) { if(length > 0) fillByRef(dst, offset, length, value); }
public static void copy(boolean[] src, int srcOffset, boolean[] dst, int dstOffset, int length) { if(length > 0) copyBy01(src, srcOffset, dst, dstOffset, length); }
public static void copy(char[] src, int srcOffset, char[] dst, int dstOffset, int length) { if(length > 0) copyBy02(src, srcOffset, dst, dstOffset, length); }
public static void copy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int length) { if(length > 0) copyBy01(src, srcOffset, dst, dstOffset, length); }
public static void copy(byte2[] src, int srcOffset, byte2[] dst, int dstOffset, int length) { if(length > 0) copyBy02(src, srcOffset, dst, dstOffset, length); }
public static void copy(byte4[] src, int srcOffset, byte4[] dst, int dstOffset, int length) { if(length > 0) copyBy04(src, srcOffset, dst, dstOffset, length); }
public static void copy(byte8[] src, int srcOffset, byte8[] dst, int dstOffset, int length) { if(length > 0) copyBy08(src, srcOffset, dst, dstOffset, length); }
public static void copy(short[] src, int srcOffset, short[] dst, int dstOffset, int length) { if(length > 0) copyBy02(src, srcOffset, dst, dstOffset, length); }
public static void copy(short2[] src, int srcOffset, short2[] dst, int dstOffset, int length) { if(length > 0) copyBy04(src, srcOffset, dst, dstOffset, length); }
public static void copy(short4[] src, int srcOffset, short4[] dst, int dstOffset, int length) { if(length > 0) copyBy08(src, srcOffset, dst, dstOffset, length); }
public static void copy(short8[] src, int srcOffset, short8[] dst, int dstOffset, int length) { if(length > 0) copyBy16(src, srcOffset, dst, dstOffset, length); }
public static void copy(int[] src, int srcOffset, int[] dst, int dstOffset, int length) { if(length > 0) copyBy04(src, srcOffset, dst, dstOffset, length); }
public static void copy(int2[] src, int srcOffset, int2[] dst, int dstOffset, int length) { if(length > 0) copyBy08(src, srcOffset, dst, dstOffset, length); }
public static void copy(int4[] src, int srcOffset, int4[] dst, int dstOffset, int length) { if(length > 0) copyBy16(src, srcOffset, dst, dstOffset, length); }
public static void copy(int8[] src, int srcOffset, int8[] dst, int dstOffset, int length) { if(length > 0) copyBy32(src, srcOffset, dst, dstOffset, length); }
public static void copy(long[] src, int srcOffset, long[] dst, int dstOffset, int length) { if(length > 0) copyBy08(src, srcOffset, dst, dstOffset, length); }
public static void copy(long2[] src, int srcOffset, long2[] dst, int dstOffset, int length) { if(length > 0) copyBy16(src, srcOffset, dst, dstOffset, length); }
public static void copy(long4[] src, int srcOffset, long4[] dst, int dstOffset, int length) { if(length > 0) copyBy32(src, srcOffset, dst, dstOffset, length); }
public static void copy(long8[] src, int srcOffset, long8[] dst, int dstOffset, int length) { if(length > 0) copyBy64(src, srcOffset, dst, dstOffset, length); }
public static void copy(float[] src, int srcOffset, float[] dst, int dstOffset, int length) { if(length > 0) copyBy04(src, srcOffset, dst, dstOffset, length); }
public static void copy(float2[] src, int srcOffset, float2[] dst, int dstOffset, int length) { if(length > 0) copyBy08(src, srcOffset, dst, dstOffset, length); }
public static void copy(float4[] src, int srcOffset, float4[] dst, int dstOffset, int length) { if(length > 0) copyBy16(src, srcOffset, dst, dstOffset, length); }
public static void copy(float8[] src, int srcOffset, float8[] dst, int dstOffset, int length) { if(length > 0) copyBy32(src, srcOffset, dst, dstOffset, length); }
public static void copy(double[] src, int srcOffset, double[] dst, int dstOffset, int length) { if(length > 0) copyBy08(src, srcOffset, dst, dstOffset, length); }
public static void copy(double2[] src, int srcOffset, double2[] dst, int dstOffset, int length) { if(length > 0) copyBy16(src, srcOffset, dst, dstOffset, length); }
public static void copy(double4[] src, int srcOffset, double4[] dst, int dstOffset, int length) { if(length > 0) copyBy32(src, srcOffset, dst, dstOffset, length); }
public static void copy(double8[] src, int srcOffset, double8[] dst, int dstOffset, int length) { if(length > 0) copyBy64(src, srcOffset, dst, dstOffset, length); }
public static void copy(real[] src, int srcOffset, real[] dst, int dstOffset, int length) { if(length > 0) copyBy10(src, srcOffset, dst, dstOffset, length); }
public static void copy(Object[] src, int srcOffset, Object[] dst, int dstOffset, int length) { if(length > 0) copyByRefFast(src, srcOffset, dst, dstOffset, length); }
public static void copyRefs(Object[] src, int srcOffset, Object[] dst, int dstOffset, int length) { if(length > 0) copyByRefSlow(src, srcOffset, dst, dstOffset, length); }
public static void copyRaw(RawData src, long srcOffset, RawData dst, long dstOffset, long length) {
if(length <= 0)
{
return;
}
if(src == null)
{
throw new NullPointerException("аргумент src равен нулевой ссылке");
}
if(dst == null)
{
throw new NullPointerException("аргумент dst равен нулевой ссылке");
}
if(!(src instanceof avt.io.ByteArrayStream) && !(src instanceof Struct) && !src.getClass().isArray())
{
throw new IllegalArgumentException("аргумент src имеет сторонний тип");
}
if(!(dst instanceof avt.io.ByteArrayStream) && !(dst instanceof Struct) && !dst.getClass().isArray())
{
throw new IllegalArgumentException("аргумент dst имеет сторонний тип");
}
checkRawBounds(src, srcOffset, length);
checkRawBounds(dst, dstOffset, length);
long srcPointer = src.getPointer() + srcOffset;
long dstPointer = dst.getPointer() + dstOffset;
if(srcPointer < dstPointer)
{
long endOffset = length - 1L;
copyBackwardByByte(srcPointer + endOffset, dstPointer + endOffset, length);
return;
}
copyForwardByByte(srcPointer, dstPointer, length);
}
public static void copyToRaw(char[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 1, dst, dstOffset, (long) length << 1); }
public static void copyToRaw(byte[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset, dst, dstOffset, (long) length); }
public static void copyToRaw(byte2[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 1, dst, dstOffset, (long) length << 1); }
public static void copyToRaw(byte4[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 2, dst, dstOffset, (long) length << 2); }
public static void copyToRaw(byte8[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 3, dst, dstOffset, (long) length << 3); }
public static void copyToRaw(short[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 1, dst, dstOffset, (long) length << 1); }
public static void copyToRaw(short2[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 2, dst, dstOffset, (long) length << 2); }
public static void copyToRaw(short4[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 3, dst, dstOffset, (long) length << 3); }
public static void copyToRaw(short8[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 4, dst, dstOffset, (long) length << 4); }
public static void copyToRaw(int[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 2, dst, dstOffset, (long) length << 2); }
public static void copyToRaw(int2[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 3, dst, dstOffset, (long) length << 3); }
public static void copyToRaw(int4[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 4, dst, dstOffset, (long) length << 4); }
public static void copyToRaw(int8[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 5, dst, dstOffset, (long) length << 5); }
public static void copyToRaw(long[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 3, dst, dstOffset, (long) length << 3); }
public static void copyToRaw(long2[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 4, dst, dstOffset, (long) length << 4); }
public static void copyToRaw(long4[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 5, dst, dstOffset, (long) length << 5); }
public static void copyToRaw(long8[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 6, dst, dstOffset, (long) length << 6); }
public static void copyToRaw(float[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 2, dst, dstOffset, (long) length << 2); }
public static void copyToRaw(float2[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 3, dst, dstOffset, (long) length << 3); }
public static void copyToRaw(float4[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 4, dst, dstOffset, (long) length << 4); }
public static void copyToRaw(float8[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 5, dst, dstOffset, (long) length << 5); }
public static void copyToRaw(double[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 3, dst, dstOffset, (long) length << 3); }
public static void copyToRaw(double2[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 4, dst, dstOffset, (long) length << 4); }
public static void copyToRaw(double4[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 5, dst, dstOffset, (long) length << 5); }
public static void copyToRaw(double8[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset << 6, dst, dstOffset, (long) length << 6); }
public static void copyToRaw(real[] src, int srcOffset, RawData dst, long dstOffset, int length) { if(length > 0) copyRaw(src, (long) srcOffset * 10L, dst, dstOffset, (long) length * 10L); }
public static void copyFromRaw(RawData src, long srcOffset, char[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 1, (long) length << 1); }
public static void copyFromRaw(RawData src, long srcOffset, byte[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset, (long) length); }
public static void copyFromRaw(RawData src, long srcOffset, byte2[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 1, (long) length << 1); }
public static void copyFromRaw(RawData src, long srcOffset, byte4[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 2, (long) length << 2); }
public static void copyFromRaw(RawData src, long srcOffset, byte8[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 3, (long) length << 3); }
public static void copyFromRaw(RawData src, long srcOffset, short[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 1, (long) length << 1); }
public static void copyFromRaw(RawData src, long srcOffset, short2[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 2, (long) length << 2); }
public static void copyFromRaw(RawData src, long srcOffset, short4[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 3, (long) length << 3); }
public static void copyFromRaw(RawData src, long srcOffset, short8[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 4, (long) length << 4); }
public static void copyFromRaw(RawData src, long srcOffset, int[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 2, (long) length << 2); }
public static void copyFromRaw(RawData src, long srcOffset, int2[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 3, (long) length << 3); }
public static void copyFromRaw(RawData src, long srcOffset, int4[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 4, (long) length << 4); }
public static void copyFromRaw(RawData src, long srcOffset, int8[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 5, (long) length << 5); }
public static void copyFromRaw(RawData src, long srcOffset, long[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 3, (long) length << 3); }
public static void copyFromRaw(RawData src, long srcOffset, long2[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 4, (long) length << 4); }
public static void copyFromRaw(RawData src, long srcOffset, long4[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 5, (long) length << 5); }
public static void copyFromRaw(RawData src, long srcOffset, long8[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 6, (long) length << 6); }
public static void copyFromRaw(RawData src, long srcOffset, float[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 2, (long) length << 2); }
public static void copyFromRaw(RawData src, long srcOffset, float2[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 3, (long) length << 3); }
public static void copyFromRaw(RawData src, long srcOffset, float4[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 4, (long) length << 4); }
public static void copyFromRaw(RawData src, long srcOffset, float8[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 5, (long) length << 5); }
public static void copyFromRaw(RawData src, long srcOffset, double[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 3, (long) length << 3); }
public static void copyFromRaw(RawData src, long srcOffset, double2[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 4, (long) length << 4); }
public static void copyFromRaw(RawData src, long srcOffset, double4[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 5, (long) length << 5); }
public static void copyFromRaw(RawData src, long srcOffset, double8[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset << 6, (long) length << 6); }
public static void copyFromRaw(RawData src, long srcOffset, real[] dst, int dstOffset, int length) { if(length > 0) copyRaw(src, srcOffset, dst, (long) dstOffset * 10L, (long) length * 10L); }
public static void checkRawBounds(RawData data, long offset, long length) {
long len = data.getLength();
long lim = offset + length;
if(lim > len || lim < offset || offset > len || offset < 0L)
{
throw new RawDataOffsetOutOfBoundsException("смещение в произвольных данных выходит из диапазона");
}
}
public static void checkBounds(Measureable array, int offset, int length) {
int len = array.length;
int lim = offset + length;
if(lim > len || lim < offset || offset > len || offset < 0)
{
throw new ArrayIndexOutOfBoundsException("индекс элемента массива выходит из диапазона");
}
}
public static native int indexOf(boolean value, boolean[] array, int startFromIndex, int maximumScanLength);
public static native int indexOf(int value, char[] array, int startFromIndex, int maximumScanLength);
public static native int indexOf(int value, byte[] array, int startFromIndex, int maximumScanLength);
public static native int indexOf(int value, short[] array, int startFromIndex, int maximumScanLength);
public static native int indexOf(int value, int[] array, int startFromIndex, int maximumScanLength);
public static native int indexOf(long value, long[] array, int startFromIndex, int maximumScanLength);
public static native int indexOf(Object value, Object[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(boolean value, boolean[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(int value, char[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(int value, byte[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(int value, short[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(int value, int[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(long value, long[] array, int startFromIndex, int maximumScanLength);
public static native int lastIndexOf(Object value, Object[] array, int startFromIndex, int maximumScanLength);
public static int2 intersectBounds(Measureable array, int offset, int length) {
if(array == null)
{
throw new NullPointerException("аргумент array равен нулевой ссылке");
}
int len = array.length;
int lim = offset + length;
int beginIndex = offset < 0 ? 0 : offset;
int endIndex = lim > len ? len : lim;
return new int2 { beginIndex, endIndex - beginIndex };
}
private static void fillCheckArguments(Measureable dst, int offset, int length) {
if(dst == null)
{
throw new NullPointerException("аргумент dst равен нулевой ссылке");
}
checkBounds(dst, offset, length);
}
private static void fillByByte(Measureable dst, int offset, int length, byte8 value, int capacity) {
fillCheckArguments(dst, offset, length);
fillByByte(getArrayPointer(dst) + ((long) offset * (long) capacity), length, value, capacity);
}
private static void fillByShort(Measureable dst, int offset, int length, short8 value, int capacity) {
fillCheckArguments(dst, offset, length);
fillByShort(getArrayPointer(dst) + ((long) offset * (long) capacity << 1), length, value, capacity);
}
private static void fillByInt(Measureable dst, int offset, int length, int8 value, int capacity) {
fillCheckArguments(dst, offset, length);
fillByInt(getArrayPointer(dst) + ((long) offset * (long) capacity << 2), length, value, capacity);
}
private static void fillByLong(Measureable dst, int offset, int length, long8 value, int capacity) {
fillCheckArguments(dst, offset, length);
fillByLong(getArrayPointer(dst) + ((long) offset * (long) capacity << 3), length, value, capacity);
}
private static void fillByFloat(Measureable dst, int offset, int length, float8 value, int capacity) {
fillCheckArguments(dst, offset, length);
fillByFloat(getArrayPointer(dst) + ((long) offset * (long) capacity << 2), length, value, capacity);
}
private static void fillByDouble(Measureable dst, int offset, int length, double8 value, int capacity) {
fillCheckArguments(dst, offset, length);
fillByDouble(getArrayPointer(dst) + ((long) offset * (long) capacity << 3), length, value, capacity);
}
private static void fillByReal(Measureable dst, int offset, int length, real value) {
fillCheckArguments(dst, offset, length);
fillByReal(getArrayPointer(dst) + ((long) offset * 10L), length, value);
}
private static void fillByRef(Object[] dst, int offset, int length, Object value) {
fillCheckArguments(dst, offset, length);
((Object) dst).checkObjectArrayAssignable(value);
fillByRef(getArrayPointer(dst) + ((long) offset << 3), length, value);
}
private static native void fillByByte(long dst, int cnt, byte8 val, int cap);
private static native void fillByShort(long dst, int cnt, short8 val, int cap);
private static native void fillByInt(long dst, int cnt, int8 val, int cap);
private static native void fillByLong(long dst, int cnt, long8 val, int cap);
private static native void fillByFloat(long dst, int cnt, float8 val, int cap);
private static native void fillByDouble(long dst, int cnt, double8 val, int cap);
private static native void fillByReal(long dst, int cnt, real val);
private static native void fillByRef(long dst, int cnt, Object val);
private static void copyCheckArguments(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
if(src == null)
{
throw new NullPointerException("аргумент src равен нулевой ссылке");
}
if(dst == null)
{
throw new NullPointerException("аргумент dst равен нулевой ссылке");
}
checkBounds(src, srcOffset, length);
checkBounds(dst, dstOffset, length);
}
private static void copyBy01(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length) - 1L;
copyBackwardByByte(srcPointer + endOffset, dstPointer + endOffset, (long) length);
return;
}
copyForwardByByte(srcPointer, dstPointer, (long) length);
}
private static void copyBy02(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 1);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 1);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 1) - 2L;
copyBackwardByShort(srcPointer + endOffset, dstPointer + endOffset, (long) length);
return;
}
copyForwardByShort(srcPointer, dstPointer, (long) length);
}
private static void copyBy04(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 2);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 2);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 2) - 4L;
copyBackwardByInt(srcPointer + endOffset, dstPointer + endOffset, (long) length);
return;
}
copyForwardByInt(srcPointer, dstPointer, (long) length);
}
private static void copyBy08(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 3);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 3);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 3) - 8L;
copyBackwardByLong(srcPointer + endOffset, dstPointer + endOffset, (long) length);
return;
}
copyForwardByLong(srcPointer, dstPointer, (long) length);
}
private static void copyBy10(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset * 10L);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset * 10L);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length * 10L) - 2L;
copyBackwardByShort(srcPointer + endOffset, dstPointer + endOffset, (long) length * 5L);
return;
}
copyForwardByShort(srcPointer, dstPointer, (long) length * 5L);
}
private static void copyBy16(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 4);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 4);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 4) - 8L;
copyBackwardByLong(srcPointer + endOffset, dstPointer + endOffset, (long) length << 1);
return;
}
copyForwardByLong(srcPointer, dstPointer, (long) length << 1);
}
private static void copyBy32(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 5);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 5);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 5) - 8L;
copyBackwardByLong(srcPointer + endOffset, dstPointer + endOffset, (long) length << 2);
return;
}
copyForwardByLong(srcPointer, dstPointer, (long) length << 2);
}
private static void copyBy64(Measureable src, int srcOffset, Measureable dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 6);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 6);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 6) - 8L;
copyBackwardByLong(srcPointer + endOffset, dstPointer + endOffset, (long) length << 3);
return;
}
copyForwardByLong(srcPointer, dstPointer, (long) length << 3);
}
private static void copyByRefFast(Object[] src, int srcOffset, Object[] dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
Class srcType = src.getClass().componentType;
Class dstType = dst.getClass().componentType;
if(!dstType.isAssignableFrom(srcType))
{
throw new ArrayStoreException("сохранение в массиве данных иного типа невозможно") { saving = srcType, required = dstType };
}
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 3);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 3);
if(srcPointer < dstPointer)
{
long endOffset = (long) (length << 3) - 8L;
copyBackwardByRef(srcPointer + endOffset, dstPointer + endOffset, (long) length);
return;
}
copyForwardByRef(srcPointer, dstPointer, (long) length);
}
private static void copyByRefSlow(Object[] src, int srcOffset, Object[] dst, int dstOffset, int length) {
copyCheckArguments(src, srcOffset, dst, dstOffset, length);
long srcPointer = getArrayPointer(src) + ((long) srcOffset << 3);
long dstPointer = getArrayPointer(dst) + ((long) dstOffset << 3);
if(srcPointer >= dstPointer)
{
for(; length-- > 0; dst[dstOffset++] = src[srcOffset++]);
return;
}
for(srcOffset += length, dstOffset += length; length-- > 0; dst[--dstOffset] = src[--srcOffset]);
}
private static native void copyForwardByByte(long src, long dst, long cnt);
private static native void copyForwardByShort(long src, long dst, long cnt);
private static native void copyForwardByInt(long src, long dst, long cnt);
private static native void copyForwardByLong(long src, long dst, long cnt);
private static native void copyForwardByRef(long src, long dst, long cnt);
private static native void copyBackwardByByte(long src, long dst, long cnt);
private static native void copyBackwardByShort(long src, long dst, long cnt);
private static native void copyBackwardByInt(long src, long dst, long cnt);
private static native void copyBackwardByLong(long src, long dst, long cnt);
private static native void copyBackwardByRef(long src, long dst, long cnt);
private static native long getArrayPointer(Measureable array);
private () { }
}
