Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

UIComponentELTagUtils

0/96

0/70

3.211

 /*
  * 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.taglib;
 
 import java.util.logging.Logger;
 
 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;
 
 /**
  * @since 1.2
  */
 public class UIComponentELTagUtils
 {
     //private static final Log log = LogFactory.getLog(UIComponentELTagUtils.class);
     private static final Logger log = Logger
             .getLogger(UIComponentELTagUtils.class.getName());
 
     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.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.severe("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.renderkit.JSFAttr.CONVERTER_ATTR,
                                     value);
                 }
             }
             else
             {
                 log.severe("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.taglib;
20
21		import java.util.logging.Logger;
22
23		import javax.el.ELContext;
24		import javax.el.MethodExpression;
25		import javax.el.ValueExpression;
26		import javax.faces.component.ActionSource2;
27		import javax.faces.component.EditableValueHolder;
28		import javax.faces.component.UICommand;
29		import javax.faces.component.UIComponent;
30		import javax.faces.component.UIGraphic;
31		import javax.faces.component.UIParameter;
32		import javax.faces.component.UISelectBoolean;
33		import javax.faces.component.ValueHolder;
34		import javax.faces.context.FacesContext;
35		import javax.faces.convert.Converter;
36		import javax.faces.event.MethodExpressionActionListener;
37		import javax.faces.event.MethodExpressionValueChangeListener;
38		import javax.faces.validator.MethodExpressionValidator;
39
40		/**
41		* @since 1.2
42		*/
43		public class UIComponentELTagUtils
44		{
45		//private static final Log log = LogFactory.getLog(UIComponentELTagUtils.class);
46	0	private static final Logger log = Logger
47		.getLogger(UIComponentELTagUtils.class.getName());
48
49		private UIComponentELTagUtils()
50	0	{
51	0	} //util class, no instantiation allowed
52
53		/**
54		* @since 1.2
55		*/
56		public static void setIntegerProperty(UIComponent component,
57		String propName, ValueExpression value)
58		{
59	0	setIntegerProperty(component, propName, value, null);
60	0	}
61
62		/**
63		* @since 1.2
64		*/
65		public static void setIntegerProperty(UIComponent component,
66		String propName, ValueExpression value, Integer defaultValue)
67		{
68	0	if (value != null)
69		{
70	0	if (value.isLiteralText())
71		{
72	0	component.getAttributes().put(propName,
73		Integer.valueOf(value.getExpressionString()));
74		}
75		else
76		{
77	0	component.setValueExpression(propName, value);
78		}
79		}
80		else
81		{
82	0	if (defaultValue != null)
83		{
84	0	component.getAttributes().put(propName, defaultValue);
85		}
86		}
87	0	}
88
89		/**
90		* @since 1.2
91		*/
92		public static void setLongProperty(UIComponent component, String propName,
93		ValueExpression value)
94		{
95	0	setLongProperty(component, propName, value, null);
96	0	}
97
98		/**
99		* @since 1.2
100		*/
101		public static void setLongProperty(UIComponent component, String propName,
102		ValueExpression value, Long defaultValue)
103		{
104	0	if (value != null)
105		{
106	0	if (value.isLiteralText())
107		{
108	0	component.getAttributes().put(propName,
109		Long.valueOf(value.getExpressionString()));
110		}
111		else
112		{
113	0	component.setValueExpression(propName, value);
114		}
115		}
116		else
117		{
118	0	if (defaultValue != null)
119		{
120	0	component.getAttributes().put(propName, defaultValue);
121		}
122		}
123	0	}
124
125		/**
126		* @since 1.2
127		*/
128		public static void setStringProperty(UIComponent component,
129		String propName, ValueExpression value)
130		{
131	0	setStringProperty(component, propName, value, null);
132	0	}
133
134		/**
135		* @since 1.2
136		*/
137		public static void setStringProperty(UIComponent component,
138		String propName, ValueExpression value, String defaultValue)
139		{
140	0	if (value != null)
141		{
142	0	if (value.isLiteralText())
143		{
144	0	component.getAttributes().put(propName,
145		value.getExpressionString());
146		}
147		else
148		{
149	0	component.setValueExpression(propName, value);
150		}
151		}
152		else
153		{
154	0	if (defaultValue != null)
155		{
156	0	component.getAttributes().put(propName, defaultValue);
157		}
158		}
159	0	}
160
161		/**
162		* @since 1.2
163		*/
164		public static void setBooleanProperty(UIComponent component,
165		String propName, ValueExpression value)
166		{
167	0	setBooleanProperty(component, propName, value, null);
168	0	}
169
170		/**
171		* @since 1.2
172		*/
173		public static void setBooleanProperty(UIComponent component,
174		String propName, ValueExpression value, Boolean defaultValue)
175		{
176	0	if (value != null)
177		{
178	0	if (value.isLiteralText())
179		{
180	0	component.getAttributes().put(propName,
181		Boolean.valueOf(value.getExpressionString()));
182		}
183		else
184		{
185	0	component.setValueExpression(propName, value);
186		}
187		}
188		else
189		{
190	0	if (defaultValue != null)
191		{
192	0	component.getAttributes().put(propName, defaultValue);
193		}
194		}
195	0	}
196
197		/**
198		* @since 1.2
199		*/
200		public static void setValueProperty(FacesContext context,
201		UIComponent component, ValueExpression value)
202		{
203	0	if (value != null)
204		{
205	0	if (!value.isLiteralText())
206		{
207	0	component.setValueExpression(
208		org.apache.myfaces.shared.renderkit.JSFAttr.VALUE_ATTR,
209		value);
210		}
211	0	else if (component instanceof UICommand)
212		{
213	0	((UICommand) component).setValue(value.getExpressionString());
214		}
215	0	else if (component instanceof UIParameter)
216		{
217	0	((UIParameter) component).setValue(value.getExpressionString());
218		}
219	0	else if (component instanceof UISelectBoolean)
220		{
221	0	((UISelectBoolean) component).setValue(Boolean.valueOf(value
222		.getExpressionString()));
223		}
224	0	else if (component instanceof UIGraphic)
225		{
226	0	((UIGraphic) component).setValue(value.getExpressionString());
227		}
228		//Since many input components are ValueHolders the special components
229		//must come first, ValueHolder is the last resort.
230	0	else if (component instanceof ValueHolder)
231		{
232	0	((ValueHolder) component).setValue(value.getExpressionString());
233		}
234		else
235		{
236	0	log.severe("Component " + component.getClass().getName()
237		+ " is no ValueHolder, cannot set value.");
238		}
239		}
240	0	}
241
242		/**
243		* @since 1.2
244		*/
245		public static void setConverterProperty(FacesContext context,
246		UIComponent component, ValueExpression value)
247		{
248	0	if (value != null)
249		{
250	0	if (component instanceof ValueHolder)
251		{
252	0	if (value.isLiteralText())
253		{
254	0	FacesContext facesContext = FacesContext
255		.getCurrentInstance();
256	0	Converter converter = facesContext.getApplication()
257		.createConverter(value.getExpressionString());
258	0	((ValueHolder) component).setConverter(converter);
259	0	}
260		else
261		{
262	0	component
263		.setValueExpression(
264		org.apache.myfaces.shared.renderkit.JSFAttr.CONVERTER_ATTR,
265		value);
266		}
267		}
268		else
269		{
270	0	log.severe("Component " + component.getClass().getName()
271		+ " is no ValueHolder, cannot set value.");
272		}
273		}
274	0	}
275
276		/**
277		* @since 1.2
278		*/
279		public static void addValidatorProperty(FacesContext context,
280		UIComponent component, MethodExpression validator)
281		{
282	0	if (validator != null)
283		{
284	0	if (!(component instanceof EditableValueHolder))
285		{
286	0	throw new IllegalArgumentException("Component "
287		+ component.getClientId(context)
288		+ " is no EditableValueHolder");
289		}
290
291	0	((EditableValueHolder) component)
292		.addValidator(new MethodExpressionValidator(validator));
293		}
294	0	}
295
296		/**
297		* @since 1.2
298		*/
299		public static void setValueBinding(FacesContext context,
300		UIComponent component, String propName, ValueExpression value)
301		{
302	0	if (value != null)
303		{
304	0	if (!value.isLiteralText())
305		{
306	0	component.setValueExpression(propName, value);
307		}
308		else
309		{
310	0	throw new IllegalArgumentException("Component "
311		+ component.getClientId(context) + " attribute "
312		+ propName + " must be a value reference, was " + value);
313		}
314		}
315	0	}
316
317		/**
318		* @since 1.2
319		*/
320		public static void setActionProperty(FacesContext context,
321		UIComponent component, MethodExpression action)
322		{
323	0	if (action != null)
324		{
325	0	if (!(component instanceof ActionSource2))
326		{
327	0	throw new IllegalArgumentException("Component "
328		+ component.getClientId(context)
329		+ " 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, MethodExpression actionListener)
341		{
342	0	if (actionListener != null)
343		{
344	0	if (!(component instanceof ActionSource2))
345		{
346	0	throw new IllegalArgumentException("Component "
347		+ component.getClientId(context)
348		+ " is no ActionSource");
349		}
350
351	0	((ActionSource2) component)
352		.addActionListener(new MethodExpressionActionListener(
353		actionListener));
354		}
355	0	}
356
357		/**
358		* @since 1.2
359		*/
360		public static void addValueChangedListenerProperty(FacesContext context,
361		UIComponent component, MethodExpression valueChangedListener)
362		{
363	0	if (valueChangedListener != null)
364		{
365	0	if (!(component instanceof EditableValueHolder))
366		{
367	0	throw new IllegalArgumentException("Component "
368		+ component.getClientId(context)
369		+ " is no EditableValueHolder");
370		}
371
372	0	((EditableValueHolder) component)
373		.addValueChangeListener(new MethodExpressionValueChangeListener(
374		valueChangedListener));
375		}
376	0	}
377
378		/**
379		* @since 1.2
380		*/
381		public static Object evaluateValueExpression(ELContext elContext,
382		ValueExpression valueExpression)
383		{
384	0	return valueExpression.isLiteralText() ? valueExpression
385		.getExpressionString() : valueExpression.getValue(elContext);
386		}
387
388		/**
389		* @since 1.2
390		*/
391		public static Boolean getBooleanValue(ELContext elContext,
392		ValueExpression valueExpression)
393		{
394	0	if (valueExpression.isLiteralText())
395		{
396	0	return Boolean.valueOf(valueExpression.getExpressionString());
397		}
398
399	0	return (Boolean) valueExpression.getValue(elContext);
400		}
401
402		public static Integer getIntegerValue(ELContext elContext,
403		ValueExpression valueExpression)
404		{
405	0	if (valueExpression.isLiteralText())
406		{
407	0	return Integer.valueOf(valueExpression.getExpressionString());
408		}
409
410	0	return (Integer) valueExpression.getValue(elContext);
411		}
412
413		}