Coverage Report

Coverage Report - org.apache.myfaces.shared_impl.taglib.UIComponentELTagUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

UIComponentELTagUtils

0/95

0/70

3.158

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you under the Apache License, Version 2.0 (the
  *  "License"); you may not use this file except in compliance
  *  with the License.  You may obtain a copy of the License at
  * 
  *  http://www.apache.org/licenses/LICENSE-2.0
  * 
  *  Unless required by applicable law or agreed to in writing,
  *  software distributed under the License is distributed on an
  *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *  KIND, either express or implied.  See the License for the
  *  specific language governing permissions and limitations
  *  under the License.
  */
 package org.apache.myfaces.shared_impl.taglib;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import javax.el.ELContext;
 import javax.el.MethodExpression;
 import javax.el.ValueExpression;
 import javax.faces.component.ActionSource2;
 import javax.faces.component.EditableValueHolder;
 import javax.faces.component.UICommand;
 import javax.faces.component.UIComponent;
 import javax.faces.component.UIGraphic;
 import javax.faces.component.UIParameter;
 import javax.faces.component.UISelectBoolean;
 import javax.faces.component.ValueHolder;
 import javax.faces.context.FacesContext;
 import javax.faces.convert.Converter;
 import javax.faces.event.MethodExpressionActionListener;
 import javax.faces.event.MethodExpressionValueChangeListener;
 import javax.faces.validator.MethodExpressionValidator;
 
 /**
  * @author Manfred Geiler (latest modification by $Author: skitching $)
  * @author Bruno Aranda (JSR-252)
  * @version $Revision: 673827 $ $Date: 2008-07-03 16:46:23 -0500 (Thu, 03 Jul 2008) $
  *
  * @since 1.2
  */
 public class UIComponentELTagUtils
 {
     private static final Log log = LogFactory.getLog(UIComponentELTagUtils.class);
 
     private UIComponentELTagUtils() {}    //util class, no instantiation allowed
 
     /**
      * @since 1.2
      */
     public static void setIntegerProperty(UIComponent component,
                                           String propName,
                                           ValueExpression value)
     {
         setIntegerProperty(component, propName, value, null);
     }
 
     /**
      * @since 1.2
      */
     public static void setIntegerProperty(UIComponent component,
                                          String propName,
                                          ValueExpression value,
                                          Integer defaultValue)
     {
         if (value != null)
         {
             if (value.isLiteralText())
             {
                 component.getAttributes().put(propName, Integer.valueOf(value.getExpressionString()));
             }
             else
             {
                 component.setValueExpression(propName, value);
             }
         }
         else
         {
             if (defaultValue != null)
             {
                 component.getAttributes().put(propName, defaultValue);
             }
         }
     }
 
 
     /**
      * @since 1.2
      */
     public static void setLongProperty(UIComponent component,
                                        String propName,
                                        ValueExpression value)
     {
         setLongProperty(component, propName, value, null);
     }
 
     /**
      * @since 1.2
      */
     public static void setLongProperty(UIComponent component,
                                          String propName,
                                          ValueExpression value,
                                          Long defaultValue)
     {
         if (value != null)
         {
             if (value.isLiteralText())
             {
                 component.getAttributes().put(propName, Long.valueOf(value.getExpressionString()));
             }
             else
             {
                 component.setValueExpression(propName, value);
             }
         }
         else
         {
             if (defaultValue != null)
             {
                 component.getAttributes().put(propName, defaultValue);
             }
         }
     }
 
     /**
      * @since 1.2
      */
     public static void setStringProperty(UIComponent component,
                                      String propName,
                                      ValueExpression value)
     {
         setStringProperty(component, propName, value, null);
     }
 
     /**
      * @since 1.2
      */
     public static void setStringProperty(UIComponent component,
                                          String propName,
                                          ValueExpression value,
                                          String defaultValue)
     {
         if (value != null)
         {
             if (value.isLiteralText())
             {
                 component.getAttributes().put(propName, value.getExpressionString());
             }
             else
             {
                 component.setValueExpression(propName, value);
             }
         }
         else
         {
             if (defaultValue != null)
             {
                 component.getAttributes().put(propName, defaultValue);
             }
         }
     }
 
 
     /**
      * @since 1.2
      */
     public static void setBooleanProperty(UIComponent component,
                                       String propName,
                                       ValueExpression value)
     {
         setBooleanProperty(component, propName, value, null);
     }
 
     /**
      * @since 1.2
      */
     public static void setBooleanProperty(UIComponent component,
                                       String propName,
                                       ValueExpression value,
                                       Boolean defaultValue)
     {
         if (value != null)
         {
             if (value.isLiteralText())
             {
                 component.getAttributes().put(propName, Boolean.valueOf(value.getExpressionString()));
             }
             else
             {
                 component.setValueExpression(propName, value);
             }
         }
         else
         {
             if (defaultValue != null)
             {
                 component.getAttributes().put(propName, defaultValue);
             }
         }
     }
 
     /**
      * @since 1.2
      */
     public static void setValueProperty(FacesContext context,
                                         UIComponent component,
                                         ValueExpression value)
     {
         if (value != null)
         {
             if (!value.isLiteralText())
             {
                 component.setValueExpression(org.apache.myfaces.shared_impl.renderkit.JSFAttr.VALUE_ATTR, value);
             }
             else if (component instanceof UICommand)
             {
                 ((UICommand)component).setValue(value.getExpressionString());
             }
             else if (component instanceof UIParameter)
             {
                 ((UIParameter)component).setValue(value.getExpressionString());
             }
             else if (component instanceof UISelectBoolean)
             {
                 ((UISelectBoolean)component).setValue(Boolean.valueOf(value.getExpressionString()));
             }
             else if (component instanceof UIGraphic)
             {
                 ((UIGraphic)component).setValue(value.getExpressionString());
             }
             //Since many input components are ValueHolders the special components
             //must come first, ValueHolder is the last resort.
             else if (component instanceof ValueHolder)
             {
                 ((ValueHolder)component).setValue(value.getExpressionString());
             }
             else
             {
                 log.error("Component " + component.getClass().getName() + " is no ValueHolder, cannot set value.");
             }
         }
     }
 
     /**
      * @since 1.2
      */
     public static void setConverterProperty(FacesContext context,
                                         UIComponent component,
                                         ValueExpression value)
     {
         if (value != null)
         {
             if (component instanceof ValueHolder)
             {
                 if (value.isLiteralText())
                 {
                     FacesContext facesContext = FacesContext.getCurrentInstance();
                     Converter converter = facesContext.getApplication().createConverter(value.getExpressionString());
                     ((ValueHolder)component).setConverter(converter);
                 }
                 else
                 {
                     component.setValueExpression(org.apache.myfaces.shared_impl.renderkit.JSFAttr.CONVERTER_ATTR, value);
                 }
             }
             else
             {
                 log.error("Component " + component.getClass().getName() + " is no ValueHolder, cannot set value.");
             }
         }
     }
 
     /**
      * @since 1.2
      */
     public static void addValidatorProperty(FacesContext context,
                                             UIComponent component,
                                             MethodExpression validator)
     {
         if (validator != null)
         {
             if (!(component instanceof EditableValueHolder))
             {
                 throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no EditableValueHolder");
             }
 
             ((EditableValueHolder)component).addValidator(new MethodExpressionValidator(validator));
         }
     }
 
     /**
      * @since 1.2
      */
     public static void setValueBinding(FacesContext context,
                                        UIComponent component,
                                        String propName,
                                        ValueExpression value)
     {
         if (value != null)
         {
             if (!value.isLiteralText())
             {
                 component.setValueExpression(propName, value);
             }
             else
             {
                 throw new IllegalArgumentException("Component " + component.getClientId(context) + " attribute " + propName + " must be a value reference, was " + value);
             }
         }
     }
 
     /**
      * @since 1.2
      */
     public static void setActionProperty(FacesContext context,
                                          UIComponent component,
                                          MethodExpression action)
     {
         if (action != null)
         {
             if (!(component instanceof ActionSource2))
             {
                 throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no ActionSource2");
             }
 
             ((ActionSource2)component).setActionExpression(action);
         }
     }
 
     /**
      * @since 1.2
      */
     public static void addActionListenerProperty(FacesContext context,
                                                  UIComponent component,
                                                  MethodExpression actionListener)
     {
         if (actionListener != null)
         {
             if (!(component instanceof ActionSource2))
             {
                 throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no ActionSource");
             }
 
             ((ActionSource2)component).addActionListener(new MethodExpressionActionListener(actionListener));
         }
     }
 
     /**
      * @since 1.2
      */
     public static void addValueChangedListenerProperty(FacesContext context,
                                                        UIComponent component,
                                                        MethodExpression valueChangedListener)
     {
         if (valueChangedListener != null)
         {
             if (!(component instanceof EditableValueHolder))
             {
                 throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no EditableValueHolder");
             }
 
             ((EditableValueHolder)component).addValueChangeListener(
                     new MethodExpressionValueChangeListener(valueChangedListener));
         }
     }
 
     /**
      * @since 1.2
      */
     public static Object evaluateValueExpression(ELContext elContext, ValueExpression valueExpression )
     {
         return valueExpression.isLiteralText() ? valueExpression.getExpressionString() : valueExpression.getValue(elContext);
     }
 
     /**
      * @since 1.2
      */
     public static Boolean getBooleanValue(ELContext elContext, ValueExpression valueExpression)
     {
         if (valueExpression.isLiteralText()){
             return Boolean.valueOf(valueExpression.getExpressionString());
         }
         
         return (Boolean) valueExpression.getValue(elContext);
     }
 
     public static Integer getIntegerValue(ELContext elContext, ValueExpression valueExpression)
     {
         if (valueExpression.isLiteralText()){
             return Integer.valueOf(valueExpression.getExpressionString());
         }
         
            return (Integer) valueExpression.getValue(elContext);
     }
 
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package org.apache.myfaces.shared_impl.taglib;
20
21		import org.apache.commons.logging.Log;
22		import org.apache.commons.logging.LogFactory;
23
24		import javax.el.ELContext;
25		import javax.el.MethodExpression;
26		import javax.el.ValueExpression;
27		import javax.faces.component.ActionSource2;
28		import javax.faces.component.EditableValueHolder;
29		import javax.faces.component.UICommand;
30		import javax.faces.component.UIComponent;
31		import javax.faces.component.UIGraphic;
32		import javax.faces.component.UIParameter;
33		import javax.faces.component.UISelectBoolean;
34		import javax.faces.component.ValueHolder;
35		import javax.faces.context.FacesContext;
36		import javax.faces.convert.Converter;
37		import javax.faces.event.MethodExpressionActionListener;
38		import javax.faces.event.MethodExpressionValueChangeListener;
39		import javax.faces.validator.MethodExpressionValidator;
40
41		/**
42		* @author Manfred Geiler (latest modification by $Author: skitching $)
43		* @author Bruno Aranda (JSR-252)
44		* @version $Revision: 673827 $ $Date: 2008-07-03 16:46:23 -0500 (Thu, 03 Jul 2008) $
45		*
46		* @since 1.2
47		*/
48		public class UIComponentELTagUtils
49		{
50	0	private static final Log log = LogFactory.getLog(UIComponentELTagUtils.class);
51
52	0	private UIComponentELTagUtils() {} //util class, no instantiation allowed
53
54		/**
55		* @since 1.2
56		*/
57		public static void setIntegerProperty(UIComponent component,
58		String propName,
59		ValueExpression value)
60		{
61	0	setIntegerProperty(component, propName, value, null);
62	0	}
63
64		/**
65		* @since 1.2
66		*/
67		public static void setIntegerProperty(UIComponent component,
68		String propName,
69		ValueExpression value,
70		Integer defaultValue)
71		{
72	0	if (value != null)
73		{
74	0	if (value.isLiteralText())
75		{
76	0	component.getAttributes().put(propName, Integer.valueOf(value.getExpressionString()));
77		}
78		else
79		{
80	0	component.setValueExpression(propName, value);
81		}
82		}
83		else
84		{
85	0	if (defaultValue != null)
86		{
87	0	component.getAttributes().put(propName, defaultValue);
88		}
89		}
90	0	}
91
92
93		/**
94		* @since 1.2
95		*/
96		public static void setLongProperty(UIComponent component,
97		String propName,
98		ValueExpression value)
99		{
100	0	setLongProperty(component, propName, value, null);
101	0	}
102
103		/**
104		* @since 1.2
105		*/
106		public static void setLongProperty(UIComponent component,
107		String propName,
108		ValueExpression value,
109		Long defaultValue)
110		{
111	0	if (value != null)
112		{
113	0	if (value.isLiteralText())
114		{
115	0	component.getAttributes().put(propName, Long.valueOf(value.getExpressionString()));
116		}
117		else
118		{
119	0	component.setValueExpression(propName, value);
120		}
121		}
122		else
123		{
124	0	if (defaultValue != null)
125		{
126	0	component.getAttributes().put(propName, defaultValue);
127		}
128		}
129	0	}
130
131		/**
132		* @since 1.2
133		*/
134		public static void setStringProperty(UIComponent component,
135		String propName,
136		ValueExpression value)
137		{
138	0	setStringProperty(component, propName, value, null);
139	0	}
140
141		/**
142		* @since 1.2
143		*/
144		public static void setStringProperty(UIComponent component,
145		String propName,
146		ValueExpression value,
147		String defaultValue)
148		{
149	0	if (value != null)
150		{
151	0	if (value.isLiteralText())
152		{
153	0	component.getAttributes().put(propName, value.getExpressionString());
154		}
155		else
156		{
157	0	component.setValueExpression(propName, value);
158		}
159		}
160		else
161		{
162	0	if (defaultValue != null)
163		{
164	0	component.getAttributes().put(propName, defaultValue);
165		}
166		}
167	0	}
168
169
170		/**
171		* @since 1.2
172		*/
173		public static void setBooleanProperty(UIComponent component,
174		String propName,
175		ValueExpression value)
176		{
177	0	setBooleanProperty(component, propName, value, null);
178	0	}
179
180		/**
181		* @since 1.2
182		*/
183		public static void setBooleanProperty(UIComponent component,
184		String propName,
185		ValueExpression value,
186		Boolean defaultValue)
187		{
188	0	if (value != null)
189		{
190	0	if (value.isLiteralText())
191		{
192	0	component.getAttributes().put(propName, Boolean.valueOf(value.getExpressionString()));
193		}
194		else
195		{
196	0	component.setValueExpression(propName, value);
197		}
198		}
199		else
200		{
201	0	if (defaultValue != null)
202		{
203	0	component.getAttributes().put(propName, defaultValue);
204		}
205		}
206	0	}
207
208		/**
209		* @since 1.2
210		*/
211		public static void setValueProperty(FacesContext context,
212		UIComponent component,
213		ValueExpression value)
214		{
215	0	if (value != null)
216		{
217	0	if (!value.isLiteralText())
218		{
219	0	component.setValueExpression(org.apache.myfaces.shared_impl.renderkit.JSFAttr.VALUE_ATTR, value);
220		}
221	0	else if (component instanceof UICommand)
222		{
223	0	((UICommand)component).setValue(value.getExpressionString());
224		}
225	0	else if (component instanceof UIParameter)
226		{
227	0	((UIParameter)component).setValue(value.getExpressionString());
228		}
229	0	else if (component instanceof UISelectBoolean)
230		{
231	0	((UISelectBoolean)component).setValue(Boolean.valueOf(value.getExpressionString()));
232		}
233	0	else if (component instanceof UIGraphic)
234		{
235	0	((UIGraphic)component).setValue(value.getExpressionString());
236		}
237		//Since many input components are ValueHolders the special components
238		//must come first, ValueHolder is the last resort.
239	0	else if (component instanceof ValueHolder)
240		{
241	0	((ValueHolder)component).setValue(value.getExpressionString());
242		}
243		else
244		{
245	0	log.error("Component " + component.getClass().getName() + " is no ValueHolder, cannot set value.");
246		}
247		}
248	0	}
249
250		/**
251		* @since 1.2
252		*/
253		public static void setConverterProperty(FacesContext context,
254		UIComponent component,
255		ValueExpression value)
256		{
257	0	if (value != null)
258		{
259	0	if (component instanceof ValueHolder)
260		{
261	0	if (value.isLiteralText())
262		{
263	0	FacesContext facesContext = FacesContext.getCurrentInstance();
264	0	Converter converter = facesContext.getApplication().createConverter(value.getExpressionString());
265	0	((ValueHolder)component).setConverter(converter);
266	0	}
267		else
268		{
269	0	component.setValueExpression(org.apache.myfaces.shared_impl.renderkit.JSFAttr.CONVERTER_ATTR, value);
270		}
271		}
272		else
273		{
274	0	log.error("Component " + component.getClass().getName() + " is no ValueHolder, cannot set value.");
275		}
276		}
277	0	}
278
279		/**
280		* @since 1.2
281		*/
282		public static void addValidatorProperty(FacesContext context,
283		UIComponent component,
284		MethodExpression validator)
285		{
286	0	if (validator != null)
287		{
288	0	if (!(component instanceof EditableValueHolder))
289		{
290	0	throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no EditableValueHolder");
291		}
292
293	0	((EditableValueHolder)component).addValidator(new MethodExpressionValidator(validator));
294		}
295	0	}
296
297		/**
298		* @since 1.2
299		*/
300		public static void setValueBinding(FacesContext context,
301		UIComponent component,
302		String propName,
303		ValueExpression value)
304		{
305	0	if (value != null)
306		{
307	0	if (!value.isLiteralText())
308		{
309	0	component.setValueExpression(propName, value);
310		}
311		else
312		{
313	0	throw new IllegalArgumentException("Component " + component.getClientId(context) + " attribute " + propName + " must be a value reference, was " + value);
314		}
315		}
316	0	}
317
318		/**
319		* @since 1.2
320		*/
321		public static void setActionProperty(FacesContext context,
322		UIComponent component,
323		MethodExpression action)
324		{
325	0	if (action != null)
326		{
327	0	if (!(component instanceof ActionSource2))
328		{
329	0	throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no ActionSource2");
330		}
331
332	0	((ActionSource2)component).setActionExpression(action);
333		}
334	0	}
335
336		/**
337		* @since 1.2
338		*/
339		public static void addActionListenerProperty(FacesContext context,
340		UIComponent component,
341		MethodExpression actionListener)
342		{
343	0	if (actionListener != null)
344		{
345	0	if (!(component instanceof ActionSource2))
346		{
347	0	throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no ActionSource");
348		}
349
350	0	((ActionSource2)component).addActionListener(new MethodExpressionActionListener(actionListener));
351		}
352	0	}
353
354		/**
355		* @since 1.2
356		*/
357		public static void addValueChangedListenerProperty(FacesContext context,
358		UIComponent component,
359		MethodExpression valueChangedListener)
360		{
361	0	if (valueChangedListener != null)
362		{
363	0	if (!(component instanceof EditableValueHolder))
364		{
365	0	throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no EditableValueHolder");
366		}
367
368	0	((EditableValueHolder)component).addValueChangeListener(
369		new MethodExpressionValueChangeListener(valueChangedListener));
370		}
371	0	}
372
373		/**
374		* @since 1.2
375		*/
376		public static Object evaluateValueExpression(ELContext elContext, ValueExpression valueExpression )
377		{
378	0	return valueExpression.isLiteralText() ? valueExpression.getExpressionString() : valueExpression.getValue(elContext);
379		}
380
381		/**
382		* @since 1.2
383		*/
384		public static Boolean getBooleanValue(ELContext elContext, ValueExpression valueExpression)
385		{
386	0	if (valueExpression.isLiteralText()){
387	0	return Boolean.valueOf(valueExpression.getExpressionString());
388		}
389
390	0	return (Boolean) valueExpression.getValue(elContext);
391		}
392
393		public static Integer getIntegerValue(ELContext elContext, ValueExpression valueExpression)
394		{
395	0	if (valueExpression.isLiteralText()){
396	0	return Integer.valueOf(valueExpression.getExpressionString());
397		}
398
399	0	return (Integer) valueExpression.getValue(elContext);
400		}
401
402		}