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