1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.logging.log4j.core.util;
18
19 import java.util.Locale;
20 import java.util.Properties;
21
22 import org.apache.logging.log4j.Logger;
23 import org.apache.logging.log4j.status.StatusLogger;
24 import org.apache.logging.log4j.util.PropertiesUtil;
25
26
27
28
29 public final class OptionConverter {
30
31 private static final Logger LOGGER = StatusLogger.getLogger();
32
33 private static final String DELIM_START = "${";
34 private static final char DELIM_STOP = '}';
35 private static final int DELIM_START_LEN = 2;
36 private static final int DELIM_STOP_LEN = 1;
37 private static final int ONE_K = 1024;
38
39
40
41
42 private OptionConverter() {
43 }
44
45 public static String[] concatenateArrays(final String[] l, final String[] r) {
46 final int len = l.length + r.length;
47 final String[] a = new String[len];
48
49 System.arraycopy(l, 0, a, 0, l.length);
50 System.arraycopy(r, 0, a, l.length, r.length);
51
52 return a;
53 }
54
55 public static String convertSpecialChars(final String s) {
56 char c;
57 final int len = s.length();
58 final StringBuilder sbuf = new StringBuilder(len);
59
60 int i = 0;
61 while (i < len) {
62 c = s.charAt(i++);
63 if (c == '\\') {
64 c = s.charAt(i++);
65 if (c == 'n') {
66 c = '\n';
67 } else if (c == 'r') {
68 c = '\r';
69 } else if (c == 't') {
70 c = '\t';
71 } else if (c == 'f') {
72 c = '\f';
73 } else if (c == '\b') {
74 c = '\b';
75 } else if (c == '\"') {
76 c = '\"';
77 } else if (c == '\'') {
78 c = '\'';
79 } else if (c == '\\') {
80 c = '\\';
81 }
82 }
83 sbuf.append(c);
84 }
85 return sbuf.toString();
86 }
87
88 public static Object instantiateByKey(final Properties props, final String key, final Class<?> superClass,
89 final Object defaultValue) {
90
91
92 final String className = findAndSubst(key, props);
93 if (className == null) {
94 LOGGER.error("Could not find value for key {}", key);
95 return defaultValue;
96 }
97
98 return OptionConverter.instantiateByClassName(className.trim(), superClass,
99 defaultValue);
100 }
101
102
103
104
105
106
107
108
109
110
111
112
113 public static boolean toBoolean(final String value, final boolean defaultValue) {
114 if (value == null) {
115 return defaultValue;
116 }
117 final String trimmedVal = value.trim();
118 if ("true".equalsIgnoreCase(trimmedVal)) {
119 return true;
120 }
121 if ("false".equalsIgnoreCase(trimmedVal)) {
122 return false;
123 }
124 return defaultValue;
125 }
126
127
128
129
130
131
132
133 public static int toInt(final String value, final int defaultValue) {
134 if (value != null) {
135 final String s = value.trim();
136 try {
137 return Integer.parseInt(s);
138 } catch (final NumberFormatException e) {
139 LOGGER.error("[{}] is not in proper int form.", s, e);
140 }
141 }
142 return defaultValue;
143 }
144
145
146
147
148
149
150
151 public static long toFileSize(final String value, final long defaultValue) {
152 if (value == null) {
153 return defaultValue;
154 }
155
156 String str = value.trim().toUpperCase(Locale.ENGLISH);
157 long multiplier = 1;
158 int index;
159
160 if ((index = str.indexOf("KB")) != -1) {
161 multiplier = ONE_K;
162 str = str.substring(0, index);
163 } else if ((index = str.indexOf("MB")) != -1) {
164 multiplier = ONE_K * ONE_K;
165 str = str.substring(0, index);
166 } else if ((index = str.indexOf("GB")) != -1) {
167 multiplier = ONE_K * ONE_K * ONE_K;
168 str = str.substring(0, index);
169 }
170 if (str != null) {
171 try {
172 return Long.parseLong(str) * multiplier;
173 } catch (final NumberFormatException e) {
174 LOGGER.error("[{}] is not in proper int form.", str);
175 LOGGER.error("[{}] not in expected format.", value, e);
176 }
177 }
178 return defaultValue;
179 }
180
181
182
183
184
185
186
187
188
189 public static String findAndSubst(final String key, final Properties props) {
190 final String value = props.getProperty(key);
191 if (value == null) {
192 return null;
193 }
194
195 try {
196 return substVars(value, props);
197 } catch (final IllegalArgumentException e) {
198 LOGGER.error("Bad option value [{}].", value, e);
199 return value;
200 }
201 }
202
203
204
205
206
207
208
209
210
211
212
213
214 public static Object instantiateByClassName(final String className, final Class<?> superClass,
215 final Object defaultValue) {
216 if (className != null) {
217 try {
218 final Class<?> classObj = Loader.loadClass(className);
219 if (!superClass.isAssignableFrom(classObj)) {
220 LOGGER.error("A \"{}\" object is not assignable to a \"{}\" variable.", className,
221 superClass.getName());
222 LOGGER.error("The class \"{}\" was loaded by [{}] whereas object of type [{}] was loaded by [{}].",
223 superClass.getName(), superClass.getClassLoader(), classObj.getName());
224 return defaultValue;
225 }
226 return classObj.newInstance();
227 } catch (final Exception e) {
228 LOGGER.error("Could not instantiate class [{}].", className, e);
229 }
230 }
231 return defaultValue;
232 }
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271 public static String substVars(final String val, final Properties props) throws
272 IllegalArgumentException {
273
274 final StringBuilder sbuf = new StringBuilder();
275
276 int i = 0;
277 int j;
278 int k;
279
280 while (true) {
281 j = val.indexOf(DELIM_START, i);
282 if (j == -1) {
283
284 if (i == 0) {
285 return val;
286 }
287
288 sbuf.append(val.substring(i, val.length()));
289 return sbuf.toString();
290 }
291 sbuf.append(val.substring(i, j));
292 k = val.indexOf(DELIM_STOP, j);
293 if (k == -1) {
294 throw new IllegalArgumentException('"' + val +
295 "\" has no closing brace. Opening brace at position " + j
296 + '.');
297 }
298 j += DELIM_START_LEN;
299 final String key = val.substring(j, k);
300
301 String replacement = PropertiesUtil.getProperties().getStringProperty(key, null);
302
303 if (replacement == null && props != null) {
304 replacement = props.getProperty(key);
305 }
306
307 if (replacement != null) {
308
309
310
311
312
313 final String recursiveReplacement = substVars(replacement, props);
314 sbuf.append(recursiveReplacement);
315 }
316 i = k + DELIM_STOP_LEN;
317 }
318 }
319 }