1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.myfaces.config;
20
21 import java.util.ArrayList;
22 import java.util.Collection;
23 import java.util.Collections;
24 import java.util.Comparator;
25 import java.util.HashMap;
26 import java.util.List;
27 import java.util.Map;
28 import java.util.concurrent.ConcurrentHashMap;
29
30 import javax.el.ELResolver;
31 import javax.el.ExpressionFactory;
32 import javax.faces.context.ExternalContext;
33 import javax.faces.el.PropertyResolver;
34 import javax.faces.el.VariableResolver;
35
36 import org.apache.commons.logging.Log;
37 import org.apache.commons.logging.LogFactory;
38 import org.apache.myfaces.config.element.ManagedBean;
39 import org.apache.myfaces.config.element.NavigationRule;
40 import org.apache.myfaces.config.impl.digester.elements.ResourceBundle;
41
42
43
44
45
46
47
48
49
50 @SuppressWarnings("deprecation")
51 public class RuntimeConfig
52 {
53 private static final Log log = LogFactory.getLog(RuntimeConfig.class);
54
55 private static final String APPLICATION_MAP_PARAM_NAME = RuntimeConfig.class.getName();
56
57 private final Collection<NavigationRule> _navigationRules = new ArrayList<NavigationRule>();
58 private final Map<String, ManagedBean> _managedBeans = new HashMap<String, ManagedBean>();
59 private boolean _navigationRulesChanged = false;
60 private final Map<String, ResourceBundle> _resourceBundles = new HashMap<String, ResourceBundle>();
61 private final Map<String, ManagedBean> _oldManagedBeans = new HashMap<String, ManagedBean>();
62
63 private List<ELResolver> facesConfigElResolvers;
64 private List<ELResolver> applicationElResolvers;
65
66 private VariableResolver _variableResolver;
67 private PropertyResolver _propertyResolver;
68
69 private ExpressionFactory _expressionFactory;
70
71 private PropertyResolver _propertyResolverChainHead;
72
73 private VariableResolver _variableResolverChainHead;
74
75 private Comparator<ELResolver> _elResolverComparator;
76
77 private final Map<String, org.apache.myfaces.config.impl.digester.elements.Converter> _converterClassNameToConfigurationMap =
78 new ConcurrentHashMap<String, org.apache.myfaces.config.impl.digester.elements.Converter>();
79
80 public static RuntimeConfig getCurrentInstance(ExternalContext externalContext)
81 {
82 RuntimeConfig runtimeConfig = (RuntimeConfig) externalContext.getApplicationMap().get(
83 APPLICATION_MAP_PARAM_NAME);
84 if (runtimeConfig == null)
85 {
86 runtimeConfig = new RuntimeConfig();
87 externalContext.getApplicationMap().put(APPLICATION_MAP_PARAM_NAME, runtimeConfig);
88 }
89 return runtimeConfig;
90 }
91
92 public void purge()
93 {
94 _navigationRules.clear();
95 _oldManagedBeans.clear();
96 _oldManagedBeans.putAll(_managedBeans);
97 _managedBeans.clear();
98 _navigationRulesChanged = false;
99 _converterClassNameToConfigurationMap.clear();
100 }
101
102
103
104
105
106
107 public Collection<NavigationRule> getNavigationRules()
108 {
109 return Collections.unmodifiableCollection(_navigationRules);
110 }
111
112 public void addNavigationRule(NavigationRule navigationRule)
113 {
114 _navigationRules.add(navigationRule);
115
116 _navigationRulesChanged = true;
117 }
118
119 public boolean isNavigationRulesChanged()
120 {
121 return _navigationRulesChanged;
122 }
123
124 public void setNavigationRulesChanged(boolean navigationRulesChanged)
125 {
126 _navigationRulesChanged = navigationRulesChanged;
127 }
128
129
130
131
132
133
134 public ManagedBean getManagedBean(String name)
135 {
136 return _managedBeans.get(name);
137 }
138
139 public Map<String, ManagedBean> getManagedBeans()
140 {
141 return Collections.unmodifiableMap(_managedBeans);
142 }
143
144 public void addManagedBean(String name, ManagedBean managedBean)
145 {
146 _managedBeans.put(name, managedBean);
147 if(_oldManagedBeans!=null)
148 _oldManagedBeans.remove(name);
149 }
150
151
152 public final void addConverterConfiguration(final String converterClassName,
153 final org.apache.myfaces.config.impl.digester.elements.Converter configuration)
154 {
155 checkNull(converterClassName, "converterClassName");
156 checkEmpty(converterClassName, "converterClassName");
157 checkNull(configuration, "configuration");
158
159 _converterClassNameToConfigurationMap.put(converterClassName, configuration);
160 }
161
162 public org.apache.myfaces.config.impl.digester.elements.Converter getConverterConfiguration(String converterClassName)
163 {
164 return (org.apache.myfaces.config.impl.digester.elements.Converter)_converterClassNameToConfigurationMap.get(converterClassName);
165 }
166
167 private void checkNull(final Object param, final String paramName)
168 {
169 if (param == null)
170 {
171 throw new NullPointerException(paramName + " can not be null.");
172 }
173 }
174
175 private void checkEmpty(final String param, final String paramName)
176 {
177 if (param.length() == 0)
178 {
179 throw new NullPointerException("String " + paramName + " can not be empty.");
180 }
181 }
182
183
184
185
186
187
188
189
190 public ResourceBundle getResourceBundle(String name)
191 {
192 return _resourceBundles.get(name);
193 }
194
195
196
197
198 public Map<String, ResourceBundle> getResourceBundles()
199 {
200 return _resourceBundles;
201 }
202
203 public void addResourceBundle(ResourceBundle bundle)
204 {
205 if (bundle == null)
206 {
207 throw new IllegalArgumentException("bundle must not be null");
208 }
209 String var = bundle.getVar();
210 if (_resourceBundles.containsKey(var) && log.isWarnEnabled())
211 {
212 log.warn("Another resource bundle for var '" + var + "' with base name '"
213 + _resourceBundles.get(var).getBaseName() + "' is already registered. '"
214 + _resourceBundles.get(var).getBaseName() + "' will be replaced with '" + bundle.getBaseName()
215 + "'.");
216 }
217 _resourceBundles.put(var, bundle);
218 }
219
220 public void addFacesConfigElResolver(ELResolver resolver)
221 {
222 if (facesConfigElResolvers == null)
223 {
224 facesConfigElResolvers = new ArrayList<ELResolver>();
225 }
226 facesConfigElResolvers.add(resolver);
227 }
228
229 public List<ELResolver> getFacesConfigElResolvers()
230 {
231 return facesConfigElResolvers;
232 }
233
234 public void addApplicationElResolver(ELResolver resolver)
235 {
236 if (applicationElResolvers == null)
237 {
238 applicationElResolvers = new ArrayList<ELResolver>();
239 }
240 applicationElResolvers.add(resolver);
241 }
242
243 public List<ELResolver> getApplicationElResolvers()
244 {
245 return applicationElResolvers;
246 }
247
248 public void setVariableResolver(VariableResolver variableResolver)
249 {
250 _variableResolver = variableResolver;
251 }
252
253 public VariableResolver getVariableResolver()
254 {
255 return _variableResolver;
256 }
257
258 public void setPropertyResolver(PropertyResolver propertyResolver)
259 {
260 _propertyResolver = propertyResolver;
261 }
262
263 public PropertyResolver getPropertyResolver()
264 {
265 return _propertyResolver;
266 }
267
268 public ExpressionFactory getExpressionFactory()
269 {
270 return _expressionFactory;
271 }
272
273 public void setExpressionFactory(ExpressionFactory expressionFactory)
274 {
275 _expressionFactory = expressionFactory;
276 }
277
278 public void setPropertyResolverChainHead(PropertyResolver resolver)
279 {
280 _propertyResolverChainHead = resolver;
281 }
282
283 public PropertyResolver getPropertyResolverChainHead()
284 {
285 return _propertyResolverChainHead;
286 }
287
288 public void setVariableResolverChainHead(VariableResolver resolver)
289 {
290 _variableResolverChainHead = resolver;
291 }
292
293 public VariableResolver getVariableResolverChainHead()
294 {
295 return _variableResolverChainHead;
296 }
297
298 public Map getManagedBeansNotReaddedAfterPurge()
299 {
300 return _oldManagedBeans;
301 }
302
303 public void resetManagedBeansNotReaddedAfterPurge()
304 {
305 _oldManagedBeans.clear();
306 }
307
308 public Comparator<ELResolver> getELResolverComparator()
309 {
310 return _elResolverComparator;
311 }
312
313 public void setELResolverComparator(Comparator<ELResolver> elResolverComparator)
314 {
315 _elResolverComparator = elResolverComparator;
316 }
317 }