1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
package org.workingfrog.i18n.util;
import java.util.HashSet;
import java.util.Set;
public class LogLevel {
/** logs.
* levels :
* - NONE : no output,
* - L10N : find missing keys for current language,
* - I18N : locate objects without i18n behavior,
* - NAMING : identify mispelled keys or values hard coded in objects,
* - ALL : all previous levels, less NONE ;-})
*
* combinations of levels L10N, I18N and NAMING :
* - IL : I18N + L10N,
* - IN : I18N + NAMING,
* - LN : L10N + NAMING,
* - LIN <=> ALL (not provided, ALL more efficient)
*/
public static final LogLevel NONE = new LogLevel("NONE");
public static final LogLevel L10N = new LogLevel("L10N");
public static final LogLevel I18N = new LogLevel("I18N");
public static final LogLevel NAMING = new LogLevel("NAMING");
public static final LogLevel IL = new LogLevel("IL");
public static final LogLevel IN = new LogLevel("IN");
public static final LogLevel LN = new LogLevel("LN");
public static final LogLevel ALL = new LogLevel("ALL");
/** LogLevel used in project */
private static LogLevel current = NONE;
/** used in comparison with current LogLevel */
private static Set defaults = new HashSet();
static {
defaults.add(NONE);
defaults.add(L10N);
defaults.add(I18N);
defaults.add(NAMING);
defaults.add(ALL);
}
/** instance name */
private final String name;
private LogLevel (String name) { this.name = name; }
private static boolean compare (LogLevel level, LogLevel combination) {
if (IL.equals(combination)) {
return level.equals(I18N) || level.equals(L10N);
} else if (IN.equals(combination)) {
return level.equals(I18N) || level.equals(NAMING);
} else {
return level.equals(L10N) || level.equals(NAMING);
}
}
private static boolean bothAreLevels (LogLevel current, LogLevel level) {
return defaults.contains(current) && defaults.contains(level);
}
private static boolean bothAreCombinations
(LogLevel current, LogLevel level) {
return !defaults.contains(current) && !defaults.contains(level);
}
public static void setCurrent (LogLevel level) {
current = level;
}
public static void setCurrent (String level) {
String ucLevel = level.toUpperCase();
if (NONE.toString().equals(ucLevel)) {
setCurrent(NONE);
} else if (L10N.toString().equals(ucLevel)) {
setCurrent(L10N);
} else if (I18N.toString().equals(ucLevel)) {
setCurrent(I18N);
} else if (NAMING.toString().equals(ucLevel)) {
setCurrent(NAMING);
} else if (ALL.toString().equals(ucLevel)) {
setCurrent(ALL);
} else if (IL.toString().equals(ucLevel)) {
setCurrent(IL);
} else if (IN.toString().equals(ucLevel)) {
setCurrent(IN);
} else if (LN.toString().equals(ucLevel)) {
setCurrent(LN);
} else {
throw new IllegalArgumentException("\"" + level + "\" is not a "
+ "valid i18n level");
}
}
public static boolean isChecking (LogLevel level) {
if (current.equals(ALL)) {
return true;
}
if (bothAreLevels(current, level)) {
return current.equals(level);
} else if (bothAreCombinations(current, level)) {
if (current.equals(IL)) {
return level.toString().indexOf('I') != -1
|| level.toString().indexOf('L') != -1;
} else if (current.equals(IN)) {
return level.toString().indexOf('I') != -1
|| level.toString().indexOf('N') != -1;
} else {
return level.toString().indexOf('L') != -1
|| level.toString().indexOf('N') != -1;
}
} else if (defaults.contains(current)) {
return compare(current, level);
} else {
return compare(level, current);
}
}
public String toString () { return name; }
public static void main (String[] args) {
System.out.println("testing NONE");
LogLevel.setCurrent(NONE);
System.out.println("checking ALL ? " + LogLevel.isChecking(ALL));
System.out.println("checking I18N ? " + LogLevel.isChecking(I18N));
System.out.println("checking NONE ? " + LogLevel.isChecking(NONE));
System.out.println("\ntesting IN");
LogLevel.setCurrent(IN);
System.out.println("checking ALL ? " + LogLevel.isChecking(ALL));
System.out.println("checking L10N ? " + LogLevel.isChecking(L10N));
System.out.println("checking NAMING ? " + LogLevel.isChecking(NAMING));
System.out.println("checking I18N ? " + LogLevel.isChecking(I18N));
}
}
|
