Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.jelly.tags.core.ArgTag$3 |
100% |
100% |

1 |  |
     /*
2 |  |
      * Copyright 2002,2004 The Apache Software Foundation.
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *      http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.jelly.tags.core;
17 |  |
18 |  |
     import java.util.HashMap;
19 |  |
     import java.util.Map;
20 |  |
21 |  |
     import org.apache.commons.beanutils.ConversionException;
22 |  |
     import org.apache.commons.beanutils.Converter;
23 |  |
     import org.apache.commons.beanutils.converters.BooleanConverter;
24 |  |
     import org.apache.commons.beanutils.converters.ByteConverter;
25 |  |
     import org.apache.commons.beanutils.converters.CharacterConverter;
26 |  |
     import org.apache.commons.beanutils.converters.DoubleConverter;
27 |  |
     import org.apache.commons.beanutils.converters.FloatConverter;
28 |  |
     import org.apache.commons.beanutils.converters.IntegerConverter;
29 |  |
     import org.apache.commons.beanutils.converters.LongConverter;
30 |  |
     import org.apache.commons.beanutils.converters.ShortConverter;
31 |  |
     import org.apache.commons.jelly.JellyTagException;
32 |  |
     import org.apache.commons.jelly.XMLOutput;
33 |  |
34 |  |
     /**
35 |  |
      * An argument to a {@link NewTag} or {@link InvokeTag}.
36 |  |
      * This tag MUST be enclosed within an {@link ArgTagParent}
37 |  |
      * implementation.
38 |  |
      *
39 |  |
      * @author Rodney Waldhoff
40 |  |
      * @version $Revision: 155420 $
41 |  |
      */
42 |  |
     public class ArgTag extends BaseClassLoaderTag {
43 |  |
44 |  |
         // constructors
45 |  |
         //-------------------------------------------------------------------------
46 |  |
47 |  |
         public ArgTag() {
48 |  |
         }
49 |  |
50 |  |
         // attribute setters
51 |  |
         //-------------------------------------------------------------------------
52 |  |
53 |  |
         /**
54 |  |
          * The name of the argument class or type, if any.
55 |  |
          * This may be a fully specified class name or
56 |  |
          * a primitive type name
57 |  |
          * (<code>boolean<code>, <code>int</code>, <code>double</code>, etc.).
58 |  |
          */
59 |  |
         public void setType(String type) {
60 |  |
             this.typeString = type;
61 |  |
         }
62 |  |
63 |  |
         /** The (possibly null) value of this argument. */
64 |  |
         public void setValue(Object value) {
65 |  |
             this.value= value;
66 |  |
         }
67 |  |
68 |  |
         // tag methods
69 |  |
         //-------------------------------------------------------------------------
70 |  |
71 |  |
         public void doTag(XMLOutput output) throws JellyTagException {
72 |  |
             invokeBody(output);
73 |  |
74 |  |
             Class klass = null;
75 |  |
             if("boolean".equals(typeString)) {
76 |  |
                 klass = Boolean.TYPE;
77 |  |
                 assertNotNull(value);
78 |  |
             } else if("byte".equals(typeString)) {
79 |  |
                 klass = Byte.TYPE;
80 |  |
                 assertNotNull(value);
81 |  |
             } else if("short".equals(typeString)) {
82 |  |
                 klass = Short.TYPE;
83 |  |
                 assertNotNull(value);
84 |  |
             } else if("int".equals(typeString)) {
85 |  |
                 klass = Integer.TYPE;
86 |  |
                 assertNotNull(value);
87 |  |
             } else if("char".equals(typeString)) {
88 |  |
                 klass = Character.TYPE;
89 |  |
                 assertNotNull(value);
90 |  |
             } else if("float".equals(typeString)) {
91 |  |
                 klass = Float.TYPE;
92 |  |
                 assertNotNull(value);
93 |  |
             } else if("long".equals(typeString)) {
94 |  |
                 klass = Long.TYPE;
95 |  |
                 assertNotNull(value);
96 |  |
             } else if("double".equals(typeString)) {
97 |  |
                 klass = Double.TYPE;
98 |  |
                 assertNotNull(value);
99 |  |
             } else if(null != typeString) {
100 |  |
                 try {
101 |  |
                   klass = getClassLoader().loadClass(typeString);
102 |  |
                 } catch (ClassNotFoundException e) {
103 |  |
                     throw new JellyTagException(e);
104 |  |
                 }
105 |  |
             } else if(null == value) { // and (by construction) null == typeString
106 |  |
                 klass = Object.class;
107 |  |
             } else {
108 |  |
                 klass = value.getClass();
109 |  |
             }
110 |  |
111 |  |
             if(!isInstanceOf(klass,value)) {
112 |  |
                 if (klass.equals(Class.class))
113 |  |
                 {
114 |  |
                     try {
115 |  |
                         value = getClassLoader().loadClass((String) value);
116 |  |
                     } catch (ClassNotFoundException e) {
117 |  |
                         throw new JellyTagException(e);
118 |  |
                     }
119 |  |
                 }
120 |  |
                 else
121 |  |
                 {
122 |  |
                     value = convert(klass,value);
123 |  |
                 }
124 |  |
             }
125 |  |
126 |  |
             ArgTagParent parent = (ArgTagParent)findAncestorWithClass(ArgTagParent.class);
127 |  |
             if(null == parent) {
128 |  |
                 throw new JellyTagException("This tag must be enclosed inside an ArgTagParent implementation (for example, <new> or <invoke>)" );
129 |  |
             } else {
130 |  |
                 parent.addArgument(klass,value);
131 |  |
             }
132 |  |
         }
133 |  |
134 |  |
         // private methods
135 |  |
         //-------------------------------------------------------------------------
136 |  |
137 |  |
         private void assertNotNull(Object value) throws JellyTagException {
138 |  |
             if(null == value) {
139 |  |
                 throw new JellyTagException("A " + typeString + " instance cannot be null.");
140 |  |
             }
141 |  |
         }
142 |  |
143 |  |
         private boolean isInstanceOf(Class klass, Object value) {
144 |  |
             return (null == value || (klass.isInstance(value)));
145 |  |
         }
146 |  |
147 |  |
         // attributes
148 |  |
         //-------------------------------------------------------------------------
149 |  |
150 |  |
         /** The name of the parameter type, if any. */
151 |  |
         private String typeString;
152 |  |
153 |  |
         /** The value of the parameter, if any */
154 |  |
         private Object value;
155 |  |
156 |  |
         // static stuff
157 |  |
         //-------------------------------------------------------------------------
158 |  |
159 |  |
         private static Object convert(Class klass, Object value) throws JellyTagException {
160 |  |
             if(null == value) {
161 |  |
                 return null;
162 |  |
             } else if(!klass.isInstance(value)) {
163 |  |
                 Converter converter = (Converter)(converterMap.get(klass));
164 |  |
                 if(null == converter) {
165 |  |
                     throw new JellyTagException("Can't convert " + value + " to " + klass);
166 |  |
                 } else {
167 |  |
                     try {
168 |  |
                         return converter.convert(klass,value);
169 |  |
                     } catch(ConversionException e) {
170 |  |
                         throw new JellyTagException("Can't convert " + value + " to " + klass + " (" + e.toString() + ")",e);
171 |  |
                     }
172 |  |
                 }
173 |  |
             } else {
174 |  |
                 return value;
175 |  |
             }
176 |  |
177 |  |
         }
178 |  |
179 |  |
         /** My bag of converters, by target Class */
180 |  |
         private static Map converterMap = new HashMap();
181 |  |
         // these inner classes should probably move to beanutils
182 |  |
         static {
183 |  |
             {
184 |  |
                 Converter c = new BooleanConverter();
185 |  |
                 converterMap.put(Boolean.TYPE,c);
186 |  |
                 converterMap.put(Boolean.class,c);
187 |  |
             }
188 |  |
             {
189 |  |
                 Converter c = new CharacterConverter();
190 |  |
                 converterMap.put(Character.TYPE,c);
191 |  |
                 converterMap.put(Character.class,c);
192 |  |
             }
193 |  |
             {
194 |  |
                 Converter c = new Converter() {
195 |  |
                     public Object convert(Class klass, Object value) {
196 |  |
                         if(value instanceof Number) {
197 |  |
                             return new Byte(((Number)value).byteValue());
198 |  |
                         } else {
199 |  |
                             return inner.convert(klass,value);
200 |  |
                         }
201 |  |
                     }
202 |  |
                     private Converter inner = new ByteConverter();
203 |  |
                 };
204 |  |
                 converterMap.put(Byte.TYPE,c);
205 |  |
                 converterMap.put(Byte.class,c);
206 |  |
             }
207 |  |
             {
208 |  |
                 Converter c = new Converter() {
209 |  |
                     public Object convert(Class klass, Object value) {
210 |  |
                         if(value instanceof Number) {
211 |  |
                             return new Short(((Number)value).shortValue());
212 |  |
                         } else {
213 |  |
                             return inner.convert(klass,value);
214 |  |
                         }
215 |  |
                     }
216 |  |
                     private Converter inner = new ShortConverter();
217 |  |
                 };
218 |  |
                 converterMap.put(Short.TYPE,c);
219 |  |
                 converterMap.put(Short.class,c);
220 |  |
             }
221 |  |
             {
222 |  |
                 Converter c = new Converter() {
223 |  |
                     public Object convert(Class klass, Object value) {
224 | 78 |
                         if(value instanceof Number) {
225 | 13 |
                             return new Integer(((Number)value).intValue());
226 |  |
                         } else {
227 | 65 |
                             return inner.convert(klass,value);
228 |  |
                         }
229 |  |
                     }
230 | 286 |
                     private Converter inner = new IntegerConverter();
231 |  |
                 };
232 |  |
                 converterMap.put(Integer.TYPE,c);
233 |  |
                 converterMap.put(Integer.class,c);
234 |  |
             }
235 |  |
             {
236 |  |
                 Converter c = new Converter() {
237 |  |
                     public Object convert(Class klass, Object value) {
238 |  |
                         if(value instanceof Number) {
239 |  |
                             return new Long(((Number)value).longValue());
240 |  |
                         } else {
241 |  |
                             return inner.convert(klass,value);
242 |  |
                         }
243 |  |
                     }
244 |  |
                     private Converter inner = new LongConverter();
245 |  |
                 };
246 |  |
                 converterMap.put(Long.TYPE,c);
247 |  |
                 converterMap.put(Long.class,c);
248 |  |
             }
249 |  |
             {
250 |  |
                 Converter c = new Converter() {
251 |  |
                     public Object convert(Class klass, Object value) {
252 |  |
                         if(value instanceof Number) {
253 |  |
                             return new Float(((Number)value).floatValue());
254 |  |
                         } else {
255 |  |
                             return inner.convert(klass,value);
256 |  |
                         }
257 |  |
                     }
258 |  |
                     private Converter inner = new FloatConverter();
259 |  |
                 };
260 |  |
                 converterMap.put(Float.TYPE,c);
261 |  |
                 converterMap.put(Float.class,c);
262 |  |
             }
263 |  |
             {
264 |  |
                 Converter c = new Converter() {
265 |  |
                     public Object convert(Class klass, Object value) {
266 |  |
                         if(value instanceof Number) {
267 |  |
                             return new Double(((Number)value).doubleValue());
268 |  |
                         } else {
269 |  |
                             return inner.convert(klass,value);
270 |  |
                         }
271 |  |
                     }
272 |  |
                     private Converter inner = new DoubleConverter();
273 |  |
                 };
274 |  |
                 converterMap.put(Double.TYPE,c);
275 |  |
                 converterMap.put(Double.class,c);
276 |  |
             }
277 |  |
         }
278 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.