Source code: com/sun/facelets/tag/TagAttribute.java
1 /**
2 * Licensed under the Common Development and Distribution License,
3 * you may not use this file except in compliance with the License.
4 * You may obtain a copy of the License at
5 *
6 * http://www.sun.com/cddl/
7 *
8 * Unless required by applicable law or agreed to in writing, software
9 * distributed under the License is distributed on an "AS IS" BASIS,
10 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
11 * implied. See the License for the specific language governing
12 * permissions and limitations under the License.
13 */
14
15 package com.sun.facelets.tag;
16
17 import javax.el.ELException;
18 import javax.el.ExpressionFactory;
19 import javax.el.MethodExpression;
20 import javax.el.ValueExpression;
21
22 import com.sun.facelets.FaceletContext;
23 import com.sun.facelets.el.ELText;
24 import com.sun.facelets.el.TagMethodExpression;
25 import com.sun.facelets.el.TagValueExpression;
26
27 /**
28 * Representation of a Tag's attribute in a Facelet File
29 *
30 * @author Jacob Hookom
31 * @version $Id: TagAttribute.java,v 1.7 2005/11/09 03:49:18 jhook Exp $
32 */
33 public final class TagAttribute {
34
35 private final boolean literal;
36
37 private final String localName;
38
39 private final Location location;
40
41 private final String namespace;
42
43 private final String qName;
44
45 private final String value;
46
47 private String string;
48
49 public TagAttribute(Location location, String ns, String localName,
50 String qName, String value) {
51 this.location = location;
52 this.namespace = ns;
53 this.localName = localName;
54 this.qName = qName;
55 this.value = value;
56 try {
57 this.literal = ELText.isLiteral(this.value);
58 } catch (ELException e) {
59 throw new TagAttributeException(this, e);
60 }
61 }
62
63 /**
64 * If literal, return
65 * {@link Boolean#getBoolean(java.lang.String) Boolean.getBoolean(java.lang.String)}
66 * passing our value, otherwise call
67 * {@link #getObject(FaceletContext, Class) getObject(FaceletContext, Class)}.
68 *
69 * @see Boolean#getBoolean(java.lang.String)
70 * @see #getObject(FaceletContext, Class)
71 * @param ctx
72 * FaceletContext to use
73 * @return boolean value
74 */
75 public boolean getBoolean(FaceletContext ctx) {
76 if (this.literal) {
77 return Boolean.valueOf(this.value).booleanValue();
78 } else {
79 return ((Boolean) this.getObject(ctx, Boolean.class))
80 .booleanValue();
81 }
82 }
83
84 /**
85 * If literal, call
86 * {@link Integer#parseInt(java.lang.String) Integer.parseInt(String)},
87 * otherwise call
88 * {@link #getObject(FaceletContext, Class) getObject(FaceletContext, Class)}.
89 *
90 * @see Integer#parseInt(java.lang.String)
91 * @see #getObject(FaceletContext, Class)
92 * @param ctx
93 * FaceletContext to use
94 * @return int value
95 */
96 public int getInt(FaceletContext ctx) {
97 if (this.literal) {
98 return Integer.parseInt(this.value);
99 } else {
100 return ((Number) this.getObject(ctx, Number.class)).intValue();
101 }
102 }
103
104 /**
105 * Local name of this attribute
106 *
107 * @return local name of this attribute
108 */
109 public String getLocalName() {
110 return this.localName;
111 }
112
113 /**
114 * The location of this attribute in the FaceletContext
115 *
116 * @return the TagAttribute's location
117 */
118 public Location getLocation() {
119 return this.location;
120 }
121
122 /**
123 * Create a MethodExpression, using this attribute's value as the expression
124 * String.
125 *
126 * @see ExpressionFactory#createMethodExpression(javax.el.ELContext,
127 * java.lang.String, java.lang.Class, java.lang.Class[])
128 * @see MethodExpression
129 * @param ctx
130 * FaceletContext to use
131 * @param type
132 * expected return type
133 * @param paramTypes
134 * parameter type
135 * @return a MethodExpression instance
136 */
137 public MethodExpression getMethodExpression(FaceletContext ctx, Class type,
138 Class[] paramTypes) {
139 try {
140 ExpressionFactory f = ctx.getExpressionFactory();
141 return new TagMethodExpression(this, f.createMethodExpression(ctx,
142 this.value, type, paramTypes));
143 } catch (Exception e) {
144 throw new TagAttributeException(this, e);
145 }
146 }
147
148 /**
149 * The resolved Namespace for this attribute
150 *
151 * @return resolved Namespace
152 */
153 public String getNamespace() {
154 return this.namespace;
155 }
156
157 /**
158 * Delegates to getObject with Object.class as a param
159 *
160 * @see #getObject(FaceletContext, Class)
161 * @param ctx
162 * FaceletContext to use
163 * @return Object representation of this attribute's value
164 */
165 public Object getObject(FaceletContext ctx) {
166 return this.getObject(ctx, Object.class);
167 }
168
169 /**
170 * The qualified name for this attribute
171 *
172 * @return the qualified name for this attribute
173 */
174 public String getQName() {
175 return this.qName;
176 }
177
178 /**
179 * Return the literal value of this attribute
180 *
181 * @return literal value
182 */
183 public String getValue() {
184 return this.value;
185 }
186
187 /**
188 * If literal, then return our value, otherwise delegate to getObject,
189 * passing String.class.
190 *
191 * @see #getObject(FaceletContext, Class)
192 * @param ctx
193 * FaceletContext to use
194 * @return String value of this attribute
195 */
196 public String getValue(FaceletContext ctx) {
197 if (this.literal) {
198 return this.value;
199 } else {
200 return (String) this.getObject(ctx, String.class);
201 }
202 }
203
204 /**
205 * If literal, simply coerce our String literal value using an
206 * ExpressionFactory, otherwise create a ValueExpression and evaluate it.
207 *
208 * @see ExpressionFactory#coerceToType(java.lang.Object, java.lang.Class)
209 * @see ExpressionFactory#createValueExpression(javax.el.ELContext,
210 * java.lang.String, java.lang.Class)
211 * @see ValueExpression
212 * @param ctx
213 * FaceletContext to use
214 * @param type
215 * expected return type
216 * @return Object value of this attribute
217 */
218 public Object getObject(FaceletContext ctx, Class type) {
219 if (this.literal) {
220 if (String.class.equals(type)) {
221 return this.value;
222 } else {
223 try {
224 return ctx.getExpressionFactory().coerceToType(this.value,
225 type);
226 } catch (Exception e) {
227 throw new TagAttributeException(this, e);
228 }
229 }
230 } else {
231 ValueExpression ve = this.getValueExpression(ctx, type);
232 try {
233 return ve.getValue(ctx);
234 } catch (Exception e) {
235 throw new TagAttributeException(this, e);
236 }
237 }
238 }
239
240 /**
241 * Create a ValueExpression, using this attribute's literal value and the
242 * passed expected type.
243 *
244 * @see ExpressionFactory#createValueExpression(javax.el.ELContext,
245 * java.lang.String, java.lang.Class)
246 * @see ValueExpression
247 * @param ctx
248 * FaceletContext to use
249 * @param type
250 * expected return type
251 * @return ValueExpression instance
252 */
253 public ValueExpression getValueExpression(FaceletContext ctx, Class type) {
254 try {
255 ExpressionFactory f = ctx.getExpressionFactory();
256 return new TagValueExpression(this, f.createValueExpression(ctx,
257 this.value, type));
258 } catch (Exception e) {
259 throw new TagAttributeException(this, e);
260 }
261 }
262
263 /**
264 * If this TagAttribute is literal (not #{..} or ${..})
265 *
266 * @return true if this attribute is literal
267 */
268 public boolean isLiteral() {
269 return this.literal;
270 }
271
272 /*
273 * (non-Javadoc)
274 *
275 * @see java.lang.Object#toString()
276 */
277 public String toString() {
278 if (this.string == null) {
279 this.string = this.location + " " + this.qName + "=\"" + this.value
280 + "\"";
281 }
282 return this.string;
283 }
284
285 }