Coverage report

  %line %branch
org.apache.commons.jexl.util.introspection.IntrospectorBase
76% 
100% 

 1  
 /*
 2  
  * Copyright 2001,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  
 
 17  
 package org.apache.commons.jexl.util.introspection;
 18  
 
 19  
 import java.util.Map;
 20  
 import java.util.Set;
 21  
 import java.util.HashMap;
 22  
 import java.util.HashSet;
 23  
 
 24  
 import java.lang.reflect.Method;
 25  
 
 26  
 /**
 27  
  * This basic function of this class is to return a Method object for a
 28  
  * particular class given the name of a method and the parameters to the method
 29  
  * in the form of an Object[]
 30  
  * 
 31  
  * The first time the Introspector sees a class it creates a class method map
 32  
  * for the class in question. Basically the class method map is a Hastable where
 33  
  * Method objects are keyed by a concatenation of the method name and the names
 34  
  * of classes that make up the parameters.
 35  
  * 
 36  
  * For example, a method with the following signature:
 37  
  * 
 38  
  * public void method(String a, StringBuffer b)
 39  
  * 
 40  
  * would be mapped by the key:
 41  
  * 
 42  
  * "method" + "java.lang.String" + "java.lang.StringBuffer"
 43  
  * 
 44  
  * This mapping is performed for all the methods in a class and stored for
 45  
  * 
 46  
  * @since 1.0
 47  
  * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
 48  
  * @author <a href="mailto:bob@werken.com">Bob McWhirter</a>
 49  
  * @author <a href="mailto:szegedia@freemail.hu">Attila Szegedi</a>
 50  
  * @author <a href="mailto:paulo.gaspar@krankikom.de">Paulo Gaspar</a>
 51  
  * @version $Id: IntrospectorBase.java 398464 2006-04-30 23:50:43Z dion $
 52  
  */
 53  8
 public class IntrospectorBase {
 54  
     /**
 55  
      * Holds the method maps for the classes we know about, keyed by Class
 56  
      * object.
 57  
      */
 58  4
     protected Map classMethodMaps = new HashMap();
 59  
 
 60  
     /**
 61  
      * Holds the qualified class names for the classes we hold in the
 62  
      * classMethodMaps hash.
 63  
      */
 64  4
     protected Set cachedClassNames = new HashSet();
 65  
 
 66  
     /**
 67  
      * Gets the method defined by <code>name</code> and <code>params</code>
 68  
      * for the Class <code>c</code>.
 69  
      * 
 70  
      * @param c Class in which the method search is taking place
 71  
      * @param name Name of the method being searched for
 72  
      * @param params An array of Objects (not Classes) that describe the the
 73  
      *            parameters
 74  
      * 
 75  
      * @return The desired Method object.
 76  
      * @throws Exception on any logical error.
 77  
      */
 78  
     public Method getMethod(Class c, String name, Object[] params) throws Exception {
 79  98
         if (c == null) {
 80  0
             throw new Exception("Introspector.getMethod(): Class method key was null: " + name);
 81  
         }
 82  
 
 83  98
         ClassMap classMap = null;
 84  
 
 85  98
         synchronized (classMethodMaps) {
 86  98
             classMap = (ClassMap) classMethodMaps.get(c);
 87  
 
 88  
             /*
 89  
              * if we don't have this, check to see if we have it by name. if so,
 90  
              * then we have a classloader change so dump our caches.
 91  
              */
 92  
 
 93  98
             if (classMap == null) {
 94  10
                 if (cachedClassNames.contains(c.getName())) {
 95  
                     /*
 96  
                      * we have a map for a class with same name, but not this
 97  
                      * class we are looking at. This implies a classloader
 98  
                      * change, so dump
 99  
                      */
 100  0
                     clearCache();
 101  
                 }
 102  
 
 103  10
                 classMap = createClassMap(c);
 104  
             }
 105  98
         }
 106  
 
 107  98
         return classMap.findMethod(name, params);
 108  
     }
 109  
 
 110  
     /**
 111  
      * Creates a class map for specific class and registers it in the cache.
 112  
      * Also adds the qualified name to the name->class map for later Classloader
 113  
      * change detection.
 114  
      * @param c class.
 115  
      * @return a {@link ClassMap}
 116  
      */
 117  
     protected ClassMap createClassMap(Class c) {
 118  10
         ClassMap classMap = new ClassMap(c);
 119  10
         classMethodMaps.put(c, classMap);
 120  10
         cachedClassNames.add(c.getName());
 121  
 
 122  10
         return classMap;
 123  
     }
 124  
 
 125  
     /**
 126  
      * Clears the classmap and classname caches.
 127  
      */
 128  
     protected void clearCache() {
 129  
         /*
 130  
          * since we are synchronizing on this object, we have to clear it rather
 131  
          * than just dump it.
 132  
          */
 133  0
         classMethodMaps.clear();
 134  
 
 135  
         /*
 136  
          * for speed, we can just make a new one and let the old one be GC'd
 137  
          */
 138  0
         cachedClassNames = new HashSet();
 139  0
     }
 140  
 }

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