001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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 boolean contains(java.lang.String[] array, java.lang.String value,
231                    boolean ignoreCase) {
232                    return ArrayUtil.contains(array, value, ignoreCase);
233            }
234    
235            public boolean containsAll(boolean[] array1, boolean[] array2) {
236                    return ArrayUtil.containsAll(array1, array2);
237            }
238    
239            public boolean containsAll(byte[] array1, byte[] array2) {
240                    return ArrayUtil.containsAll(array1, array2);
241            }
242    
243            public boolean containsAll(char[] array1, char[] array2) {
244                    return ArrayUtil.containsAll(array1, array2);
245            }
246    
247            public boolean containsAll(double[] array1, double[] array2) {
248                    return ArrayUtil.containsAll(array1, array2);
249            }
250    
251            public boolean containsAll(float[] array1, float[] array2) {
252                    return ArrayUtil.containsAll(array1, array2);
253            }
254    
255            public boolean containsAll(int[] array1, int[] array2) {
256                    return ArrayUtil.containsAll(array1, array2);
257            }
258    
259            public boolean containsAll(long[] array1, long[] array2) {
260                    return ArrayUtil.containsAll(array1, array2);
261            }
262    
263            public boolean containsAll(java.lang.Object[] array1,
264                    java.lang.Object[] array2) {
265                    return ArrayUtil.containsAll(array1, array2);
266            }
267    
268            public boolean containsAll(short[] array1, short[] array2) {
269                    return ArrayUtil.containsAll(array1, array2);
270            }
271    
272            public java.lang.String[] distinct(java.lang.String[] array) {
273                    return ArrayUtil.distinct(array);
274            }
275    
276            public java.lang.String[] distinct(java.lang.String[] array,
277                    java.util.Comparator<java.lang.String> comparator) {
278                    return ArrayUtil.distinct(array, comparator);
279            }
280    
281            public boolean[] filter(boolean[] array,
282                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Boolean> predicateFilter) {
283                    return ArrayUtil.filter(array, predicateFilter);
284            }
285    
286            public byte[] filter(byte[] array,
287                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Byte> predicateFilter) {
288                    return ArrayUtil.filter(array, predicateFilter);
289            }
290    
291            public char[] filter(char[] array,
292                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Character> predicateFilter) {
293                    return ArrayUtil.filter(array, predicateFilter);
294            }
295    
296            public double[] filter(double[] array,
297                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Double> predicateFilter) {
298                    return ArrayUtil.filter(array, predicateFilter);
299            }
300    
301            public float[] filter(float[] array,
302                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Float> predicateFilter) {
303                    return ArrayUtil.filter(array, predicateFilter);
304            }
305    
306            public int[] filter(int[] array,
307                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Integer> predicateFilter) {
308                    return ArrayUtil.filter(array, predicateFilter);
309            }
310    
311            public long[] filter(long[] array,
312                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Long> predicateFilter) {
313                    return ArrayUtil.filter(array, predicateFilter);
314            }
315    
316            public short[] filter(short[] array,
317                    com.liferay.portal.kernel.util.PredicateFilter<java.lang.Short> predicateFilter) {
318                    return ArrayUtil.filter(array, predicateFilter);
319            }
320    
321            public <T> T[] filter(T[] array,
322                    com.liferay.portal.kernel.util.PredicateFilter<T> filterPredicate) {
323                    return ArrayUtil.filter(array, filterPredicate);
324            }
325    
326            public int getLength(java.lang.Object[] array) {
327                    return ArrayUtil.getLength(array);
328            }
329    
330            public java.lang.Object getValue(java.lang.Object[] array, int pos) {
331                    return ArrayUtil.getValue(array, pos);
332            }
333    
334            public boolean isEmpty(boolean[] array) {
335                    return ArrayUtil.isEmpty(array);
336            }
337    
338            public boolean isEmpty(byte[] array) {
339                    return ArrayUtil.isEmpty(array);
340            }
341    
342            public boolean isEmpty(char[] array) {
343                    return ArrayUtil.isEmpty(array);
344            }
345    
346            public boolean isEmpty(double[] array) {
347                    return ArrayUtil.isEmpty(array);
348            }
349    
350            public boolean isEmpty(float[] array) {
351                    return ArrayUtil.isEmpty(array);
352            }
353    
354            public boolean isEmpty(int[] array) {
355                    return ArrayUtil.isEmpty(array);
356            }
357    
358            public boolean isEmpty(long[] array) {
359                    return ArrayUtil.isEmpty(array);
360            }
361    
362            public boolean isEmpty(java.lang.Object[] array) {
363                    return ArrayUtil.isEmpty(array);
364            }
365    
366            public boolean isEmpty(short[] array) {
367                    return ArrayUtil.isEmpty(array);
368            }
369    
370            public boolean isNotEmpty(boolean[] array) {
371                    return ArrayUtil.isNotEmpty(array);
372            }
373    
374            public boolean isNotEmpty(byte[] array) {
375                    return ArrayUtil.isNotEmpty(array);
376            }
377    
378            public boolean isNotEmpty(char[] array) {
379                    return ArrayUtil.isNotEmpty(array);
380            }
381    
382            public boolean isNotEmpty(double[] array) {
383                    return ArrayUtil.isNotEmpty(array);
384            }
385    
386            public boolean isNotEmpty(float[] array) {
387                    return ArrayUtil.isNotEmpty(array);
388            }
389    
390            public boolean isNotEmpty(int[] array) {
391                    return ArrayUtil.isNotEmpty(array);
392            }
393    
394            public boolean isNotEmpty(long[] array) {
395                    return ArrayUtil.isNotEmpty(array);
396            }
397    
398            public boolean isNotEmpty(java.lang.Object[] array) {
399                    return ArrayUtil.isNotEmpty(array);
400            }
401    
402            public boolean isNotEmpty(short[] array) {
403                    return ArrayUtil.isNotEmpty(array);
404            }
405    
406            public boolean[] remove(boolean[] array, boolean value) {
407                    return ArrayUtil.remove(array, value);
408            }
409    
410            public byte[] remove(byte[] array, byte value) {
411                    return ArrayUtil.remove(array, value);
412            }
413    
414            public char[] remove(char[] array, char value) {
415                    return ArrayUtil.remove(array, value);
416            }
417    
418            public double[] remove(double[] array, double value) {
419                    return ArrayUtil.remove(array, value);
420            }
421    
422            public float[] remove(float[] array, float value) {
423                    return ArrayUtil.remove(array, value);
424            }
425    
426            public int[] remove(int[] array, int value) {
427                    return ArrayUtil.remove(array, value);
428            }
429    
430            public long[] remove(long[] array, long value) {
431                    return ArrayUtil.remove(array, value);
432            }
433    
434            public short[] remove(short[] array, short value) {
435                    return ArrayUtil.remove(array, value);
436            }
437    
438            public java.lang.String[] remove(java.lang.String[] array,
439                    java.lang.String value) {
440                    return ArrayUtil.remove(array, value);
441            }
442    
443            public java.lang.String[] removeByPrefix(java.lang.String[] array,
444                    java.lang.String prefix) {
445                    return ArrayUtil.removeByPrefix(array, prefix);
446            }
447    
448            public void reverse(boolean[] array) {
449                    ArrayUtil.reverse(array);
450            }
451    
452            public void reverse(char[] array) {
453                    ArrayUtil.reverse(array);
454            }
455    
456            public void reverse(double[] array) {
457                    ArrayUtil.reverse(array);
458            }
459    
460            public void reverse(int[] array) {
461                    ArrayUtil.reverse(array);
462            }
463    
464            public void reverse(long[] array) {
465                    ArrayUtil.reverse(array);
466            }
467    
468            public void reverse(short[] array) {
469                    ArrayUtil.reverse(array);
470            }
471    
472            public void reverse(java.lang.String[] array) {
473                    ArrayUtil.reverse(array);
474            }
475    
476            public boolean[] subset(boolean[] array, int start, int end) {
477                    return ArrayUtil.subset(array, start, end);
478            }
479    
480            public byte[] subset(byte[] array, int start, int end) {
481                    return ArrayUtil.subset(array, start, end);
482            }
483    
484            public char[] subset(char[] array, int start, int end) {
485                    return ArrayUtil.subset(array, start, end);
486            }
487    
488            public double[] subset(double[] array, int start, int end) {
489                    return ArrayUtil.subset(array, start, end);
490            }
491    
492            public float[] subset(float[] array, int start, int end) {
493                    return ArrayUtil.subset(array, start, end);
494            }
495    
496            public int[] subset(int[] array, int start, int end) {
497                    return ArrayUtil.subset(array, start, end);
498            }
499    
500            public long[] subset(long[] array, int start, int end) {
501                    return ArrayUtil.subset(array, start, end);
502            }
503    
504            public short[] subset(short[] array, int start, int end) {
505                    return ArrayUtil.subset(array, start, end);
506            }
507    
508            public <T> T[] subset(T[] array, int start, int end) {
509                    return ArrayUtil.subset(array, start, end);
510            }
511    
512            public java.lang.Boolean[] toArray(boolean[] array) {
513                    return ArrayUtil.toArray(array);
514            }
515    
516            public boolean[] toArray(java.lang.Boolean[] array) {
517                    return ArrayUtil.toArray(array);
518            }
519    
520            public java.lang.Byte[] toArray(byte[] array) {
521                    return ArrayUtil.toArray(array);
522            }
523    
524            public byte[] toArray(java.lang.Byte[] array) {
525                    return ArrayUtil.toArray(array);
526            }
527    
528            public java.lang.Character[] toArray(char[] array) {
529                    return ArrayUtil.toArray(array);
530            }
531    
532            public char[] toArray(java.lang.Character[] array) {
533                    return ArrayUtil.toArray(array);
534            }
535    
536            public java.lang.Double[] toArray(double[] array) {
537                    return ArrayUtil.toArray(array);
538            }
539    
540            public double[] toArray(java.lang.Double[] array) {
541                    return ArrayUtil.toArray(array);
542            }
543    
544            public java.lang.Float[] toArray(float[] array) {
545                    return ArrayUtil.toArray(array);
546            }
547    
548            public float[] toArray(java.lang.Float[] array) {
549                    return ArrayUtil.toArray(array);
550            }
551    
552            public java.lang.Integer[] toArray(int[] array) {
553                    return ArrayUtil.toArray(array);
554            }
555    
556            public int[] toArray(java.lang.Integer[] array) {
557                    return ArrayUtil.toArray(array);
558            }
559    
560            public java.lang.Long[] toArray(long[] array) {
561                    return ArrayUtil.toArray(array);
562            }
563    
564            public long[] toArray(java.lang.Long[] array) {
565                    return ArrayUtil.toArray(array);
566            }
567    
568            public java.lang.Short[] toArray(short[] array) {
569                    return ArrayUtil.toArray(array);
570            }
571    
572            public short[] toArray(java.lang.Short[] array) {
573                    return ArrayUtil.toArray(array);
574            }
575    
576            public double[] toDoubleArray(
577                    java.util.Collection<java.lang.Double> collection) {
578                    return ArrayUtil.toDoubleArray(collection);
579            }
580    
581            public float[] toFloatArray(
582                    java.util.Collection<java.lang.Float> collection) {
583                    return ArrayUtil.toFloatArray(collection);
584            }
585    
586            public int[] toIntArray(java.util.Collection<java.lang.Integer> collection) {
587                    return ArrayUtil.toIntArray(collection);
588            }
589    
590            public long[] toLongArray(java.util.Collection<java.lang.Long> collection) {
591                    return ArrayUtil.toLongArray(collection);
592            }
593    
594            public java.lang.Long[] toLongArray(java.lang.Object[] array) {
595                    return ArrayUtil.toLongArray(array);
596            }
597    
598            public short[] toShortArray(
599                    java.util.Collection<java.lang.Short> collection) {
600                    return ArrayUtil.toShortArray(collection);
601            }
602    
603            public java.lang.String toString(java.lang.Object[] array,
604                    java.lang.String param) {
605                    return ArrayUtil.toString(array, param);
606            }
607    
608            public java.lang.String toString(java.lang.Object[] array,
609                    java.lang.String param, java.lang.String delimiter) {
610                    return ArrayUtil.toString(array, param, delimiter);
611            }
612    
613            public java.lang.String toString(java.lang.Object[] array,
614                    java.lang.String param, java.lang.String delimiter,
615                    java.util.Locale locale) {
616                    return ArrayUtil.toString(array, param, delimiter, locale);
617            }
618    
619            public <T, V> java.lang.String toString(T[] list,
620                    com.liferay.portal.kernel.util.Accessor<T, V> accessor) {
621                    return ArrayUtil.toString(list, accessor);
622            }
623    
624            public <T, V> java.lang.String toString(T[] list,
625                    com.liferay.portal.kernel.util.Accessor<T, V> accessor,
626                    java.lang.String delimiter) {
627                    return ArrayUtil.toString(list, accessor, delimiter);
628            }
629    
630            public <T, V> java.lang.String toString(T[] list,
631                    com.liferay.portal.kernel.util.Accessor<T, V> accessor,
632                    java.lang.String delimiter, java.util.Locale locale) {
633                    return ArrayUtil.toString(list, accessor, delimiter, locale);
634            }
635    
636            public java.lang.String[] toStringArray(boolean[] array) {
637                    return ArrayUtil.toStringArray(array);
638            }
639    
640            public java.lang.String[] toStringArray(byte[] array) {
641                    return ArrayUtil.toStringArray(array);
642            }
643    
644            public java.lang.String[] toStringArray(char[] array) {
645                    return ArrayUtil.toStringArray(array);
646            }
647    
648            public java.lang.String[] toStringArray(java.util.Date[] array,
649                    java.text.DateFormat dateFormat) {
650                    return ArrayUtil.toStringArray(array, dateFormat);
651            }
652    
653            public java.lang.String[] toStringArray(double[] array) {
654                    return ArrayUtil.toStringArray(array);
655            }
656    
657            public java.lang.String[] toStringArray(float[] array) {
658                    return ArrayUtil.toStringArray(array);
659            }
660    
661            public java.lang.String[] toStringArray(int[] array) {
662                    return ArrayUtil.toStringArray(array);
663            }
664    
665            public java.lang.String[] toStringArray(
666                    com.liferay.portal.kernel.json.JSONArray array) {
667                    return ArrayUtil.toStringArray(array);
668            }
669    
670            public java.lang.String[] toStringArray(long[] array) {
671                    return ArrayUtil.toStringArray(array);
672            }
673    
674            public java.lang.String[] toStringArray(java.lang.Object[] array) {
675                    return ArrayUtil.toStringArray(array);
676            }
677    
678            public java.lang.String[] toStringArray(short[] array) {
679                    return ArrayUtil.toStringArray(array);
680            }
681    
682            public byte[] unique(byte[] array) {
683                    return ArrayUtil.unique(array);
684            }
685    
686            public double[] unique(double[] array) {
687                    return ArrayUtil.unique(array);
688            }
689    
690            public float[] unique(float[] array) {
691                    return ArrayUtil.unique(array);
692            }
693    
694            public int[] unique(int[] array) {
695                    return ArrayUtil.unique(array);
696            }
697    
698            public long[] unique(long[] array) {
699                    return ArrayUtil.unique(array);
700            }
701    
702            public short[] unique(short[] array) {
703                    return ArrayUtil.unique(array);
704            }
705    
706            private ArrayUtil_IW() {
707            }
708    
709            private static ArrayUtil_IW _instance = new ArrayUtil_IW();
710    }