001    /**
002     * Copyright (c) 2000-2012 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    import java.text.DateFormat;
018    
019    import java.util.Date;
020    
021    /**
022     * @author Brian Wing Shun Chan
023     */
024    public class GetterUtil {
025    
026            public static final String[] BOOLEANS = {"true", "t", "y", "on", "1"};
027    
028            public static final boolean DEFAULT_BOOLEAN = false;
029    
030            public static final boolean[] DEFAULT_BOOLEAN_VALUES = new boolean[0];
031    
032            public static final byte DEFAULT_BYTE = 0;
033    
034            public static final byte[] DEFAULT_BYTE_VALUES = new byte[0];
035    
036            public static final Date[] DEFAULT_DATE_VALUES = new Date[0];
037    
038            public static final double DEFAULT_DOUBLE = 0.0;
039    
040            public static final double[] DEFAULT_DOUBLE_VALUES = new double[0];
041    
042            public static final float DEFAULT_FLOAT = 0;
043    
044            public static final float[] DEFAULT_FLOAT_VALUES = new float[0];
045    
046            public static final int DEFAULT_INTEGER = 0;
047    
048            public static final int[] DEFAULT_INTEGER_VALUES = new int[0];
049    
050            public static final long DEFAULT_LONG = 0;
051    
052            public static final long[] DEFAULT_LONG_VALUES = new long[0];
053    
054            public static final Number DEFAULT_NUMBER = 0;
055    
056            public static final Number[] DEFAULT_NUMBER_VALUES = new Number[0];
057    
058            public static final Number DEFAULT_OBJECT = null;
059    
060            public static final short DEFAULT_SHORT = 0;
061    
062            public static final short[] DEFAULT_SHORT_VALUES = new short[0];
063    
064            public static final String DEFAULT_STRING = StringPool.BLANK;
065    
066            public static boolean get(Object value, boolean defaultValue) {
067                    if (value == null) {
068                            return defaultValue;
069                    }
070    
071                    if (value instanceof String) {
072                            return get((String)value, defaultValue);
073                    }
074    
075                    Class<?> clazz = value.getClass();
076    
077                    if (clazz.isAssignableFrom(Boolean.class)) {
078                            return (Boolean)value;
079                    }
080    
081                    return defaultValue;
082            }
083    
084            public static Date get(
085                    Object value, DateFormat dateFormat, Date defaultValue) {
086    
087                    if (value == null) {
088                            return defaultValue;
089                    }
090    
091                    if (value instanceof String) {
092                            return get((String)value, dateFormat, defaultValue);
093                    }
094    
095                    Class<?> clazz = value.getClass();
096    
097                    if (clazz.isAssignableFrom(Date.class)) {
098                            return (Date)value;
099                    }
100    
101                    return defaultValue;
102            }
103    
104            public static double get(Object value, double defaultValue) {
105                    if (value == null) {
106                            return defaultValue;
107                    }
108    
109                    if (value instanceof String) {
110                            return get((String)value, defaultValue);
111                    }
112    
113                    Class<?> clazz = value.getClass();
114    
115                    if (clazz.isAssignableFrom(Double.class)) {
116                            return (Double)value;
117                    }
118    
119                    if (value instanceof Number) {
120                            Number number = (Number)value;
121    
122                            return number.doubleValue();
123                    }
124    
125                    return defaultValue;
126            }
127    
128            public static float get(Object value, float defaultValue) {
129                    if (value == null) {
130                            return defaultValue;
131                    }
132    
133                    if (value instanceof String) {
134                            return get((String)value, defaultValue);
135                    }
136    
137                    Class<?> clazz = value.getClass();
138    
139                    if (clazz.isAssignableFrom(Float.class)) {
140                            return (Float)value;
141                    }
142    
143                    if (value instanceof Number) {
144                            Number number = (Number)value;
145    
146                            return number.floatValue();
147                    }
148    
149                    return defaultValue;
150            }
151    
152            public static int get(Object value, int defaultValue) {
153                    if (value == null) {
154                            return defaultValue;
155                    }
156    
157                    if (value instanceof String) {
158                            return get((String)value, defaultValue);
159                    }
160    
161                    Class<?> clazz = value.getClass();
162    
163                    if (clazz.isAssignableFrom(Integer.class)) {
164                            return (Integer)value;
165                    }
166    
167                    if (value instanceof Number) {
168                            Number number = (Number)value;
169    
170                            return number.intValue();
171                    }
172    
173                    return defaultValue;
174            }
175    
176            public static long get(Object value, long defaultValue) {
177                    if (value == null) {
178                            return defaultValue;
179                    }
180    
181                    if (value instanceof String) {
182                            return get((String)value, defaultValue);
183                    }
184    
185                    Class<?> clazz = value.getClass();
186    
187                    if (clazz.isAssignableFrom(Long.class)) {
188                            return (Long)value;
189                    }
190    
191                    if (value instanceof Number) {
192                            Number number = (Number)value;
193    
194                            return number.longValue();
195                    }
196    
197                    return defaultValue;
198            }
199    
200            public static Number get(Object value, Number defaultValue) {
201                    if (value == null) {
202                            return defaultValue;
203                    }
204    
205                    if (value instanceof String) {
206                            if (Validator.isNull(value)) {
207                                    return defaultValue;
208                            }
209    
210                            if (getFloat(value) == getInteger(value)) {
211                                    return getInteger(value);
212                            }
213                            else {
214                                    return getFloat(value);
215                            }
216                    }
217    
218                    Class<?> clazz = value.getClass();
219    
220                    if (clazz.isAssignableFrom(Byte.class)) {
221                            return (Byte)value;
222                    }
223                    else if (clazz.isAssignableFrom(Double.class)) {
224                            return (Double)value;
225                    }
226                    else if (clazz.isAssignableFrom(Float.class)) {
227                            return (Float)value;
228                    }
229                    else if (clazz.isAssignableFrom(Integer.class)) {
230                            return (Integer)value;
231                    }
232                    else if (clazz.isAssignableFrom(Long.class)) {
233                            return (Long)value;
234                    }
235                    else if (clazz.isAssignableFrom(Short.class)) {
236                            return (Short)value;
237                    }
238    
239                    if (value instanceof Number) {
240                            return (Number)value;
241                    }
242    
243                    return defaultValue;
244            }
245    
246            public static short get(Object value, short defaultValue) {
247                    if (value == null) {
248                            return defaultValue;
249                    }
250    
251                    if (value instanceof String) {
252                            return get((String)value, defaultValue);
253                    }
254    
255                    Class<?> clazz = value.getClass();
256    
257                    if (clazz.isAssignableFrom(Short.class)) {
258                            return (Short)value;
259                    }
260    
261                    if (value instanceof Number) {
262                            Number number = (Number)value;
263    
264                            return number.shortValue();
265                    }
266    
267                    return defaultValue;
268            }
269    
270            public static String get(Object value, String defaultValue) {
271                    if (value == null) {
272                            return defaultValue;
273                    }
274    
275                    if (value instanceof String) {
276                            return get((String)value, defaultValue);
277                    }
278    
279                    return defaultValue;
280            }
281    
282            public static boolean get(String value, boolean defaultValue) {
283                    if (value == null) {
284                            return defaultValue;
285                    }
286    
287                    try {
288                            value = value.trim().toLowerCase();
289    
290                            if (value.equals(BOOLEANS[0]) || value.equals(BOOLEANS[1]) ||
291                                    value.equals(BOOLEANS[2]) || value.equals(BOOLEANS[3]) ||
292                                    value.equals(BOOLEANS[4])) {
293    
294                                    return true;
295                            }
296                            else {
297                                    return false;
298                            }
299                    }
300                    catch (Exception e) {
301                    }
302    
303                    return defaultValue;
304            }
305    
306            public static Date get(
307                    String value, DateFormat dateFormat, Date defaultValue) {
308    
309                    if (value == null) {
310                            return defaultValue;
311                    }
312    
313                    try {
314                            Date date = dateFormat.parse(value.trim());
315    
316                            if (date != null) {
317                                    return date;
318                            }
319                    }
320                    catch (Exception e) {
321                    }
322    
323                    return defaultValue;
324            }
325    
326            public static double get(String value, double defaultValue) {
327                    if (value != null) {
328                            try {
329                                    return Double.parseDouble(_trim(value));
330                            }
331                            catch (Exception e) {
332                            }
333                    }
334    
335                    return defaultValue;
336            }
337    
338            public static float get(String value, float defaultValue) {
339                    if (value == null) {
340                            return defaultValue;
341                    }
342    
343                    try {
344                            return Float.parseFloat(_trim(value));
345                    }
346                    catch (Exception e) {
347                    }
348    
349                    return defaultValue;
350            }
351    
352            public static int get(String value, int defaultValue) {
353                    if (value == null) {
354                            return defaultValue;
355                    }
356    
357                    return _parseInt(_trim(value), defaultValue);
358            }
359    
360            public static long get(String value, long defaultValue) {
361                    if (value == null) {
362                            return defaultValue;
363                    }
364    
365                    return _parseLong(_trim(value), defaultValue);
366            }
367    
368            public static short get(String value, short defaultValue) {
369                    if (value == null) {
370                            return defaultValue;
371                    }
372    
373                    return _parseShort(_trim(value), defaultValue);
374            }
375    
376            public static String get(String value, String defaultValue) {
377                    if (value == null) {
378                            return defaultValue;
379                    }
380    
381                    value = value.trim();
382    
383                    if (value.indexOf(CharPool.RETURN) != -1) {
384                            value = StringUtil.replace(
385                                    value, StringPool.RETURN_NEW_LINE, StringPool.NEW_LINE);
386                    }
387    
388                    return value;
389            }
390    
391            public static boolean getBoolean(Object value) {
392                    return getBoolean(value, DEFAULT_BOOLEAN);
393            }
394    
395            public static boolean getBoolean(Object value, boolean defaultValue) {
396                    return get(value, defaultValue);
397            }
398    
399            public static boolean getBoolean(String value) {
400                    return getBoolean(value, DEFAULT_BOOLEAN);
401            }
402    
403            public static boolean getBoolean(String value, boolean defaultValue) {
404                    return get(value, defaultValue);
405            }
406    
407            public static boolean[] getBooleanValues(Object value) {
408                    return getBooleanValues(value, DEFAULT_BOOLEAN_VALUES);
409            }
410    
411            public static boolean[] getBooleanValues(
412                    Object value, boolean[] defaultValue) {
413    
414                    Class<?> clazz = value.getClass();
415    
416                    if (clazz.isArray()) {
417                            Class<?> componentType = clazz.getComponentType();
418    
419                            if (componentType.isAssignableFrom(String.class)) {
420                                    return getBooleanValues((String[])value, defaultValue);
421                            }
422                            else if (componentType.isAssignableFrom(Boolean.class)) {
423                                    return (boolean[])value;
424                            }
425                    }
426    
427                    return defaultValue;
428            }
429    
430            public static boolean[] getBooleanValues(String[] values) {
431                    return getBooleanValues(values, DEFAULT_BOOLEAN_VALUES);
432            }
433    
434            public static boolean[] getBooleanValues(
435                    String[] values, boolean[] defaultValue) {
436    
437                    if (values == null) {
438                            return defaultValue;
439                    }
440    
441                    boolean[] booleanValues = new boolean[values.length];
442    
443                    for (int i = 0; i < values.length; i++) {
444                            booleanValues[i] = getBoolean(values[i]);
445                    }
446    
447                    return booleanValues;
448            }
449    
450            public static Date getDate(Object value, DateFormat dateFormat) {
451                    return getDate(value, dateFormat, new Date());
452            }
453    
454            public static Date getDate(
455                    Object value, DateFormat dateFormat, Date defaultValue) {
456    
457                    return get(value, dateFormat, defaultValue);
458            }
459    
460            public static Date getDate(String value, DateFormat dateFormat) {
461                    return getDate(value, dateFormat, new Date());
462            }
463    
464            public static Date getDate(
465                    String value, DateFormat dateFormat, Date defaultValue) {
466    
467                    return get(value, dateFormat, defaultValue);
468            }
469    
470            public static Date[] getDateValues(Object value, DateFormat dateFormat) {
471                    return getDateValues(value, dateFormat, DEFAULT_DATE_VALUES);
472            }
473    
474            public static Date[] getDateValues(
475                    Object value, DateFormat dateFormat, Date[] defaultValue) {
476    
477                    Class<?> clazz = value.getClass();
478    
479                    if (clazz.isArray()) {
480                            Class<?> componentType = clazz.getComponentType();
481    
482                            if (componentType.isAssignableFrom(String.class)) {
483                                    return getDateValues((String[])value, dateFormat, defaultValue);
484                            }
485                            else if (componentType.isAssignableFrom(Date.class)) {
486                                    return (Date[])value;
487                            }
488                    }
489    
490                    return defaultValue;
491            }
492    
493            public static Date[] getDateValues(String[] values, DateFormat dateFormat) {
494                    return getDateValues(values, dateFormat, DEFAULT_DATE_VALUES);
495            }
496    
497            public static Date[] getDateValues(
498                    String[] values, DateFormat dateFormat, Date[] defaultValue) {
499    
500                    if (values == null) {
501                            return defaultValue;
502                    }
503    
504                    Date[] dateValues = new Date[values.length];
505    
506                    for (int i = 0; i < values.length; i++) {
507                            dateValues[i] = getDate(values[i], dateFormat);
508                    }
509    
510                    return dateValues;
511            }
512    
513            public static double getDouble(Object value) {
514                    return getDouble(value, DEFAULT_DOUBLE);
515            }
516    
517            public static double getDouble(Object value, double defaultValue) {
518                    return get(value, defaultValue);
519            }
520    
521            public static double getDouble(String value) {
522                    return getDouble(value, DEFAULT_DOUBLE);
523            }
524    
525            public static double getDouble(String value, double defaultValue) {
526                    return get(value, defaultValue);
527            }
528    
529            public static double[] getDoubleValues(Object value) {
530                    return getDoubleValues(value, DEFAULT_DOUBLE_VALUES);
531            }
532    
533            public static double[] getDoubleValues(
534                    Object value, double[] defaultValue) {
535    
536                    Class<?> clazz = value.getClass();
537    
538                    if (clazz.isArray()) {
539                            Class<?> componentType = clazz.getComponentType();
540    
541                            if (componentType.isAssignableFrom(String.class)) {
542                                    return getDoubleValues((String[])value, defaultValue);
543                            }
544                            else if (componentType.isAssignableFrom(Double.class)) {
545                                    return (double[])value;
546                            }
547                    }
548    
549                    return defaultValue;
550            }
551    
552            public static double[] getDoubleValues(String[] values) {
553                    return getDoubleValues(values, DEFAULT_DOUBLE_VALUES);
554            }
555    
556            public static double[] getDoubleValues(
557                    String[] values, double[] defaultValue) {
558    
559                    if (values == null) {
560                            return defaultValue;
561                    }
562    
563                    double[] doubleValues = new double[values.length];
564    
565                    for (int i = 0; i < values.length; i++) {
566                            doubleValues[i] = getDouble(values[i]);
567                    }
568    
569                    return doubleValues;
570            }
571    
572            public static float getFloat(Object value) {
573                    return getFloat(value, DEFAULT_FLOAT);
574            }
575    
576            public static float getFloat(Object value, float defaultValue) {
577                    return get(value, defaultValue);
578            }
579    
580            public static float getFloat(String value) {
581                    return getFloat(value, DEFAULT_FLOAT);
582            }
583    
584            public static float getFloat(String value, float defaultValue) {
585                    return get(value, defaultValue);
586            }
587    
588            public static float[] getFloatValues(Object value) {
589                    return getFloatValues(value, DEFAULT_FLOAT_VALUES);
590            }
591    
592            public static float[] getFloatValues(Object value, float[] defaultValue) {
593                    Class<?> clazz = value.getClass();
594    
595                    if (clazz.isArray()) {
596                            Class<?> componentType = clazz.getComponentType();
597    
598                            if (componentType.isAssignableFrom(String.class)) {
599                                    return getFloatValues((String[])value, defaultValue);
600                            }
601                            else if (componentType.isAssignableFrom(Float.class)) {
602                                    return (float[])value;
603                            }
604                    }
605    
606                    return defaultValue;
607            }
608    
609            public static float[] getFloatValues(String[] values) {
610                    return getFloatValues(values, DEFAULT_FLOAT_VALUES);
611            }
612    
613            public static float[] getFloatValues(
614                    String[] values, float[] defaultValue) {
615    
616                    if (values == null) {
617                            return defaultValue;
618                    }
619    
620                    float[] floatValues = new float[values.length];
621    
622                    for (int i = 0; i < values.length; i++) {
623                            floatValues[i] = getFloat(values[i]);
624                    }
625    
626                    return floatValues;
627            }
628    
629            public static int getInteger(Object value) {
630                    return getInteger(value, DEFAULT_INTEGER);
631            }
632    
633            public static int getInteger(Object value, int defaultValue) {
634                    return get(value, defaultValue);
635            }
636    
637            public static int getInteger(String value) {
638                    return getInteger(value, DEFAULT_INTEGER);
639            }
640    
641            public static int getInteger(String value, int defaultValue) {
642                    return get(value, defaultValue);
643            }
644    
645            public static int[] getIntegerValues(Object value) {
646                    return getIntegerValues(value, DEFAULT_INTEGER_VALUES);
647            }
648    
649            public static int[] getIntegerValues(Object value, int[] defaultValue) {
650                    Class<?> clazz = value.getClass();
651    
652                    if (clazz.isArray()) {
653                            Class<?> componentType = clazz.getComponentType();
654    
655                            if (componentType.isAssignableFrom(String.class)) {
656                                    return getIntegerValues((String[])value, defaultValue);
657                            }
658                            else if (componentType.isAssignableFrom(Integer.class)) {
659                                    return (int[])value;
660                            }
661                    }
662    
663                    return defaultValue;
664            }
665    
666            public static int[] getIntegerValues(String[] values) {
667                    return getIntegerValues(values, DEFAULT_INTEGER_VALUES);
668            }
669    
670            public static int[] getIntegerValues(String[] values, int[] defaultValue) {
671                    if (values == null) {
672                            return defaultValue;
673                    }
674    
675                    int[] intValues = new int[values.length];
676    
677                    for (int i = 0; i < values.length; i++) {
678                            intValues[i] = getInteger(values[i]);
679                    }
680    
681                    return intValues;
682            }
683    
684            public static long getLong(Object value) {
685                    return getLong(value, DEFAULT_LONG);
686            }
687    
688            public static long getLong(Object value, long defaultValue) {
689                    return get(value, defaultValue);
690            }
691    
692            public static long getLong(String value) {
693                    return getLong(value, DEFAULT_LONG);
694            }
695    
696            public static long getLong(String value, long defaultValue) {
697                    return get(value, defaultValue);
698            }
699    
700            public static long[] getLongValues(Object value) {
701                    return getLongValues(value, DEFAULT_LONG_VALUES);
702            }
703    
704            public static long[] getLongValues(Object value, long[] defaultValue) {
705                    Class<?> clazz = value.getClass();
706    
707                    if (clazz.isArray()) {
708                            Class<?> componentType = clazz.getComponentType();
709    
710                            if (componentType.isAssignableFrom(String.class)) {
711                                    return getLongValues((String[])value, defaultValue);
712                            }
713                            else if (componentType.isAssignableFrom(Long.class)) {
714                                    return (long[])value;
715                            }
716                            else if (Number.class.isAssignableFrom(componentType)) {
717                                    Number[] numbers = (Number[])value;
718    
719                                    long[] values = new long[numbers.length];
720    
721                                    for (int i = 0; i < values.length; i++) {
722                                            values[i] = numbers[i].longValue();
723                                    }
724    
725                                    return values;
726                            }
727                    }
728    
729                    return defaultValue;
730            }
731    
732            public static long[] getLongValues(String[] values) {
733                    return getLongValues(values, DEFAULT_LONG_VALUES);
734            }
735    
736            public static long[] getLongValues(String[] values, long[] defaultValue) {
737                    if (values == null) {
738                            return defaultValue;
739                    }
740    
741                    long[] longValues = new long[values.length];
742    
743                    for (int i = 0; i < values.length; i++) {
744                            longValues[i] = getLong(values[i]);
745                    }
746    
747                    return longValues;
748            }
749    
750            public static Number getNumber(Object value) {
751                    return getNumber(value, DEFAULT_NUMBER);
752            }
753    
754            public static Number getNumber(Object value, Number defaultValue) {
755                    return get(value, defaultValue);
756            }
757    
758            public static Number getNumber(String value) {
759                    return getNumber(value, DEFAULT_NUMBER);
760            }
761    
762            public static Number getNumber(String value, Number defaultValue) {
763                    return get(value, defaultValue);
764            }
765    
766            public static Number[] getNumberValues(Object value) {
767                    return getNumberValues(value, DEFAULT_NUMBER_VALUES);
768            }
769    
770            public static Number[] getNumberValues(
771                    Object value, Number[] defaultValue) {
772    
773                    Class<?> clazz = value.getClass();
774    
775                    if (clazz.isArray()) {
776                            Class<?> componentType = clazz.getComponentType();
777    
778                            if (componentType.isAssignableFrom(String.class)) {
779                                    return getNumberValues((String[])value, defaultValue);
780                            }
781                            else if (componentType.isAssignableFrom(Number.class)) {
782                                    return (Number[])value;
783                            }
784                    }
785    
786                    return defaultValue;
787            }
788    
789            public static Number[] getNumberValues(String[] values) {
790                    return getNumberValues(values, DEFAULT_NUMBER_VALUES);
791            }
792    
793            public static Number[] getNumberValues(
794                    String[] values, Number[] defaultValue) {
795    
796                    if (values == null) {
797                            return defaultValue;
798                    }
799    
800                    Number[] numberValues = new Number[values.length];
801    
802                    for (int i = 0; i < values.length; i++) {
803                            numberValues[i] = getNumber(values[i]);
804                    }
805    
806                    return numberValues;
807            }
808    
809            public static Object getObject(Object value) {
810                    return getObject(value, DEFAULT_OBJECT);
811            }
812    
813            public static Object getObject(Object value, Object defaultValue) {
814                    if (value == null) {
815                            return defaultValue;
816                    }
817    
818                    return value;
819            }
820    
821            public static short getShort(Object value) {
822                    return getShort(value, DEFAULT_SHORT);
823            }
824    
825            public static short getShort(Object value, short defaultValue) {
826                    return get(value, defaultValue);
827            }
828    
829            public static short getShort(String value) {
830                    return getShort(value, DEFAULT_SHORT);
831            }
832    
833            public static short getShort(String value, short defaultValue) {
834                    return get(value, defaultValue);
835            }
836    
837            public static short[] getShortValues(Object value) {
838                    return getShortValues(value, DEFAULT_SHORT_VALUES);
839            }
840    
841            public static short[] getShortValues(Object value, short[] defaultValue) {
842                    Class<?> clazz = value.getClass();
843    
844                    if (clazz.isArray()) {
845                            Class<?> componentType = clazz.getComponentType();
846    
847                            if (componentType.isAssignableFrom(String.class)) {
848                                    return getShortValues((String[])value, defaultValue);
849                            }
850                            else if (componentType.isAssignableFrom(Short.class)) {
851                                    return (short[])value;
852                            }
853                    }
854    
855                    return defaultValue;
856            }
857    
858            public static short[] getShortValues(String[] values) {
859                    return getShortValues(values, DEFAULT_SHORT_VALUES);
860            }
861    
862            public static short[] getShortValues(
863                    String[] values, short[] defaultValue) {
864    
865                    if (values == null) {
866                            return defaultValue;
867                    }
868    
869                    short[] shortValues = new short[values.length];
870    
871                    for (int i = 0; i < values.length; i++) {
872                            shortValues[i] = getShort(values[i]);
873                    }
874    
875                    return shortValues;
876            }
877    
878            public static String getString(Object value) {
879                    return getString(value, DEFAULT_STRING);
880            }
881    
882            public static String getString(Object value, String defaultValue) {
883                    return get(value, defaultValue);
884            }
885    
886            public static String getString(String value) {
887                    return getString(value, DEFAULT_STRING);
888            }
889    
890            public static String getString(String value, String defaultValue) {
891                    return get(value, defaultValue);
892            }
893    
894            private static int _parseInt(String value, int defaultValue) {
895                    int length = value.length();
896    
897                    if (length <= 0) {
898                            return defaultValue;
899                    }
900    
901                    int pos = 0;
902                    int limit = -Integer.MAX_VALUE;
903                    boolean negative = false;
904    
905                    char c = value.charAt(0);
906    
907                    if (c < CharPool.NUMBER_0) {
908                            if (c == CharPool.MINUS) {
909                                    limit = Integer.MIN_VALUE;
910                                    negative = true;
911                            }
912                            else if (c != CharPool.PLUS) {
913                                    return defaultValue;
914                            }
915    
916                            if (length == 1) {
917                                    return defaultValue;
918                            }
919    
920                            pos++;
921                    }
922    
923                    int smallLimit = limit / 10;
924    
925                    int result = 0;
926    
927                    while (pos < length) {
928                            if (result < smallLimit) {
929                                    return defaultValue;
930                            }
931    
932                            c = value.charAt(pos++);
933    
934                            if ((c < CharPool.NUMBER_0) || (c > CharPool.NUMBER_9)) {
935                                    return defaultValue;
936                            }
937    
938                            int number = c - CharPool.NUMBER_0;
939    
940                            result *= 10;
941    
942                            if (result < (limit + number)) {
943                                    return defaultValue;
944                            }
945    
946                            result -= number;
947                    }
948    
949                    if (negative) {
950                            return result;
951                    }
952                    else {
953                            return -result;
954                    }
955            }
956    
957            private static long _parseLong(String value, long defaultValue) {
958                    if (_useJDKParseLong == null) {
959                            if (OSDetector.isAIX() && ServerDetector.isWebSphere() &&
960                                    JavaDetector.isIBM() && JavaDetector.is64bit()) {
961    
962                                    _useJDKParseLong = Boolean.TRUE;
963                            }
964                            else {
965                                    _useJDKParseLong = Boolean.FALSE;
966                            }
967                    }
968    
969                    if (_useJDKParseLong) {
970                            try {
971                                    return Long.parseLong(value);
972                            }
973                            catch (NumberFormatException nfe) {
974                                    return defaultValue;
975                            }
976                    }
977    
978                    int length = value.length();
979    
980                    if (length <= 0) {
981                            return defaultValue;
982                    }
983    
984                    int pos = 0;
985                    long limit = -Long.MAX_VALUE;
986                    boolean negative = false;
987    
988                    char c = value.charAt(0);
989    
990                    if (c < CharPool.NUMBER_0) {
991                            if (c == CharPool.MINUS) {
992                                    limit = Long.MIN_VALUE;
993                                    negative = true;
994                            }
995                            else if (c != CharPool.PLUS) {
996                                    return defaultValue;
997                            }
998    
999                            if (length == 1) {
1000                                    return defaultValue;
1001                            }
1002    
1003                            pos++;
1004                    }
1005    
1006                    long smallLimit = limit / 10;
1007    
1008                    long result = 0;
1009    
1010                    while (pos < length) {
1011                            if (result < smallLimit) {
1012                                    return defaultValue;
1013                            }
1014    
1015                            c = value.charAt(pos++);
1016    
1017                            if ((c < CharPool.NUMBER_0) || (c > CharPool.NUMBER_9)) {
1018                                    return defaultValue;
1019                            }
1020    
1021                            int number = c - CharPool.NUMBER_0;
1022    
1023                            result *= 10;
1024    
1025                            if (result < (limit + number)) {
1026                                    return defaultValue;
1027                            }
1028    
1029                            result -= number;
1030                    }
1031    
1032                    if (negative) {
1033                            return result;
1034                    }
1035                    else {
1036                            return -result;
1037                    }
1038            }
1039    
1040            private static short _parseShort(String value, short defaultValue) {
1041                    int i = _parseInt(value, defaultValue);
1042    
1043                    if ((i < Short.MIN_VALUE) || (i > Short.MAX_VALUE)) {
1044                            return defaultValue;
1045                    }
1046    
1047                    return (short)i;
1048            }
1049    
1050            private static String _trim(String value) {
1051                    value = value.trim();
1052    
1053                    int length = value.length();
1054    
1055                    StringBuilder sb = new StringBuilder(length);
1056    
1057                    for (int i = 0; i < length; i++) {
1058                            char c = value.charAt(i);
1059    
1060                            if (Character.isDigit(c) ||
1061                                    ((c == CharPool.DASH) &&
1062                                     ((i == 0) || (value.charAt(i - 1) == CharPool.UPPER_CASE_E) ||
1063                                      (value.charAt(i - 1) == CharPool.LOWER_CASE_E))) ||
1064                                    (c == CharPool.PERIOD) || (c == CharPool.UPPER_CASE_E) ||
1065                                    (c == CharPool.LOWER_CASE_E)) {
1066    
1067                                    sb.append(c);
1068                            }
1069                    }
1070    
1071                    return sb.toString();
1072            }
1073    
1074            private static Boolean _useJDKParseLong;
1075    
1076    }