1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.log4j;
18
19 import org.apache.log4j.spi.LoggingEvent;
20
21 import java.text.DateFormat;
22 import java.text.MessageFormat;
23 import java.text.NumberFormat;
24 import java.util.Date;
25 import java.util.ResourceBundle;
26 import java.util.Locale;
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 public final class LogMF extends LogXF {
46
47
48
49
50 private LogMF() {
51 }
52
53
54
55
56 private static NumberFormat numberFormat = null;
57
58
59
60 private static Locale numberLocale = null;
61
62
63
64 private static DateFormat dateFormat = null;
65
66
67
68 private static Locale dateLocale = null;
69
70
71
72
73
74
75 private static synchronized String formatNumber(final Object n) {
76 Locale currentLocale = Locale.getDefault();
77 if (currentLocale != numberLocale || numberFormat == null) {
78 numberLocale = currentLocale;
79 numberFormat = NumberFormat.getInstance(currentLocale);
80 }
81 return numberFormat.format(n);
82 }
83
84
85
86
87
88
89
90 private static synchronized String formatDate(final Object d) {
91 Locale currentLocale = Locale.getDefault();
92 if (currentLocale != dateLocale || dateFormat == null) {
93 dateLocale = currentLocale;
94 dateFormat = DateFormat.getDateTimeInstance(
95 DateFormat.SHORT,
96 DateFormat.SHORT,
97 currentLocale);
98 }
99 return dateFormat.format(d);
100 }
101
102
103
104
105
106
107
108 private static String formatObject(final Object arg0) {
109 if (arg0 instanceof String) {
110 return arg0.toString();
111 } else if (arg0 instanceof Double ||
112 arg0 instanceof Float) {
113 return formatNumber(arg0);
114 } else if (arg0 instanceof Date) {
115 return formatDate(arg0);
116 }
117 return String.valueOf(arg0);
118 }
119
120
121
122
123
124
125
126
127
128 private static boolean isSimple(final String pattern) {
129 if (pattern.indexOf('\'') != -1) {
130 return false;
131 }
132 for(int pos = pattern.indexOf('{');
133 pos != -1;
134 pos = pattern.indexOf('{', pos + 1)) {
135 if (pos + 2 >= pattern.length() ||
136 pattern.charAt(pos+2) != '}' ||
137 pattern.charAt(pos+1) < '0' ||
138 pattern.charAt(pos+1) > '9') {
139 return false;
140 }
141 }
142 return true;
143
144 }
145
146
147
148
149
150
151
152 private static String format(final String pattern,
153 final Object[] arguments) {
154 if (pattern == null) {
155 return null;
156 } else if(isSimple(pattern)) {
157 String formatted[] = new String[10];
158 int prev = 0;
159 String retval = "";
160 int pos = pattern.indexOf('{');
161 while(pos >= 0) {
162 if(pos + 2 < pattern.length() &&
163 pattern.charAt(pos+2) == '}' &&
164 pattern.charAt(pos+1) >= '0' &&
165 pattern.charAt(pos+1) <= '9') {
166 int index = pattern.charAt(pos+1) - '0';
167 retval += pattern.substring(prev, pos);
168 if (formatted[index] == null) {
169 if (arguments == null || index >= arguments.length) {
170 formatted[index] = pattern.substring(pos, pos+3);
171 } else {
172 formatted[index] = formatObject(arguments[index]);
173 }
174 }
175 retval += formatted[index];
176 prev = pos + 3;
177 pos = pattern.indexOf('{', prev);
178 } else {
179 pos = pattern.indexOf('{', pos + 1);
180 }
181 }
182 retval += pattern.substring(prev);
183 return retval;
184 }
185 try {
186 return MessageFormat.format(pattern, arguments);
187 } catch (IllegalArgumentException ex) {
188 return pattern;
189 }
190 }
191
192
193
194
195
196
197
198 private static String format(final String pattern,
199 final Object arg0) {
200 if (pattern == null) {
201 return null;
202 } else if(isSimple(pattern)) {
203 String formatted = null;
204 int prev = 0;
205 String retval = "";
206 int pos = pattern.indexOf('{');
207 while(pos >= 0) {
208 if(pos + 2 < pattern.length() &&
209 pattern.charAt(pos+2) == '}' &&
210 pattern.charAt(pos+1) >= '0' &&
211 pattern.charAt(pos+1) <= '9') {
212 int index = pattern.charAt(pos+1) - '0';
213 retval += pattern.substring(prev, pos);
214 if (index != 0) {
215 retval += pattern.substring(pos, pos+3);
216 } else {
217 if (formatted == null) {
218 formatted = formatObject(arg0);
219 }
220 retval += formatted;
221 }
222 prev = pos + 3;
223 pos = pattern.indexOf('{', prev);
224 } else {
225 pos = pattern.indexOf('{', pos + 1);
226 }
227 }
228 retval += pattern.substring(prev);
229 return retval;
230 }
231 try {
232 return MessageFormat.format(pattern, new Object[] { arg0 });
233 } catch (IllegalArgumentException ex) {
234 return pattern;
235 }
236 }
237
238
239
240
241
242
243
244
245
246
247 private static String format(
248 final String resourceBundleName,
249 final String key,
250 final Object[] arguments) {
251 String pattern;
252 if (resourceBundleName != null) {
253 try {
254 ResourceBundle bundle =
255 ResourceBundle.getBundle(resourceBundleName);
256 pattern = bundle.getString(key);
257 } catch (Exception ex) {
258 pattern = key;
259 }
260 } else {
261 pattern = key;
262 }
263 return format(pattern, arguments);
264 }
265
266
267
268
269
270 private static final String FQCN = LogMF.class.getName();
271
272
273
274
275
276
277
278
279 private static void forcedLog(final Logger logger,
280 final Level level,
281 final String msg) {
282 logger.callAppenders(new LoggingEvent(FQCN, logger, level, msg, null));
283 }
284
285
286
287
288
289
290
291
292
293 private static void forcedLog(final Logger logger,
294 final Level level,
295 final String msg,
296 final Throwable t) {
297 logger.callAppenders(new LoggingEvent(FQCN, logger, level, msg, t));
298 }
299
300
301
302
303
304
305
306 public static void trace(final Logger logger, final String pattern,
307 final Object[] arguments) {
308 if (logger.isEnabledFor(TRACE)) {
309 forcedLog(logger, TRACE, format(pattern, arguments));
310 }
311 }
312
313
314
315
316
317
318
319 public static void debug(final Logger logger, final String pattern,
320 final Object[] arguments) {
321 if (logger.isDebugEnabled()) {
322 forcedLog(logger, Level.DEBUG, format(pattern, arguments));
323 }
324 }
325
326
327
328
329
330
331
332 public static void info(final Logger logger, final String pattern,
333 final Object[] arguments) {
334 if (logger.isInfoEnabled()) {
335 forcedLog(logger, Level.INFO, format(pattern, arguments));
336 }
337 }
338
339
340
341
342
343
344
345 public static void warn(final Logger logger, final String pattern,
346 final Object[] arguments) {
347 if (logger.isEnabledFor(Level.WARN)) {
348 forcedLog(logger, Level.WARN, format(pattern, arguments));
349 }
350 }
351
352
353
354
355
356
357
358 public static void error(final Logger logger, final String pattern,
359 final Object[] arguments) {
360 if (logger.isEnabledFor(Level.ERROR)) {
361 forcedLog(logger, Level.ERROR, format(pattern, arguments));
362 }
363 }
364
365
366
367
368
369
370
371 public static void fatal(final Logger logger, final String pattern,
372 final Object[] arguments) {
373 if (logger.isEnabledFor(Level.FATAL)) {
374 forcedLog(logger, Level.FATAL, format(pattern, arguments));
375 }
376 }
377
378
379
380
381
382
383
384
385
386 public static void trace(final Logger logger,
387 final Throwable t,
388 final String pattern,
389 final Object[] arguments) {
390 if (logger.isEnabledFor(TRACE)) {
391 forcedLog(logger, TRACE, format(pattern, arguments), t);
392 }
393 }
394
395
396
397
398
399
400
401
402 public static void debug(final Logger logger,
403 final Throwable t,
404 final String pattern,
405 final Object[] arguments) {
406 if (logger.isDebugEnabled()) {
407 forcedLog(logger, Level.DEBUG, format(pattern, arguments), t);
408 }
409 }
410
411
412
413
414
415
416
417
418 public static void info(final Logger logger,
419 final Throwable t,
420 final String pattern,
421 final Object[] arguments) {
422 if (logger.isInfoEnabled()) {
423 forcedLog(logger, Level.INFO, format(pattern, arguments), t);
424 }
425 }
426
427
428
429
430
431
432
433
434 public static void warn(final Logger logger,
435 final Throwable t,
436 final String pattern,
437 final Object[] arguments) {
438 if (logger.isEnabledFor(Level.WARN)) {
439 forcedLog(logger, Level.WARN, format(pattern, arguments), t);
440 }
441 }
442
443
444
445
446
447
448
449
450 public static void error(final Logger logger,
451 final Throwable t,
452 final String pattern,
453 final Object[] arguments) {
454 if (logger.isEnabledFor(Level.ERROR)) {
455 forcedLog(logger, Level.ERROR, format(pattern, arguments), t);
456 }
457 }
458
459
460
461
462
463
464
465
466 public static void fatal(final Logger logger,
467 final Throwable t,
468 final String pattern,
469 final Object[] arguments) {
470 if (logger.isEnabledFor(Level.FATAL)) {
471 forcedLog(logger, Level.FATAL, format(pattern, arguments), t);
472 }
473 }
474
475
476
477
478
479
480
481
482
483 public static void trace(final Logger logger, final String pattern,
484 final boolean argument) {
485 if (logger.isEnabledFor(TRACE)) {
486 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
487 }
488 }
489
490
491
492
493
494
495
496 public static void trace(final Logger logger, final String pattern,
497 final char argument) {
498 if (logger.isEnabledFor(TRACE)) {
499 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
500 }
501 }
502
503
504
505
506
507
508
509 public static void trace(final Logger logger, final String pattern,
510 final byte argument) {
511 if (logger.isEnabledFor(TRACE)) {
512 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
513 }
514 }
515
516
517
518
519
520
521
522 public static void trace(final Logger logger, final String pattern,
523 final short argument) {
524 if (logger.isEnabledFor(TRACE)) {
525 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
526 }
527 }
528
529
530
531
532
533
534
535 public static void trace(final Logger logger, final String pattern,
536 final int argument) {
537 if (logger.isEnabledFor(TRACE)) {
538 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
539 }
540 }
541
542
543
544
545
546
547
548 public static void trace(final Logger logger, final String pattern,
549 final long argument) {
550 if (logger.isEnabledFor(TRACE)) {
551 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
552 }
553 }
554
555
556
557
558
559
560
561 public static void trace(final Logger logger, final String pattern,
562 final float argument) {
563 if (logger.isEnabledFor(TRACE)) {
564 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
565 }
566 }
567
568
569
570
571
572
573
574 public static void trace(final Logger logger, final String pattern,
575 final double argument) {
576 if (logger.isEnabledFor(TRACE)) {
577 forcedLog(logger, TRACE, format(pattern, valueOf(argument)));
578 }
579 }
580
581
582
583
584
585
586
587 public static void trace(final Logger logger, final String pattern,
588 final Object argument) {
589 if (logger.isEnabledFor(TRACE)) {
590 forcedLog(logger, TRACE, format(pattern, argument));
591 }
592 }
593
594
595
596
597
598
599
600
601 public static void trace(final Logger logger, final String pattern,
602 final Object arg0, final Object arg1) {
603 if (logger.isEnabledFor(TRACE)) {
604 forcedLog(logger, TRACE,
605 format(pattern, toArray(arg0, arg1)));
606 }
607 }
608
609
610
611
612
613
614
615
616
617 public static void trace(final Logger logger, final String pattern,
618 final Object arg0, final Object arg1, final Object arg2) {
619 if (logger.isEnabledFor(TRACE)) {
620 forcedLog(logger, TRACE,
621 format(pattern, toArray(arg0, arg1, arg2)));
622 }
623 }
624
625
626
627
628
629
630
631
632
633
634 public static void trace(final Logger logger, final String pattern,
635 final Object arg0, final Object arg1, final Object arg2,
636 final Object arg3) {
637 if (logger.isEnabledFor(TRACE)) {
638 forcedLog(logger, TRACE,
639 format(pattern, toArray(arg0, arg1, arg2, arg3)));
640 }
641 }
642
643
644
645
646
647
648
649 public static void debug(final Logger logger, final String pattern,
650 final boolean argument) {
651 if (logger.isDebugEnabled()) {
652 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
653 }
654 }
655
656
657
658
659
660
661
662 public static void debug(final Logger logger, final String pattern,
663 final char argument) {
664 if (logger.isDebugEnabled()) {
665 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
666 }
667 }
668
669
670
671
672
673
674
675 public static void debug(final Logger logger, final String pattern,
676 final byte argument) {
677 if (logger.isDebugEnabled()) {
678 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
679 }
680 }
681
682
683
684
685
686
687
688 public static void debug(final Logger logger, final String pattern,
689 final short argument) {
690 if (logger.isDebugEnabled()) {
691 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
692 }
693 }
694
695
696
697
698
699
700
701 public static void debug(final Logger logger, final String pattern,
702 final int argument) {
703 if (logger.isDebugEnabled()) {
704 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
705 }
706 }
707
708
709
710
711
712
713
714 public static void debug(final Logger logger, final String pattern,
715 final long argument) {
716 if (logger.isDebugEnabled()) {
717 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
718 }
719 }
720
721
722
723
724
725
726
727 public static void debug(final Logger logger, final String pattern,
728 final float argument) {
729 if (logger.isDebugEnabled()) {
730 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
731 }
732 }
733
734
735
736
737
738
739
740 public static void debug(final Logger logger, final String pattern,
741 final double argument) {
742 if (logger.isDebugEnabled()) {
743 forcedLog(logger, Level.DEBUG, format(pattern, valueOf(argument)));
744 }
745 }
746
747
748
749
750
751
752
753 public static void debug(final Logger logger, final String pattern,
754 final Object argument) {
755 if (logger.isDebugEnabled()) {
756 forcedLog(logger, Level.DEBUG, format(pattern, argument));
757 }
758 }
759
760
761
762
763
764
765
766
767 public static void debug(final Logger logger, final String pattern,
768 final Object arg0, final Object arg1) {
769 if (logger.isDebugEnabled()) {
770 forcedLog(logger, Level.DEBUG,
771 format(pattern, toArray(arg0, arg1)));
772 }
773 }
774
775
776
777
778
779
780
781
782
783 public static void debug(final Logger logger, final String pattern,
784 final Object arg0, final Object arg1, final Object arg2) {
785 if (logger.isDebugEnabled()) {
786 forcedLog(logger, Level.DEBUG,
787 format(pattern, toArray(arg0, arg1, arg2)));
788 }
789 }
790
791
792
793
794
795
796
797
798
799
800 public static void debug(final Logger logger, final String pattern,
801 final Object arg0, final Object arg1, final Object arg2,
802 final Object arg3) {
803 if (logger.isDebugEnabled()) {
804 forcedLog(logger, Level.DEBUG,
805 format(pattern, toArray(arg0, arg1, arg2, arg3)));
806 }
807 }
808
809
810
811
812
813
814
815 public static void info(final Logger logger, final String pattern,
816 final boolean argument) {
817 if (logger.isInfoEnabled()) {
818 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
819 }
820 }
821
822
823
824
825
826
827
828 public static void info(final Logger logger, final String pattern,
829 final char argument) {
830 if (logger.isInfoEnabled()) {
831 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
832 }
833 }
834
835
836
837
838
839
840
841 public static void info(final Logger logger, final String pattern,
842 final byte argument) {
843 if (logger.isInfoEnabled()) {
844 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
845 }
846 }
847
848
849
850
851
852
853
854 public static void info(final Logger logger, final String pattern,
855 final short argument) {
856 if (logger.isInfoEnabled()) {
857 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
858 }
859 }
860
861
862
863
864
865
866
867 public static void info(final Logger logger, final String pattern,
868 final int argument) {
869 if (logger.isInfoEnabled()) {
870 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
871 }
872 }
873
874
875
876
877
878
879
880 public static void info(final Logger logger, final String pattern,
881 final long argument) {
882 if (logger.isInfoEnabled()) {
883 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
884 }
885 }
886
887
888
889
890
891
892
893 public static void info(final Logger logger, final String pattern,
894 final float argument) {
895 if (logger.isInfoEnabled()) {
896 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
897 }
898 }
899
900
901
902
903
904
905
906 public static void info(final Logger logger, final String pattern,
907 final double argument) {
908 if (logger.isInfoEnabled()) {
909 forcedLog(logger, Level.INFO, format(pattern, valueOf(argument)));
910 }
911 }
912
913
914
915
916
917
918
919 public static void info(final Logger logger, final String pattern,
920 final Object argument) {
921 if (logger.isInfoEnabled()) {
922 forcedLog(logger, Level.INFO, format(pattern, argument));
923 }
924 }
925
926
927
928
929
930
931
932
933 public static void info(final Logger logger, final String pattern,
934 final Object arg0, final Object arg1) {
935 if (logger.isInfoEnabled()) {
936 forcedLog(logger, Level.INFO, format(pattern, toArray(arg0, arg1)));
937 }
938 }
939
940
941
942
943
944
945
946
947
948 public static void info(final Logger logger, final String pattern,
949 final Object arg0, final Object arg1, final Object arg2) {
950 if (logger.isInfoEnabled()) {
951 forcedLog(logger, Level.INFO, format(pattern,
952 toArray(arg0, arg1, arg2)));
953 }
954 }
955
956
957
958
959
960
961
962
963
964
965 public static void info(final Logger logger, final String pattern,
966 final Object arg0, final Object arg1, final Object arg2,
967 final Object arg3) {
968 if (logger.isInfoEnabled()) {
969 forcedLog(logger, Level.INFO, format(pattern,
970 toArray(arg0, arg1, arg2, arg3)));
971 }
972 }
973
974
975
976
977
978
979
980 public static void warn(final Logger logger, final String pattern,
981 final boolean argument) {
982 if (logger.isEnabledFor(Level.WARN)) {
983 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
984 }
985 }
986
987
988
989
990
991
992
993 public static void warn(final Logger logger, final String pattern,
994 final char argument) {
995 if (logger.isEnabledFor(Level.WARN)) {
996 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
997 }
998 }
999
1000
1001
1002
1003
1004
1005
1006 public static void warn(final Logger logger, final String pattern,
1007 final byte argument) {
1008 if (logger.isEnabledFor(Level.WARN)) {
1009 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1010 }
1011 }
1012
1013
1014
1015
1016
1017
1018
1019 public static void warn(final Logger logger, final String pattern,
1020 final short argument) {
1021 if (logger.isEnabledFor(Level.WARN)) {
1022 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1023 }
1024 }
1025
1026
1027
1028
1029
1030
1031
1032 public static void warn(final Logger logger, final String pattern,
1033 final int argument) {
1034 if (logger.isEnabledFor(Level.WARN)) {
1035 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1036 }
1037 }
1038
1039
1040
1041
1042
1043
1044
1045 public static void warn(final Logger logger, final String pattern,
1046 final long argument) {
1047 if (logger.isEnabledFor(Level.WARN)) {
1048 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1049 }
1050 }
1051
1052
1053
1054
1055
1056
1057
1058 public static void warn(final Logger logger, final String pattern,
1059 final float argument) {
1060 if (logger.isEnabledFor(Level.WARN)) {
1061 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1062 }
1063 }
1064
1065
1066
1067
1068
1069
1070
1071 public static void warn(final Logger logger, final String pattern,
1072 final double argument) {
1073 if (logger.isEnabledFor(Level.WARN)) {
1074 forcedLog(logger, Level.WARN, format(pattern, valueOf(argument)));
1075 }
1076 }
1077
1078
1079
1080
1081
1082
1083
1084 public static void warn(final Logger logger, final String pattern,
1085 final Object argument) {
1086 if (logger.isEnabledFor(Level.WARN)) {
1087 forcedLog(logger, Level.WARN, format(pattern, argument));
1088 }
1089 }
1090
1091
1092
1093
1094
1095
1096
1097
1098 public static void warn(final Logger logger, final String pattern,
1099 final Object arg0, final Object arg1) {
1100 if (logger.isEnabledFor(Level.WARN)) {
1101 forcedLog(logger, Level.WARN,
1102 format(pattern, toArray(arg0, arg1)));
1103 }
1104 }
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114 public static void warn(final Logger logger, final String pattern,
1115 final Object arg0, final Object arg1, final Object arg2) {
1116 if (logger.isEnabledFor(Level.WARN)) {
1117 forcedLog(logger, Level.WARN,
1118 format(pattern, toArray(arg0, arg1, arg2)));
1119 }
1120 }
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131 public static void warn(final Logger logger, final String pattern,
1132 final Object arg0, final Object arg1, final Object arg2,
1133 final Object arg3) {
1134 if (logger.isEnabledFor(Level.WARN)) {
1135 forcedLog(logger, Level.WARN, format(pattern,
1136 toArray(arg0, arg1, arg2, arg3)));
1137 }
1138 }
1139
1140
1141
1142
1143
1144
1145
1146
1147 public static void log(final Logger logger,
1148 final Level level,
1149 final String pattern,
1150 final Object[] parameters) {
1151 if (logger.isEnabledFor(level)) {
1152 forcedLog(logger, level,
1153 format(pattern, parameters));
1154 }
1155 }
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165 public static void log(final Logger logger,
1166 final Level level,
1167 final Throwable t,
1168 final String pattern,
1169 final Object[] parameters) {
1170 if (logger.isEnabledFor(level)) {
1171 forcedLog(logger, level,
1172 format(pattern, parameters), t);
1173 }
1174 }
1175
1176
1177
1178
1179
1180
1181
1182
1183 public static void log(final Logger logger,
1184 final Level level,
1185 final String pattern,
1186 final Object param1) {
1187 if (logger.isEnabledFor(level)) {
1188 forcedLog(logger, level,
1189 format(pattern, toArray(param1)));
1190 }
1191 }
1192
1193
1194
1195
1196
1197
1198
1199
1200 public static void log(final Logger logger,
1201 final Level level,
1202 final String pattern,
1203 final boolean param1) {
1204 if (logger.isEnabledFor(level)) {
1205 forcedLog(logger, level,
1206 format(pattern, toArray(valueOf(param1))));
1207 }
1208 }
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218 public static void log(final Logger logger,
1219 final Level level,
1220 final String pattern,
1221 final byte param1) {
1222 if (logger.isEnabledFor(level)) {
1223 forcedLog(logger, level,
1224 format(pattern, toArray(valueOf(param1))));
1225 }
1226 }
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236 public static void log(final Logger logger,
1237 final Level level,
1238 final String pattern,
1239 final char param1) {
1240 if (logger.isEnabledFor(level)) {
1241 forcedLog(logger, level,
1242 format(pattern, toArray(valueOf(param1))));
1243 }
1244 }
1245
1246
1247
1248
1249
1250
1251
1252
1253 public static void log(final Logger logger,
1254 final Level level,
1255 final String pattern,
1256 final short param1) {
1257 if (logger.isEnabledFor(level)) {
1258 forcedLog(logger, level,
1259 format(pattern, toArray(valueOf(param1))));
1260 }
1261 }
1262
1263
1264
1265
1266
1267
1268
1269
1270 public static void log(final Logger logger,
1271 final Level level,
1272 final String pattern,
1273 final int param1) {
1274 if (logger.isEnabledFor(level)) {
1275 forcedLog(logger, level,
1276 format(pattern, toArray(valueOf(param1))));
1277 }
1278 }
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288 public static void log(final Logger logger,
1289 final Level level,
1290 final String pattern,
1291 final long param1) {
1292 if (logger.isEnabledFor(level)) {
1293 forcedLog(logger, level,
1294 format(pattern, toArray(valueOf(param1))));
1295 }
1296 }
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306 public static void log(final Logger logger,
1307 final Level level,
1308 final String pattern,
1309 final float param1) {
1310 if (logger.isEnabledFor(level)) {
1311 forcedLog(logger, level,
1312 format(pattern, toArray(valueOf(param1))));
1313 }
1314 }
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324 public static void log(final Logger logger,
1325 final Level level,
1326 final String pattern,
1327 final double param1) {
1328 if (logger.isEnabledFor(level)) {
1329 forcedLog(logger, level,
1330 format(pattern, toArray(valueOf(param1))));
1331 }
1332 }
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343 public static void log(final Logger logger,
1344 final Level level,
1345 final String pattern,
1346 final Object arg0, final Object arg1) {
1347 if (logger.isEnabledFor(level)) {
1348 forcedLog(logger, level,
1349 format(pattern, toArray(arg0, arg1)));
1350 }
1351 }
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362 public static void log(final Logger logger,
1363 final Level level,
1364 final String pattern,
1365 final Object arg0, final Object arg1, final Object arg2) {
1366 if (logger.isEnabledFor(level)) {
1367 forcedLog(logger, level,
1368 format(pattern, toArray(arg0, arg1, arg2)));
1369 }
1370 }
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382 public static void log(final Logger logger,
1383 final Level level,
1384 final String pattern,
1385 final Object arg0, final Object arg1, final Object arg2,
1386 final Object arg3) {
1387 if (logger.isEnabledFor(level)) {
1388 forcedLog(logger, level, format(pattern,
1389 toArray(arg0, arg1, arg2, arg3)));
1390 }
1391 }
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402 public static void logrb(final Logger logger,
1403 final Level level,
1404 final String bundleName,
1405 final String key,
1406 final Object[] parameters) {
1407 if (logger.isEnabledFor(level)) {
1408 forcedLog(logger, level,
1409 format(bundleName, key, parameters));
1410 }
1411 }
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422 public static void logrb(final Logger logger,
1423 final Level level,
1424 final Throwable t,
1425 final String bundleName,
1426 final String key,
1427 final Object[] parameters) {
1428 if (logger.isEnabledFor(level)) {
1429 forcedLog(logger, level,
1430 format(bundleName, key, parameters), t);
1431 }
1432 }
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442 public static void logrb(final Logger logger,
1443 final Level level,
1444 final String bundleName,
1445 final String key,
1446 final Object param1) {
1447 if (logger.isEnabledFor(level)) {
1448 forcedLog(logger, level,
1449 format(bundleName, key, toArray(param1)));
1450 }
1451 }
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461 public static void logrb(final Logger logger,
1462 final Level level,
1463 final String bundleName,
1464 final String key,
1465 final boolean param1) {
1466 if (logger.isEnabledFor(level)) {
1467 forcedLog(logger, level,
1468 format(bundleName, key, toArray(valueOf(param1))));
1469 }
1470 }
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480 public static void logrb(final Logger logger,
1481 final Level level,
1482 final String bundleName,
1483 final String key,
1484 final char param1) {
1485 if (logger.isEnabledFor(level)) {
1486 forcedLog(logger, level,
1487 format(bundleName, key, toArray(valueOf(param1))));
1488 }
1489 }
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499 public static void logrb(final Logger logger,
1500 final Level level,
1501 final String bundleName,
1502 final String key,
1503 final byte param1) {
1504 if (logger.isEnabledFor(level)) {
1505 forcedLog(logger, level,
1506 format(bundleName, key, toArray(valueOf(param1))));
1507 }
1508 }
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518 public static void logrb(final Logger logger,
1519 final Level level,
1520 final String bundleName,
1521 final String key,
1522 final short param1) {
1523 if (logger.isEnabledFor(level)) {
1524 forcedLog(logger, level,
1525 format(bundleName, key, toArray(valueOf(param1))));
1526 }
1527 }
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537 public static void logrb(final Logger logger,
1538 final Level level,
1539 final String bundleName,
1540 final String key,
1541 final int param1) {
1542 if (logger.isEnabledFor(level)) {
1543 forcedLog(logger, level,
1544 format(bundleName, key, toArray(valueOf(param1))));
1545 }
1546 }
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556 public static void logrb(final Logger logger,
1557 final Level level,
1558 final String bundleName,
1559 final String key,
1560 final long param1) {
1561 if (logger.isEnabledFor(level)) {
1562 forcedLog(logger, level,
1563 format(bundleName, key, toArray(valueOf(param1))));
1564 }
1565 }
1566
1567
1568
1569
1570
1571
1572
1573
1574 public static void logrb(final Logger logger,
1575 final Level level,
1576 final String bundleName,
1577 final String key,
1578 final float param1) {
1579 if (logger.isEnabledFor(level)) {
1580 forcedLog(logger, level,
1581 format(bundleName, key, toArray(valueOf(param1))));
1582 }
1583 }
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594 public static void logrb(final Logger logger,
1595 final Level level,
1596 final String bundleName,
1597 final String key,
1598 final double param1) {
1599 if (logger.isEnabledFor(level)) {
1600 forcedLog(logger, level,
1601 format(bundleName, key, toArray(valueOf(param1))));
1602 }
1603 }
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614 public static void logrb(final Logger logger,
1615 final Level level,
1616 final String bundleName,
1617 final String key,
1618 final Object param0,
1619 final Object param1) {
1620 if (logger.isEnabledFor(level)) {
1621 forcedLog(logger, level,
1622 format(bundleName, key, toArray(param0, param1)));
1623 }
1624 }
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637 public static void logrb(final Logger logger,
1638 final Level level,
1639 final String bundleName,
1640 final String key,
1641 final Object param0,
1642 final Object param1,
1643 final Object param2) {
1644 if (logger.isEnabledFor(level)) {
1645 forcedLog(logger, level,
1646 format(bundleName, key, toArray(param0, param1, param2)));
1647 }
1648 }
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662 public static void logrb(final Logger logger,
1663 final Level level,
1664 final String bundleName,
1665 final String key,
1666 final Object param0,
1667 final Object param1,
1668 final Object param2,
1669 final Object param3) {
1670 if (logger.isEnabledFor(level)) {
1671 forcedLog(logger, level,
1672 format(bundleName, key,
1673 toArray(param0, param1, param2, param3)));
1674 }
1675 }
1676
1677 }