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.