opensource
/
fine-third
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Merge pull request #407 in CORE/base-third from ~MAKSIM/base-third:release/10.0 to release/10.0 

* commit '59a724aefb1cd5b50bd7d3735a74a53f5d0a255d':
  暂时兼容旧版本新引擎插件
release/10.0
neil 5 years ago
parent
f32949cfc9 59a724aefb
commit
413b677a44
3 changed files with 800 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      build.third_step1-jdk11.gradle
  2. 1
      build.third_step1.gradle
  3. 798
      fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java

1
build.third_step1-jdk11.gradle
Unescape View File

@ -31,6 +31,7 @@ sourceSets{
main{
java{
srcDirs=[
"${srcDir}/fine-deprecated-utils/src",
"${srcDir}/fine-asm/src",
"${srcDir}/fine-antlr4/src",
"${srcDir}/fine-aspectj/src",

1
build.third_step1.gradle
Unescape View File

@ -32,6 +32,7 @@ sourceSets{
main{
java{
srcDirs=[
"${srcDir}/fine-deprecated-utils/src",
"${srcDir}/fine-asm/src",
"${srcDir}/fine-antlr4/src",
"${srcDir}/fine-aspectj/src",

798
fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java
Unescape View File

@ -0,0 +1,798 @@
package edu.emory.mathcs.backport.java.util;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/**
* 该类由前面版本third包反编译生成，用于兼容新引擎旧版本插件，7-8月份删除
*/
@Deprecated
public class Arrays {
private Arrays() {
}
public static void sort(long[] a) {
java.util.Arrays.sort(a);
}
public static void sort(long[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(int[] a) {
java.util.Arrays.sort(a);
}
public static void sort(int[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(short[] a) {
java.util.Arrays.sort(a);
}
public static void sort(short[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(char[] a) {
java.util.Arrays.sort(a);
}
public static void sort(char[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(byte[] a) {
java.util.Arrays.sort(a);
}
public static void sort(byte[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(double[] a) {
java.util.Arrays.sort(a);
}
public static void sort(double[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(float[] a) {
java.util.Arrays.sort(a);
}
public static void sort(float[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(Object[] a) {
java.util.Arrays.sort(a);
}
public static void sort(Object[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(Object[] a, Comparator c) {
java.util.Arrays.sort(a, c);
}
public static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) {
java.util.Arrays.sort(a, fromIndex, toIndex, c);
}
public static int binarySearch(long[] a, long key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(int[] a, int key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(short[] a, short key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(char[] a, char key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(byte[] a, byte key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(double[] a, double key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(float[] a, float key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(Object[] a, Object key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(Object[] a, Object key, Comparator c) {
return java.util.Arrays.binarySearch(a, key, c);
}
public static boolean equals(long[] a, long[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(int[] a, int[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(short[] a, short[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(char[] a, char[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(byte[] a, byte[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(boolean[] a, boolean[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(double[] a, double[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(float[] a, float[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(Object[] a, Object[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static void fill(long[] a, long val) {
java.util.Arrays.fill(a, val);
}
public static void fill(long[] a, int fromIndex, int toIndex, long val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(int[] a, int val) {
java.util.Arrays.fill(a, val);
}
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(short[] a, short val) {
java.util.Arrays.fill(a, val);
}
public static void fill(short[] a, int fromIndex, int toIndex, short val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(char[] a, char val) {
java.util.Arrays.fill(a, val);
}
public static void fill(char[] a, int fromIndex, int toIndex, char val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(byte[] a, byte val) {
java.util.Arrays.fill(a, val);
}
public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(boolean[] a, boolean val) {
java.util.Arrays.fill(a, val);
}
public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(double[] a, double val) {
java.util.Arrays.fill(a, val);
}
public static void fill(double[] a, int fromIndex, int toIndex, double val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(float[] a, float val) {
java.util.Arrays.fill(a, val);
}
public static void fill(float[] a, int fromIndex, int toIndex, float val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(Object[] a, Object val) {
java.util.Arrays.fill(a, val);
}
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static Object[] copyOf(Object[] original, int newLength) {
return copyOf(original, newLength, original.getClass());
}
public static Object[] copyOf(Object[] original, int newLength, Class newType) {
Object[] arr = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength);
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static byte[] copyOf(byte[] original, int newLength) {
byte[] arr = new byte[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static short[] copyOf(short[] original, int newLength) {
short[] arr = new short[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static int[] copyOf(int[] original, int newLength) {
int[] arr = new int[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static long[] copyOf(long[] original, int newLength) {
long[] arr = new long[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static char[] copyOf(char[] original, int newLength) {
char[] arr = new char[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static float[] copyOf(float[] original, int newLength) {
float[] arr = new float[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static double[] copyOf(double[] original, int newLength) {
double[] arr = new double[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static boolean[] copyOf(boolean[] original, int newLength) {
boolean[] arr = new boolean[newLength];
int len = original.length < newLength ? original.length : newLength;
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
public static Object[] copyOfRange(Object[] original, int from, int to) {
return copyOfRange(original, from, to, original.getClass());
}
public static Object[] copyOfRange(Object[] original, int from, int to, Class newType) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
Object[] arr = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength);
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
byte[] arr = new byte[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static short[] copyOfRange(short[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
short[] arr = new short[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static int[] copyOfRange(int[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
int[] arr = new int[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static long[] copyOfRange(long[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
long[] arr = new long[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
char[] arr = new char[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static float[] copyOfRange(float[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
float[] arr = new float[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static double[] copyOfRange(double[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
double[] arr = new double[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static boolean[] copyOfRange(boolean[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
} else {
boolean[] arr = new boolean[newLength];
int ceil = original.length - from;
int len = ceil < newLength ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
}
public static List asList(Object[] a) {
return java.util.Arrays.asList(a);
}
public static int hashCode(long[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
long e = a[i];
hash = 31 * hash + (int)(e ^ e >>> 32);
}
return hash;
}
}
public static int hashCode(int[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
hash = 31 * hash + a[i];
}
return hash;
}
}
public static int hashCode(short[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
hash = 31 * hash + a[i];
}
return hash;
}
}
public static int hashCode(char[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
hash = 31 * hash + a[i];
}
return hash;
}
}
public static int hashCode(byte[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
hash = 31 * hash + a[i];
}
return hash;
}
}
public static int hashCode(boolean[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
hash = 31 * hash + (a[i] ? 1231 : 1237);
}
return hash;
}
}
public static int hashCode(float[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
hash = 31 * hash + Float.floatToIntBits(a[i]);
}
return hash;
}
}
public static int hashCode(double[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
long e = Double.doubleToLongBits(a[i]);
hash = 31 * hash + (int)(e ^ e >>> 32);
}
return hash;
}
}
public static int hashCode(Object[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
Object e = a[i];
hash = 31 * hash + (e == null ? 0 : e.hashCode());
}
return hash;
}
}
public static int deepHashCode(Object[] a) {
if (a == null) {
return 0;
} else {
int hash = 1;
for(int i = 0; i < a.length; ++i) {
Object e = a[i];
hash = 31 * hash + (e instanceof Object[] ? deepHashCode((Object[])e) : (e instanceof byte[] ? hashCode((byte[])e) : (e instanceof short[] ? hashCode((short[])e) : (e instanceof int[] ? hashCode((int[])e) : (e instanceof long[] ? hashCode((long[])e) : (e instanceof char[] ? hashCode((char[])e) : (e instanceof boolean[] ? hashCode((boolean[])e) : (e instanceof float[] ? hashCode((float[])e) : (e instanceof double[] ? hashCode((double[])e) : (e != null ? e.hashCode() : 0))))))))));
}
return hash;
}
}
public static boolean deepEquals(Object[] a1, Object[] a2) {
if (a1 == a2) {
return true;
} else if (a1 != null && a2 != null) {
int len = a1.length;
if (len != a2.length) {
return false;
} else {
for(int i = 0; i < len; ++i) {
Object e1 = a1[i];
Object e2 = a2[i];
if (e1 != e2) {
if (e1 == null) {
return false;
}
boolean eq = e1.getClass() == e2.getClass() && !e1.getClass().isArray() ? (e1 instanceof Object[] && e2 instanceof Object[] ? deepEquals((Object[])e1, (Object[])e2) : (e1 instanceof byte[] && e2 instanceof byte[] ? equals((byte[])e1, (byte[])e2) : (e1 instanceof short[] && e2 instanceof short[] ? equals((short[])e1, (short[])e2) : (e1 instanceof int[] && e2 instanceof int[] ? equals((int[])e1, (int[])e2) : (e1 instanceof long[] && e2 instanceof long[] ? equals((long[])e1, (long[])e2) : (e1 instanceof char[] && e2 instanceof char[] ? equals((char[])e1, (char[])e2) : (e1 instanceof boolean[] && e2 instanceof boolean[] ? equals((boolean[])e1, (boolean[])e2) : (e1 instanceof float[] && e2 instanceof float[] ? equals((float[])e1, (float[])e2) : (e1 instanceof double[] && e2 instanceof double[] ? equals((double[])e1, (double[])e2) : e1.equals(e2)))))))))) : e1.equals(e2);
if (!eq) {
return false;
}
}
}
return true;
}
} else {
return false;
}
}
public static String toString(long[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(int[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(short[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(char[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(byte[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(boolean[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(float[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(double[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String toString(Object[] a) {
if (a == null) {
return "null";
} else if (a.length == 0) {
return "[]";
} else {
StringBuffer buf = new StringBuffer();
buf.append('[').append(a[0]);
for(int i = 1; i < a.length; ++i) {
buf.append(", ").append(a[i]);
}
buf.append(']');
return buf.toString();
}
}
public static String deepToString(Object[] a) {
if (a == null) {
return "null";
} else {
StringBuffer buf = new StringBuffer();
deepToString(a, buf, new ArrayList());
return buf.toString();
}
}
private static void deepToString(Object[] a, StringBuffer buf, List seen) {
seen.add(a);
buf.append('[');
for(int i = 0; i < a.length; ++i) {
if (i > 0) {
buf.append(", ");
}
Object e = a[i];
if (e == null) {
buf.append("null");
} else if (!e.getClass().isArray()) {
buf.append(e.toString());
} else if (e instanceof Object[]) {
if (seen.contains(e)) {
buf.append("[...]");
} else {
deepToString((Object[])e, buf, seen);
}
} else {
buf.append(e instanceof byte[] ? toString((byte[])e) : (e instanceof short[] ? toString((short[])e) : (e instanceof int[] ? toString((int[])e) : (e instanceof long[] ? toString((long[])e) : (e instanceof char[] ? toString((char[])e) : (e instanceof boolean[] ? toString((boolean[])e) : (e instanceof float[] ? toString((float[])e) : (e instanceof double[] ? toString((double[])e) : ""))))))));
}
}
buf.append(']');
seen.remove(seen.size() - 1);
}
}
Write Preview
Loading…
Cancel
Save