001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    /**
018     * @author Brian Wing Shun Chan
019     */
020    public class ArrayUtil_IW {
021            public static ArrayUtil_IW getInstance() {
022                    return _instance;
023            }
024    
025            public boolean[] append(boolean[]... arrays) {
026                    return ArrayUtil.append(arrays);
027            }
028    
029            public boolean[] append(boolean[] array, boolean value) {
030                    return ArrayUtil.append(array, value);
031            }
032    
033            public byte[] append(byte[]... arrays) {
034                    return ArrayUtil.append(arrays);
035            }
036    
037            public byte[] append(byte[] array, byte value) {
038                    return ArrayUtil.append(array, value);
039            }
040    
041            public char[] append(char[]... arrays) {
042                    return ArrayUtil.append(arrays);
043            }
044    
045            public char[] append(char[] array, char value) {
046                    return ArrayUtil.append(array, value);
047            }
048    
049            public double[] append(double[]... arrays) {
050                    return ArrayUtil.append(arrays);
051            }
052    
053            public double[] append(double[] array, double value) {
054                    return ArrayUtil.append(array, value);
055            }
056    
057            public float[] append(float[]... arrays) {
058                    return ArrayUtil.append(arrays);
059            }
060    
061            public float[] append(float[] array, float value) {
062                    return ArrayUtil.append(array, value);
063            }
064    
065            public int[] append(int[]... arrays) {
066                    return ArrayUtil.append(arrays);
067            }
068    
069            public int[] append(int[] array, int value) {
070                    return ArrayUtil.append(array, value);
071            }
072    
073            public long[] append(long[]... arrays) {
074                    return ArrayUtil.append(arrays);
075            }
076    
077            public long[] append(long[] array, long value) {
078                    return ArrayUtil.append(array, value);
079            }
080    
081            public short[] append(short[]... arrays) {
082                    return ArrayUtil.append(arrays);
083            }
084    
085            public short[] append(short[] array, short value) {
086                    return ArrayUtil.append(array, value);
087            }
088    
089            public <T> T[] append(T[]... arrays) {
090                    return ArrayUtil.append(arrays);
091            }
092    
093            public <T> T[] append(T[] array, T value) {
094                    return ArrayUtil.append(array, value);
095            }
096    
097            public <T> T[] append(T[] array1, T[] array2) {
098                    return ArrayUtil.append(array1, array2);
099            }
100    
101            public <T> T[][] append(T[][] array1, T[] value) {
102                    return ArrayUtil.append(array1, value);
103            }
104    
105            public <T> T[][] append(T[][] array1, T[][] array2) {
106                    return ArrayUtil.append(array1, array2);
107            }
108    
109            public boolean[] clone(boolean[] array) {
110                    return ArrayUtil.clone(array);
111            }
112    
113            public boolean[] clone(boolean[] array, int from, int to) {
114                    return ArrayUtil.clone(array, from, to);
115            }
116    
117            public byte[] clone(byte[] array) {
118                    return ArrayUtil.clone(array);
119            }
120    
121            public byte[] clone(byte[] array, int from, int to) {
122                    return ArrayUtil.clone(array, from, to);
123            }
124    
125            public char[] clone(char[] array) {
126                    return ArrayUtil.clone(array);
127            }
128    
129            public char[] clone(char[] array, int from, int to) {
130                    return ArrayUtil.clone(array, from, to);
131            }
132    
133            public double[] clone(double[] array) {
134                    return ArrayUtil.clone(array);
135            }
136    
137            public double[] clone(double[] array, int from, int to) {
138                    return ArrayUtil.clone(array, from, to);
139            }
140    
141            public float[] clone(float[] array) {
142                    return ArrayUtil.clone(array);
143            }
144    
145            public float[] clone(float[] array, int from, int to) {
146                    return ArrayUtil.clone(array, from, to);
147            }
148    
149            public int[] clone(int[] array) {
150                    return ArrayUtil.clone(array);
151            }
152    
153            public int[] clone(int[] array, int from, int to) {
154                    return ArrayUtil.clone(array, from, to);
155            }
156    
157            public long[] clone(long[] array) {
158                    return ArrayUtil.clone(array);
159            }
160    
161            public long[] clone(long[] array, int from, int to) {
162                    return ArrayUtil.clone(array, from, to);
163            }
164    
165            public short[] clone(short[] array) {
166                    return ArrayUtil.clone(array);
167            }
168    
169            public short[] clone(short[] array, int from, int to) {
170                    return ArrayUtil.clone(array, from, to);
171            }
172    
173            public <T> T[] clone(T[] array) {
174                    return ArrayUtil.clone(array);
175            }
176    
177            public <T> T[] clone(T[] array, int from, int to) {
178                    return ArrayUtil.clone(array, from, to);
179            }
180    
181            public <T> T[][] clone(T[][] array) {
182                    return ArrayUtil.clone(array);
183            }
184    
185            public <T> T[][] clone(T[][] array, int from, int to) {
186                    return ArrayUtil.clone(array, from, to);
187            }
188    
189            public void combine(java.lang.Object[] array1, java.lang.Object[] array2,
190                    java.lang.Object[] combinedArray) {
191                    ArrayUtil.combine(array1, array2, combinedArray);
192            }
193    
194            public boolean contains(boolean[] array, boolean value) {
195                    return ArrayUtil.contains(array, value);
196            }
197    
198            public boolean contains(byte[] array, byte value) {
199                    return ArrayUtil.contains(array, value);
200            }
201    
202            public boolean contains(char[] array, char value) {
203                    return ArrayUtil.contains(array, value);
204            }
205    
206            public boolean contains(double[] array, double value) {
207                    return ArrayUtil.contains(array, value);
208            }
209    
210            public boolean contains(float[] array, float value) {
211                    return ArrayUtil.contains(array, value);
212            }
213    
214            public boolean contains(int[] array, int value) {
215                    return ArrayUtil.contains(array, value);
216            }
217    
218            public boolean contains(long[] array, long value) {
219                    return ArrayUtil.contains(array, value);
220            }
221    
222            public boolean contains(java.lang.Object[] array, java.lang.Object value) {
223                    return ArrayUtil.contains(array, value);
224            }
225    
226            public boolean contains(short[] array, short value) {
227                    return ArrayUtil.contains(array, value);
228            }
229    
230            public java.lang.String[] distinct(java.lang.String[] array) {
231                    return ArrayUtil.distinct(array);
232            }
233    
234            public java.lang.String[] distinct(java.lang.String[] array,
235                    java.util.Comparator<java.lang.String> comparator) {
236                    return ArrayUtil.distinct(array, comparator);
237            }
238    
239            public int getLength(java.lang.Object[] array) {
240                    return ArrayUtil.getLength(array);
241            }
242    
243            public java.lang.Object getValue(java.lang.Object[] array, int pos) {
244                    return ArrayUtil.getValue(array, pos);
245            }
246    
247            public boolean[] remove(boolean[] array, boolean value) {
248                    return ArrayUtil.remove(array, value);
249            }
250    
251            public byte[] remove(byte[] array, byte value) {
252                    return ArrayUtil.remove(array, value);
253            }
254    
255            public char[] remove(char[] array, char value) {
256                    return ArrayUtil.remove(array, value);
257            }
258    
259            public double[] remove(double[] array, double value) {
260                    return ArrayUtil.remove(array, value);
261            }
262    
263            public int[] remove(int[] array, int value) {
264                    return ArrayUtil.remove(array, value);
265            }
266    
267            public long[] remove(long[] array, long value) {
268                    return ArrayUtil.remove(array, value);
269            }
270    
271            public short[] remove(short[] array, short value) {
272                    return ArrayUtil.remove(array, value);
273            }
274    
275            public java.lang.String[] remove(java.lang.String[] array,
276                    java.lang.String value) {
277                    return ArrayUtil.remove(array, value);
278            }
279    
280            public java.lang.String[] removeByPrefix(java.lang.String[] array,
281                    java.lang.String prefix) {
282                    return ArrayUtil.removeByPrefix(array, prefix);
283            }
284    
285            public void reverse(java.lang.String[] array) {
286                    ArrayUtil.reverse(array);
287            }
288    
289            public boolean[] subset(boolean[] array, int start, int end) {
290                    return ArrayUtil.subset(array, start, end);
291            }
292    
293            public byte[] subset(byte[] array, int start, int end) {
294                    return ArrayUtil.subset(array, start, end);
295            }
296    
297            public char[] subset(char[] array, int start, int end) {
298                    return ArrayUtil.subset(array, start, end);
299            }
300    
301            public double[] subset(double[] array, int start, int end) {
302                    return ArrayUtil.subset(array, start, end);
303            }
304    
305            public float[] subset(float[] array, int start, int end) {
306                    return ArrayUtil.subset(array, start, end);
307            }
308    
309            public int[] subset(int[] array, int start, int end) {
310                    return ArrayUtil.subset(array, start, end);
311            }
312    
313            public long[] subset(long[] array, int start, int end) {
314                    return ArrayUtil.subset(array, start, end);
315            }
316    
317            public short[] subset(short[] array, int start, int end) {
318                    return ArrayUtil.subset(array, start, end);
319            }
320    
321            public <T> T[] subset(T[] array, int start, int end) {
322                    return ArrayUtil.subset(array, start, end);
323            }
324    
325            public java.lang.Boolean[] toArray(boolean[] array) {
326                    return ArrayUtil.toArray(array);
327            }
328    
329            public boolean[] toArray(java.lang.Boolean[] array) {
330                    return ArrayUtil.toArray(array);
331            }
332    
333            public java.lang.Byte[] toArray(byte[] array) {
334                    return ArrayUtil.toArray(array);
335            }
336    
337            public byte[] toArray(java.lang.Byte[] array) {
338                    return ArrayUtil.toArray(array);
339            }
340    
341            public java.lang.Character[] toArray(char[] array) {
342                    return ArrayUtil.toArray(array);
343            }
344    
345            public char[] toArray(java.lang.Character[] array) {
346                    return ArrayUtil.toArray(array);
347            }
348    
349            public java.lang.Double[] toArray(double[] array) {
350                    return ArrayUtil.toArray(array);
351            }
352    
353            public double[] toArray(java.lang.Double[] array) {
354                    return ArrayUtil.toArray(array);
355            }
356    
357            public java.lang.Float[] toArray(float[] array) {
358                    return ArrayUtil.toArray(array);
359            }
360    
361            public float[] toArray(java.lang.Float[] array) {
362                    return ArrayUtil.toArray(array);
363            }
364    
365            public java.lang.Integer[] toArray(int[] array) {
366                    return ArrayUtil.toArray(array);
367            }
368    
369            public int[] toArray(java.lang.Integer[] array) {
370                    return ArrayUtil.toArray(array);
371            }
372    
373            public java.lang.Long[] toArray(long[] array) {
374                    return ArrayUtil.toArray(array);
375            }
376    
377            public long[] toArray(java.lang.Long[] array) {
378                    return ArrayUtil.toArray(array);
379            }
380    
381            public java.lang.Short[] toArray(short[] array) {
382                    return ArrayUtil.toArray(array);
383            }
384    
385            public short[] toArray(java.lang.Short[] array) {
386                    return ArrayUtil.toArray(array);
387            }
388    
389            public double[] toDoubleArray(
390                    java.util.Collection<java.lang.Double> collection) {
391                    return ArrayUtil.toDoubleArray(collection);
392            }
393    
394            public float[] toFloatArray(
395                    java.util.Collection<java.lang.Float> collection) {
396                    return ArrayUtil.toFloatArray(collection);
397            }
398    
399            public int[] toIntArray(java.util.Collection<java.lang.Integer> collection) {
400                    return ArrayUtil.toIntArray(collection);
401            }
402    
403            public long[] toLongArray(java.util.Collection<java.lang.Long> collection) {
404                    return ArrayUtil.toLongArray(collection);
405            }
406    
407            public java.lang.Long[] toLongArray(java.lang.Object[] array) {
408                    return ArrayUtil.toLongArray(array);
409            }
410    
411            public short[] toShortArray(
412                    java.util.Collection<java.lang.Short> collection) {
413                    return ArrayUtil.toShortArray(collection);
414            }
415    
416            public java.lang.String toString(java.lang.Object[] array,
417                    java.lang.String param) {
418                    return ArrayUtil.toString(array, param);
419            }
420    
421            public java.lang.String toString(java.lang.Object[] array,
422                    java.lang.String param, java.lang.String delimiter) {
423                    return ArrayUtil.toString(array, param, delimiter);
424            }
425    
426            public <T, V> java.lang.String toString(T[] list,
427                    com.liferay.portal.kernel.util.Accessor<T, V> accessor) {
428                    return ArrayUtil.toString(list, accessor);
429            }
430    
431            public <T, V> java.lang.String toString(T[] list,
432                    com.liferay.portal.kernel.util.Accessor<T, V> accessor,
433                    java.lang.String delimiter) {
434                    return ArrayUtil.toString(list, accessor, delimiter);
435            }
436    
437            public java.lang.String[] toStringArray(boolean[] array) {
438                    return ArrayUtil.toStringArray(array);
439            }
440    
441            public java.lang.String[] toStringArray(byte[] array) {
442                    return ArrayUtil.toStringArray(array);
443            }
444    
445            public java.lang.String[] toStringArray(char[] array) {
446                    return ArrayUtil.toStringArray(array);
447            }
448    
449            public java.lang.String[] toStringArray(java.util.Date[] array,
450                    java.text.DateFormat dateFormat) {
451                    return ArrayUtil.toStringArray(array, dateFormat);
452            }
453    
454            public java.lang.String[] toStringArray(double[] array) {
455                    return ArrayUtil.toStringArray(array);
456            }
457    
458            public java.lang.String[] toStringArray(float[] array) {
459                    return ArrayUtil.toStringArray(array);
460            }
461    
462            public java.lang.String[] toStringArray(int[] array) {
463                    return ArrayUtil.toStringArray(array);
464            }
465    
466            public java.lang.String[] toStringArray(
467                    com.liferay.portal.kernel.json.JSONArray array) {
468                    return ArrayUtil.toStringArray(array);
469            }
470    
471            public java.lang.String[] toStringArray(long[] array) {
472                    return ArrayUtil.toStringArray(array);
473            }
474    
475            public java.lang.String[] toStringArray(java.lang.Object[] array) {
476                    return ArrayUtil.toStringArray(array);
477            }
478    
479            public java.lang.String[] toStringArray(short[] array) {
480                    return ArrayUtil.toStringArray(array);
481            }
482    
483            public byte[] unique(byte[] array) {
484                    return ArrayUtil.unique(array);
485            }
486    
487            public double[] unique(double[] array) {
488                    return ArrayUtil.unique(array);
489            }
490    
491            public float[] unique(float[] array) {
492                    return ArrayUtil.unique(array);
493            }
494    
495            public int[] unique(int[] array) {
496                    return ArrayUtil.unique(array);
497            }
498    
499            public long[] unique(long[] array) {
500                    return ArrayUtil.unique(array);
501            }
502    
503            public short[] unique(short[] array) {
504                    return ArrayUtil.unique(array);
505            }
506    
507            private ArrayUtil_IW() {
508            }
509    
510            private static ArrayUtil_IW _instance = new ArrayUtil_IW();
511    }