Coverage Report - org.apache.tapestry.enhance.GenericsMethodSignatureImpl
 
Classes in this File Line Coverage Branch Coverage Complexity
GenericsMethodSignatureImpl
0%
0/45
0%
0/56
5
 
 1  
 //Copyright 2004, 2005 The Apache Software Foundation
 2  
 
 3  
 //Licensed under the Apache License, Version 2.0 (the "License");
 4  
 //you may not use this file except in compliance with the License.
 5  
 //You may obtain a copy of the License at
 6  
 
 7  
 //http://www.apache.org/licenses/LICENSE-2.0
 8  
 
 9  
 //Unless required by applicable law or agreed to in writing, software
 10  
 //distributed under the License is distributed on an "AS IS" BASIS,
 11  
 //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12  
 //See the License for the specific language governing permissions and
 13  
 //limitations under the License.
 14  
 package org.apache.tapestry.enhance;
 15  
 
 16  
 import java.lang.reflect.Method;
 17  
 import java.lang.reflect.ParameterizedType;
 18  
 import java.lang.reflect.Type;
 19  
 import java.lang.reflect.TypeVariable;
 20  
 
 21  
 
 22  
 /**
 23  
  * Implementation of {@link MethodSignature} that supports jdk 1.5 generic typing support.
 24  
  * 
 25  
  */
 26  
 public class GenericsMethodSignatureImpl extends MethodSignatureImpl implements MethodSignature
 27  
 {
 28  
     boolean _isGeneric;
 29  
     
 30  
     public GenericsMethodSignatureImpl(Class type, Method m)
 31  
     {
 32  0
         super(findReturnType(type, m), m.getName(), findParameterTypes(type, m), m.getExceptionTypes());
 33  
         
 34  0
         _isGeneric = type.getGenericSuperclass() != null && ParameterizedType.class.isInstance(type.getGenericSuperclass());
 35  0
     }
 36  
 
 37  
     public boolean isGeneric()
 38  
     {
 39  0
         return _isGeneric;
 40  
     }
 41  
     
 42  
     static Class findReturnType(Class type, Method m)
 43  
     {
 44  0
         Type ret = m.getGenericReturnType();
 45  
 
 46  0
         if (TypeVariable.class.isInstance(ret) 
 47  
                 && type.getGenericSuperclass() != null
 48  
                 && ParameterizedType.class.isInstance(type.getGenericSuperclass())) {
 49  
 
 50  0
             TypeVariable tvar = (TypeVariable)ret;
 51  0
             ParameterizedType param = (ParameterizedType)type.getGenericSuperclass();
 52  
 
 53  0
             Class resolvedType = resolveType(param, tvar);
 54  0
             if (resolvedType != null)
 55  0
                 return resolvedType;
 56  
             
 57  
         }
 58  
 
 59  0
         return m.getReturnType();
 60  
     }
 61  
 
 62  
     static Class resolveType(ParameterizedType param, TypeVariable var)
 63  
     {
 64  0
         if (param.getActualTypeArguments().length < 1)
 65  0
             return null;
 66  
 
 67  0
         for (int i=0; i < var.getBounds().length; i++) {
 68  
 
 69  0
             Type t = var.getBounds()[i];
 70  0
             Class resolvedType = null;
 71  0
             if (ParameterizedType.class.isInstance(t)) {
 72  
 
 73  0
                 ParameterizedType pparam = (ParameterizedType)t;
 74  0
                 for (int e=0; e < pparam.getActualTypeArguments().length; e++) {
 75  0
                     if (!TypeVariable.class.isInstance(pparam.getActualTypeArguments()[e]))
 76  0
                         continue;
 77  
                     
 78  0
                     resolvedType = resolveType(pparam, (TypeVariable)pparam.getActualTypeArguments()[e]);
 79  
                 }
 80  0
             } else {
 81  
 
 82  0
                 resolvedType = findType(param.getActualTypeArguments(), (Class)t);
 83  
             }
 84  
             
 85  0
             if (resolvedType != null)
 86  0
                 return resolvedType;
 87  
         }
 88  
 
 89  0
         return null;
 90  
     }
 91  
 
 92  
     static Class findType(Type[] types, Class type)
 93  
     {
 94  0
         for (int i = 0; i < types.length; i++) {
 95  
             
 96  0
             if (Class.class.isInstance(types[i]) && type.isAssignableFrom((Class)types[i]))
 97  0
                 return (Class)types[i];
 98  
         }
 99  
 
 100  0
         return null;
 101  
     }
 102  
 
 103  
     static Class[] findParameterTypes(Class type, Method m)
 104  
     {
 105  0
         if (type.getGenericSuperclass() == null
 106  
                 || !ParameterizedType.class.isInstance(type.getGenericSuperclass()))
 107  0
             return m.getParameterTypes();
 108  
 
 109  0
         ParameterizedType param = (ParameterizedType)type.getGenericSuperclass();
 110  0
         Type[] genTypes = m.getGenericParameterTypes();
 111  0
         Class[] types = new Class[genTypes.length];
 112  
 
 113  
         typeSearch:
 114  0
             for (int i=0; i < genTypes.length; i++) {
 115  
 
 116  0
                 if (TypeVariable.class.isInstance(genTypes[i])) {
 117  
 
 118  0
                     Class resolved = resolveType(param, (TypeVariable)genTypes[i]);
 119  
                     
 120  0
                     if (resolved != null) {
 121  0
                         types[i] = resolved;
 122  0
                         continue;
 123  
                     }
 124  
                 }
 125  
 
 126  0
                 types[i] = m.getParameterTypes()[i];
 127  
             }
 128  
 
 129  0
         return types;
 130  
     }
 131  
 
 132  
 
 133  
 }