1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.logging.log4j.core.config.plugins.convert;
19
20 import java.io.File;
21 import java.math.BigDecimal;
22 import java.math.BigInteger;
23 import java.net.MalformedURLException;
24 import java.net.URI;
25 import java.net.URISyntaxException;
26 import java.net.URL;
27 import java.nio.charset.Charset;
28 import java.security.Provider;
29 import java.security.Security;
30 import java.util.regex.Pattern;
31
32 import javax.xml.bind.DatatypeConverter;
33
34 import org.apache.logging.log4j.Level;
35 import org.apache.logging.log4j.Logger;
36 import org.apache.logging.log4j.core.appender.rolling.action.Duration;
37 import org.apache.logging.log4j.core.config.plugins.Plugin;
38 import org.apache.logging.log4j.core.util.CronExpression;
39 import org.apache.logging.log4j.core.util.Loader;
40 import org.apache.logging.log4j.status.StatusLogger;
41
42
43
44
45
46
47
48 public final class TypeConverters {
49
50
51
52
53
54
55 public static final String CATEGORY = "TypeConverter";
56
57
58
59
60 @Plugin(name = "BigDecimal", category = CATEGORY)
61 public static class BigDecimalConverter implements TypeConverter<BigDecimal> {
62 @Override
63 public BigDecimal convert(final String s) {
64 return new BigDecimal(s);
65 }
66 }
67
68
69
70
71 @Plugin(name = "BigInteger", category = CATEGORY)
72 public static class BigIntegerConverter implements TypeConverter<BigInteger> {
73 @Override
74 public BigInteger convert(final String s) {
75 return new BigInteger(s);
76 }
77 }
78
79
80
81
82 @Plugin(name = "Boolean", category = CATEGORY)
83 public static class BooleanConverter implements TypeConverter<Boolean> {
84 @Override
85 public Boolean convert(final String s) {
86 return Boolean.valueOf(s);
87 }
88 }
89
90
91
92
93
94
95
96
97
98
99
100 @Plugin(name = "ByteArray", category = CATEGORY)
101 public static class ByteArrayConverter implements TypeConverter<byte[]> {
102
103 private static final String PREFIX_0x = "0x";
104 private static final String PREFIX_BASE64 = "Base64:";
105
106 @Override
107 public byte[] convert(final String value) {
108 byte[] bytes;
109 if (value == null || value.isEmpty()) {
110 bytes = new byte[0];
111 } else if (value.startsWith(PREFIX_BASE64)) {
112 final String lexicalXSDBase64Binary = value.substring(PREFIX_BASE64.length());
113 bytes = DatatypeConverter.parseBase64Binary(lexicalXSDBase64Binary);
114 } else if (value.startsWith(PREFIX_0x)) {
115 final String lexicalXSDHexBinary = value.substring(PREFIX_0x.length());
116 bytes = DatatypeConverter.parseHexBinary(lexicalXSDHexBinary);
117 } else {
118 bytes = value.getBytes(Charset.defaultCharset());
119 }
120 return bytes;
121 }
122 }
123
124
125
126
127 @Plugin(name = "Byte", category = CATEGORY)
128 public static class ByteConverter implements TypeConverter<Byte> {
129 @Override
130 public Byte convert(final String s) {
131 return Byte.valueOf(s);
132 }
133 }
134
135
136
137
138 @Plugin(name = "Character", category = CATEGORY)
139 public static class CharacterConverter implements TypeConverter<Character> {
140 @Override
141 public Character convert(final String s) {
142 if (s.length() != 1) {
143 throw new IllegalArgumentException("Character string must be of length 1: " + s);
144 }
145 return Character.valueOf(s.toCharArray()[0]);
146 }
147 }
148
149
150
151
152 @Plugin(name = "CharacterArray", category = CATEGORY)
153 public static class CharArrayConverter implements TypeConverter<char[]> {
154 @Override
155 public char[] convert(final String s) {
156 return s.toCharArray();
157 }
158 }
159
160
161
162
163 @Plugin(name = "Charset", category = CATEGORY)
164 public static class CharsetConverter implements TypeConverter<Charset> {
165 @Override
166 public Charset convert(final String s) {
167 return Charset.forName(s);
168 }
169 }
170
171
172
173
174 @Plugin(name = "Class", category = CATEGORY)
175 public static class ClassConverter implements TypeConverter<Class<?>> {
176 @Override
177 public Class<?> convert(final String s) throws ClassNotFoundException {
178 return Loader.loadClass(s);
179 }
180 }
181
182 @Plugin(name = "CronExpression", category = CATEGORY)
183 public static class CronExpressionConverter implements TypeConverter<CronExpression> {
184 @Override
185 public CronExpression convert(final String s) throws Exception {
186 return new CronExpression(s);
187 }
188 }
189
190
191
192
193 @Plugin(name = "Double", category = CATEGORY)
194 public static class DoubleConverter implements TypeConverter<Double> {
195 @Override
196 public Double convert(final String s) {
197 return Double.valueOf(s);
198 }
199 }
200
201
202
203
204
205 @Plugin(name = "Duration", category = CATEGORY)
206 public static class DurationConverter implements TypeConverter<Duration> {
207 @Override
208 public Duration convert(final String s) {
209 return Duration.parse(s);
210 }
211 }
212
213
214
215
216 @Plugin(name = "File", category = CATEGORY)
217 public static class FileConverter implements TypeConverter<File> {
218 @Override
219 public File convert(final String s) {
220 return new File(s);
221 }
222 }
223
224
225
226
227 @Plugin(name = "Float", category = CATEGORY)
228 public static class FloatConverter implements TypeConverter<Float> {
229 @Override
230 public Float convert(final String s) {
231 return Float.valueOf(s);
232 }
233 }
234
235
236
237
238 @Plugin(name = "Integer", category = CATEGORY)
239 public static class IntegerConverter implements TypeConverter<Integer> {
240 @Override
241 public Integer convert(final String s) {
242 return Integer.valueOf(s);
243 }
244 }
245
246
247
248
249 @Plugin(name = "Level", category = CATEGORY)
250 public static class LevelConverter implements TypeConverter<Level> {
251 @Override
252 public Level convert(final String s) {
253 return Level.valueOf(s);
254 }
255 }
256
257
258
259
260 @Plugin(name = "Long", category = CATEGORY)
261 public static class LongConverter implements TypeConverter<Long> {
262 @Override
263 public Long convert(final String s) {
264 return Long.valueOf(s);
265 }
266 }
267
268
269
270
271 @Plugin(name = "Pattern", category = CATEGORY)
272 public static class PatternConverter implements TypeConverter<Pattern> {
273 @Override
274 public Pattern convert(final String s) {
275 return Pattern.compile(s);
276 }
277 }
278
279
280
281
282 @Plugin(name = "SecurityProvider", category = CATEGORY)
283 public static class SecurityProviderConverter implements TypeConverter<Provider> {
284 @Override
285 public Provider convert(final String s) {
286 return Security.getProvider(s);
287 }
288 }
289
290
291
292
293 @Plugin(name = "Short", category = CATEGORY)
294 public static class ShortConverter implements TypeConverter<Short> {
295 @Override
296 public Short convert(final String s) {
297 return Short.valueOf(s);
298 }
299 }
300
301
302
303
304 @Plugin(name = "String", category = CATEGORY)
305 public static class StringConverter implements TypeConverter<String> {
306 @Override
307 public String convert(final String s) {
308 return s;
309 }
310 }
311
312
313
314
315 @Plugin(name = "URI", category = CATEGORY)
316 public static class UriConverter implements TypeConverter<URI> {
317 @Override
318 public URI convert(final String s) throws URISyntaxException {
319 return new URI(s);
320 }
321 }
322
323
324
325
326 @Plugin(name = "URL", category = CATEGORY)
327 public static class UrlConverter implements TypeConverter<URL> {
328 @Override
329 public URL convert(final String s) throws MalformedURLException {
330 return new URL(s);
331 }
332 }
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351 public static Object convert(final String s, final Class<?> clazz, final Object defaultValue) {
352 final TypeConverter<?> converter = TypeConverterRegistry.getInstance().findCompatibleConverter(clazz);
353 if (s == null) {
354
355
356 return parseDefaultValue(converter, defaultValue);
357 }
358 try {
359 return converter.convert(s);
360 } catch (final Exception e) {
361 LOGGER.warn("Error while converting string [{}] to type [{}]. Using default value [{}].", s, clazz,
362 defaultValue, e);
363 return parseDefaultValue(converter, defaultValue);
364 }
365 }
366
367 private static Object parseDefaultValue(final TypeConverter<?> converter, final Object defaultValue) {
368 if (defaultValue == null) {
369 return null;
370 }
371 if (!(defaultValue instanceof String)) {
372 return defaultValue;
373 }
374 try {
375 return converter.convert((String) defaultValue);
376 } catch (final Exception e) {
377 LOGGER.debug("Can't parse default value [{}] for type [{}].", defaultValue, converter.getClass(), e);
378 return null;
379 }
380 }
381
382 private static final Logger LOGGER = StatusLogger.getLogger();
383
384 }