3 * $Date: 2005-11-10 09:52:44 -0600 (Thu, 10 Nov 2005) $
\r
6 * Copyright (C) 2003-2005 The Jmol Development Team
\r
8 * Contact: jmol-developers@lists.sf.net
\r
10 * This library is free software; you can redistribute it and/or
\r
11 * modify it under the terms of the GNU Lesser General Public
\r
12 * License as published by the Free Software Foundation; either
\r
13 * version 2.1 of the License, or (at your option) any later version.
\r
15 * This library is distributed in the hope that it will be useful,
\r
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
\r
18 * Lesser General Public License for more details.
\r
20 * You should have received a copy of the GNU Lesser General Public
\r
21 * License along with this library; if not, write to the Free Software
\r
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
\r
24 package javajs.util;
\r
26 // 4/23/15 BH getComponentType fix
\r
28 import java.lang.reflect.Array;
\r
30 import java.util.Arrays;
\r
31 import java.util.Hashtable;
\r
32 import java.util.Map;
\r
35 final public class AU {
\r
38 * Very important that this not be used with Int32Array or Float32Array,
\r
39 * because it is not initialized to all zeros in MSIE 9.
\r
42 * @param minimumLength
\r
45 public static Object ensureLength(Object array, int minimumLength) {
\r
46 if (array != null && getLength(array) >= minimumLength)
\r
48 return arrayCopyObject(array, minimumLength);
\r
51 public static String[] ensureLengthS(String[] array, int minimumLength) {
\r
52 if (array != null && array.length >= minimumLength)
\r
54 return arrayCopyS(array, minimumLength);
\r
57 public static float[] ensureLengthA(float[] array, int minimumLength) {
\r
58 if (array != null && array.length >= minimumLength)
\r
60 return arrayCopyF(array, minimumLength);
\r
63 public static int[] ensureLengthI(int[] array, int minimumLength) {
\r
64 if (array != null && array.length >= minimumLength)
\r
66 return arrayCopyI(array, minimumLength);
\r
69 public static short[] ensureLengthShort(short[] array, int minimumLength) {
\r
70 if (array != null && array.length >= minimumLength)
\r
72 return arrayCopyShort(array, minimumLength);
\r
75 public static byte[] ensureLengthByte(byte[] array, int minimumLength) {
\r
76 if (array != null && array.length >= minimumLength)
\r
78 return arrayCopyByte(array, minimumLength);
\r
82 * Very important that this not be used with Int32Array or Float32Array,
\r
83 * because it is not initialized to all zeros in MSIE 9.
\r
88 public static Object doubleLength(Object array) {
\r
89 return arrayCopyObject(array, (array == null ? 16 : 2 * getLength(array)));
\r
92 public static String[] doubleLengthS(String[] array) {
\r
93 return arrayCopyS(array, (array == null ? 16 : 2 * array.length));
\r
96 public static float[] doubleLengthF(float[] array) {
\r
97 return arrayCopyF(array, (array == null ? 16 : 2 * array.length));
\r
100 public static int[] doubleLengthI(int[] array) {
\r
101 return arrayCopyI(array, (array == null ? 16 : 2 * array.length));
\r
104 public static short[] doubleLengthShort(short[] array) {
\r
105 return arrayCopyShort(array, (array == null ? 16 : 2 * array.length));
\r
108 public static byte[] doubleLengthByte(byte[] array) {
\r
109 return arrayCopyByte(array, (array == null ? 16 : 2 * array.length));
\r
112 public static boolean[] doubleLengthBool(boolean[] array) {
\r
113 return arrayCopyBool(array, (array == null ? 16 : 2 * array.length));
\r
116 public static Object deleteElements(Object array, int firstElement,
\r
118 if (nElements == 0 || array == null)
\r
120 int oldLength = getLength(array);
\r
121 if (firstElement >= oldLength)
\r
123 int n = oldLength - (firstElement + nElements);
\r
126 Object t = newInstanceO(array, firstElement + n);
\r
127 if (firstElement > 0)
\r
128 System.arraycopy(array, 0, t, 0, firstElement);
\r
130 System.arraycopy(array, firstElement + nElements, t, firstElement, n);
\r
135 * note -- cannot copy if array is null!
\r
141 public static Object arrayCopyObject(Object array, int newLength) {
\r
142 //System.out.println("ArrayUtil.copy " + newLength + " " + array + " ");
\r
143 if (array == null) {
\r
144 return null; // We can't allocate since we don't know the type of array
\r
146 int oldLength = getLength(array);
\r
147 if (newLength == oldLength)
\r
149 Object t = newInstanceO(array, newLength);
\r
150 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
157 * Very important that this not be used with Int32Array or Float32Array,
\r
158 * because those need to be initialized to all zeros in MSIE 9, and
\r
159 * MSIE 9 cannot distinguish Int32Array or Float32Array from Array.
\r
165 private static Object newInstanceO(Object array, int n) {
\r
169 * if (!array.getClass().getComponentType)
\r
170 * return new Array(n);
\r
174 return Array.newInstance(array.getClass().getComponentType(), n);
\r
178 public static int getLength(Object array) {
\r
182 * return array.length
\r
186 return Array.getLength(array);
\r
190 public static String[] arrayCopyS(String[] array, int newLength) {
\r
192 newLength = array.length;
\r
193 String[] t = new String[newLength];
\r
194 if (array != null) {
\r
195 int oldLength = array.length;
\r
196 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
202 public static int[][] arrayCopyII(int[][] array, int newLength) {
\r
203 int[][] t = newInt2(newLength);
\r
204 if (array != null) {
\r
205 int oldLength = array.length;
\r
206 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
212 public static T3[] arrayCopyPt(T3[] array, int newLength) {
\r
214 newLength = array.length;
\r
215 T3[] t = new T3[newLength];
\r
216 if (array != null) {
\r
217 int oldLength = array.length;
\r
218 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
224 public static float[] arrayCopyF(float[] array, int newLength) {
\r
226 newLength = array.length;
\r
227 float[] t = new float[newLength];
\r
228 if (array != null) {
\r
229 int oldLength = array.length;
\r
230 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
236 public static int[] arrayCopyI(int[] array, int newLength) {
\r
238 newLength = array.length;
\r
239 int[] t = new int[newLength];
\r
240 if (array != null) {
\r
241 int oldLength = array.length;
\r
242 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
249 * a specialized method that allows copying from a starting point either
\r
250 * to the end or to the middle (color schemes, especially)
\r
254 * @return array or null
\r
256 public static int[] arrayCopyRangeI(int[] array, int i0, int n) {
\r
259 int oldLength = array.length;
\r
260 if (n == -1) n = oldLength;
\r
261 if (n == -2) n = oldLength / 2;
\r
263 int[] t = new int[n];
\r
264 System.arraycopy(array, i0, t, 0, n);
\r
268 public static int[] arrayCopyRangeRevI(int[] array, int i0, int n) {
\r
271 int[] t = arrayCopyRangeI(array, i0, n);
\r
274 for (int i = n / 2; --i >= 0;)
\r
275 swapInt(t, i, n - 1 - i);
\r
279 public static short[] arrayCopyShort(short[] array, int newLength) {
\r
281 newLength = array.length;
\r
282 short[] t = new short[newLength];
\r
283 if (array != null) {
\r
284 int oldLength = array.length;
\r
285 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
291 public static byte[] arrayCopyByte(byte[] array, int newLength) {
\r
293 newLength = array.length;
\r
294 byte[] t = new byte[newLength];
\r
295 if (array != null) {
\r
296 int oldLength = array.length;
\r
297 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
303 public static boolean[] arrayCopyBool(boolean[] array, int newLength) {
\r
305 newLength = array.length;
\r
306 boolean[] t = new boolean[newLength];
\r
307 if (array != null) {
\r
308 int oldLength = array.length;
\r
309 System.arraycopy(array, 0, t, 0, oldLength < newLength ? oldLength
\r
315 public static void swapInt(int[] array, int indexA, int indexB) {
\r
316 int t = array[indexA];
\r
317 array[indexA] = array[indexB];
\r
322 public static void swap(short[] array, int indexA, int indexB) {
\r
323 short t = array[indexA];
\r
324 array[indexA] = array[indexB];
\r
328 public static void swap(float[] array, int indexA, int indexB) {
\r
329 float t = array[indexA];
\r
330 array[indexA] = array[indexB];
\r
335 public static String dumpArray(String msg, float[][] A, int x1, int x2, int y1, int y2) {
\r
336 String s = "dumpArray: " + msg + "\n";
\r
337 for (int x = x1; x <= x2; x++)
\r
338 s += "\t*" + x + "*";
\r
339 for (int y = y2; y >= y1; y--) {
\r
340 s += "\n*" + y + "*";
\r
341 for (int x = x1; x <= x2; x++)
\r
342 s += "\t" + (x < A.length && y < A[x].length ? A[x][y] : Float.NaN);
\r
347 public static String dumpIntArray(int[] A, int n) {
\r
349 for (int i = 0; i < n; i++)
\r
354 public static String sortedItem(Lst<String> v, int n) {
\r
359 String[] keys = v.toArray(new String[v.size()]);
\r
361 return keys[n % keys.length];
\r
365 * Helper method for creating a List<Tx>[] without warnings.
\r
367 * @param <type> Type of objects in the list.
\r
368 * @param size Array size.
\r
369 * @return Array of List<type>
\r
371 @SuppressWarnings("unchecked")
\r
372 public static <type> Lst<type>[] createArrayOfArrayList(int size) {
\r
373 return new Lst[size];
\r
377 * Helper method for creating a Map<K, V>[] without warnings.
\r
379 * @param <K> Type of object for the keys in the map.
\r
380 * @param <V> Type of object for the values in the map.
\r
381 * @param size Array size.
\r
382 * @return Array of Map<K, V>
\r
384 @SuppressWarnings("unchecked")
\r
385 public static <K, V> Map<K, V>[] createArrayOfHashtable(int size) {
\r
386 return new Hashtable[size];
\r
389 public static void swap(Object[] o, int i, int j) {
\r
395 public static float[][] newFloat2(int n) {
\r
399 * return Clazz.newArray(n, null);
\r
403 return new float[n][];
\r
407 public static int[][] newInt2(int n) {
\r
411 * return Clazz.newArray(n, null);
\r
415 return new int[n][];
\r
419 public static int[][][] newInt3(int nx, int ny) {
\r
423 * return Clazz.newArray(nx, null);
\r
427 return (ny < 0 ? new int[nx][][] : new int[nx][ny][]);
\r
431 public static float[][][] newFloat3(int nx, int ny) {
\r
435 * return Clazz.newArray(nx, null);
\r
439 return (ny < 0 ? new float[nx][][] : new float[nx][ny][]);
\r
443 public static int[][][][] newInt4(int n) {
\r
447 * return Clazz.newArray(n, null);
\r
451 return new int[n][][][];
\r
455 public static short[][] newShort2(int n) {
\r
459 * return Clazz.newArray(n, null);
\r
463 return new short[n][];
\r
467 public static byte[][] newByte2(int n) {
\r
471 * return Clazz.newArray(n, null);
\r
475 return new byte[n][];
\r
479 public static double[][] newDouble2(int n) {
\r
483 * return Clazz.newArray(n, null);
\r
487 return new double[n][];
\r
492 * remove all keys from a map that start with given root
\r
495 * @return number removed
\r
497 public static int removeMapKeys(Map<String, ?> map, String root) {
\r
498 Lst<String> list = new Lst<String>();
\r
499 for (String key: map.keySet())
\r
500 if (key.startsWith(root))
\r
502 for (int i = list.size(); --i >= 0;)
\r
503 map.remove(list.get(i));
\r
504 return list.size();
\r
507 public static boolean isAS(Object x) {
\r
510 * look also for array with first null element
\r
511 * so untypable -- just call it a String[]
\r
512 * (group3Lists, created in ModelLoader)
\r
515 * return Clazz.isAS(x);
\r
518 return x instanceof String[];
\r
522 public static boolean isASS(Object x) {
\r
525 * return Clazz.isASS(x);
\r
528 return x instanceof String[][];
\r
532 public static boolean isAP(Object x) {
\r
535 * return Clazz.isAP(x);
\r
538 return x instanceof T3[];
\r
542 public static boolean isAF(Object x) {
\r
545 * return Clazz.isAF(x);
\r
548 return x instanceof float[];
\r
552 public static boolean isAFloat(Object x) {
\r
555 * return Clazz.isAFloat(x);
\r
558 return x instanceof Float[];
\r
562 public static boolean isAD(Object x) {
\r
565 * return Clazz.isAF(x);
\r
568 return x instanceof double[];
\r
572 public static boolean isADD(Object x) {
\r
575 * return Clazz.isAFF(x);
\r
578 return x instanceof double[][];
\r
582 public static boolean isAB(Object x) {
\r
585 * return Clazz.isAI(x);
\r
588 return x instanceof byte[];
\r
592 public static boolean isAI(Object x) {
\r
595 * return Clazz.isAI(x);
\r
598 return x instanceof int[];
\r
602 public static boolean isAII(Object x) {
\r
605 * return Clazz.isAII(x);
\r
608 return (x instanceof int[][]);
\r
612 public static boolean isAFF(Object x) {
\r
615 * return Clazz.isAFF(x);
\r
618 return x instanceof float[][];
\r
622 public static boolean isAFFF(Object x) {
\r
625 * return Clazz.isAFFF(x);
\r
628 return x instanceof float[][][];
\r
633 * Ensure that we have signed and not unsigned bytes
\r
634 * coming out of any process, but particularly out of
\r
639 public static void ensureSignedBytes(byte[] b) {
\r
643 * for (var i = b.length; --i >= 0;) {
\r
644 * var j = b[i] & 0xFF;
\r
645 * if (j >= 0x80) j -= 0x100;
\r