001
014
015 package com.liferay.portal.kernel.util;
016
017 import java.text.DateFormat;
018
019 import java.util.Date;
020
021
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 }