Coverage report

  %line %branch
org.apache.commons.jelly.tags.core.InvokeStaticTag
80% 
98% 

 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.lang.reflect.InvocationTargetException;
 19  
 import java.lang.reflect.Method;
 20  
 import java.util.ArrayList;
 21  
 import java.util.List;
 22  
 
 23  
 import org.apache.commons.jelly.JellyTagException;
 24  
 import org.apache.commons.jelly.MissingAttributeException;
 25  
 import org.apache.commons.jelly.TagSupport;
 26  
 import org.apache.commons.jelly.XMLOutput;
 27  
 import org.apache.commons.jelly.util.ClassLoaderUtils;
 28  
 
 29  
 /**
 30  
   * A Tag which can invoke a static method on a class, without an
 31  
   * instance of the class being needed.
 32  
   * <p>
 33  
   * Like the {@link InvokeTag}, this tag can take a set of
 34  
   * arguments using the {@link ArgTag}.
 35  
   * </p>
 36  
   * <p>
 37  
   *  The following attributes are required:<br />
 38  
   * <ul>
 39  
   *   <li>var - The variable to assign the return of the method call to</li>
 40  
   *   <li>method - The name of the static method to invoke</li>
 41  
   *   <li>className - The name of the class containing the static method</li>
 42  
   * </ul>
 43  
   * </p>
 44  
   *
 45  
   * @author <a href="mailto:robert@bull-enterprises.com>Robert McIntosh</a>
 46  
   * @version $Revision: 155420 $
 47  
   */
 48  
 public class InvokeStaticTag extends TagSupport implements ArgTagParent {
 49  
 
 50  
     /** the variable exported */
 51  
     private String var;
 52  
 
 53  
     /** the variable where the method's exception is exported */
 54  
     private String exceptionVar;
 55  
 
 56  
     /** the method to invoke */
 57  
     private String methodName;
 58  
 
 59  
     /** the object to invoke the method on */
 60  
     private String className;
 61  
 
 62  65
     private List paramTypes = new ArrayList();
 63  65
     private List paramValues = new ArrayList();
 64  
 
 65  65
     public InvokeStaticTag() {
 66  65
     }
 67  
 
 68  
     /**
 69  
      * Sets the name of the variable exported by this tag
 70  
      *
 71  
      * @param var The variable name
 72  
      */
 73  
     public void setVar(String var) {
 74  39
         this.var = class="keyword">var;
 75  39
     }
 76  
 
 77  
     /** Sets the name of a variable that exports the exception thrown by
 78  
      * the method's invocation (if any)
 79  
      */
 80  
     public void setExceptionVar(String var) {
 81  13
         this.exceptionVar = var;
 82  13
     }
 83  
 
 84  
     /**
 85  
      * Sets the name of the method to invoke
 86  
      *
 87  
      * @param method The method name
 88  
      */
 89  
     public void setMethod(String methodName) {
 90  65
         this.methodName = methodName;
 91  65
     }
 92  
 
 93  
     /**
 94  
      * Sets the fully qualified class name containing the static method
 95  
      *
 96  
      * @param className The name of the class
 97  
      */
 98  
     public void setClassName(String className) {
 99  65
         this.className = className;
 100  65
     }
 101  
 
 102  
     /**
 103  
      * Adds an argument to supply to the method
 104  
      *
 105  
      * @param type The Class type of the argument
 106  
      * @param value The value of the argument
 107  
      */
 108  
     public void addArgument(Class type, Object value) {
 109  91
         paramTypes.add(type);
 110  91
         paramValues.add(value);
 111  91
     }
 112  
 
 113  
     // Tag interface
 114  
     //-------------------------------------------------------------------------
 115  
     public void doTag(XMLOutput output) throws JellyTagException {
 116  
         try {
 117  65
             if ( null == methodName) {
 118  0
                 throw new MissingAttributeException( "method" );
 119  
             }
 120  65
             invokeBody(output);
 121  
 
 122  65
             Object[] values = paramValues.toArray();
 123  65
             Class[] types = (Class[])(paramTypes.toArray(new Class[paramTypes.size()]));
 124  65
             Method method = loadClass().getMethod( methodName, types );
 125  65
             Object result = method.invoke( null, values );
 126  39
             if(null != var) {
 127  39
                 context.setVariable(var, result);
 128  
             }
 129  
 
 130  52
             ArgTag parentArg = (ArgTag)(findAncestorWithClass(ArgTag.class));
 131  39
             if(null != parentArg) {
 132  0
                 parentArg.setValue(result);
 133  
             }
 134  
         }
 135  0
         catch (ClassNotFoundException e) {
 136  0
             throw createLoadClassFailedException(e);
 137  
         }
 138  0
         catch (NoSuchMethodException e) {
 139  0
             throw createLoadClassFailedException(e);
 140  
         }
 141  0
         catch (IllegalAccessException e) {
 142  0
             throw createLoadClassFailedException(e);
 143  
         }
 144  26
         catch (InvocationTargetException e) {
 145  26
             if(null != exceptionVar) {
 146  13
                 context.setVariable(exceptionVar,e.getTargetException());
 147  13
             } else {
 148  13
                 throw new JellyTagException("method " + methodName +
 149  
                     " threw exception: "+ e.getTargetException().getMessage(),
 150  
                     e.getTargetException() );
 151  
             }
 152  
         }
 153  
         finally {
 154  65
             paramTypes.clear();
 155  65
             paramValues.clear();
 156  65
         }
 157  52
     }
 158  
 
 159  
     // Tag interface
 160  
     //-------------------------------------------------------------------------
 161  
 
 162  
     /**
 163  
      * Loads the class using either the class loader which loaded me or the
 164  
      * current threads context class loader
 165  
      */
 166  
     protected Class loadClass() throws ClassNotFoundException {
 167  65
         return ClassLoaderUtils.loadClass(className, getClass());
 168  
     }
 169  
 
 170  
     /**
 171  
      * Factory method to create a new JellyTagException instance from a given
 172  
      * failure exception
 173  
      * @param e is the exception which occurred attempting to load the class
 174  
      * @return JellyTagException
 175  
      */
 176  
     protected JellyTagException createLoadClassFailedException(Exception e) {
 177  0
         return new JellyTagException(
 178  
             "Could not load class: " + className + ". Reason: " + e, e
 179  
         );
 180  
     }
 181  
 }
 182  
 

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