Example #1
0
 public Map<TypeVariable<?>, Type> getGenericArgumentMap(Type... arguments) {
   if (arguments != null
       && representingClass.getTypeParameters().length != arguments.length
       && arguments.length != 0) {
     throw new IllegalArgumentException(
         "arguments length != " + representingClass.getTypeParameters().length);
   }
   GenericInfo<T> genericInfo = applyArguments0(arguments);
   return Collections.unmodifiableMap(genericInfo.genericArgumentMap);
 }
Example #2
0
  /**
   * A simplistic implementation, it may not handle all cases but it should handle enough.
   *
   * @param implementation the type for which the parameter requires a resolution
   * @param type the type that owns the parameter
   * @param parameterIndex the parameter index
   * @return the resolved type
   */
  public static Type resolve(Type implementation, Class<?> type, int parameterIndex) {
    if (implementation == null) {
      throw new NullPointerException();
    }

    //
    if (implementation == type) {
      TypeVariable<? extends Class<?>>[] tp = type.getTypeParameters();
      if (parameterIndex < tp.length) {
        return tp[parameterIndex];
      } else {
        throw new IllegalArgumentException();
      }
    } else if (implementation instanceof Class<?>) {
      Class<?> c = (Class<?>) implementation;
      Type gsc = c.getGenericSuperclass();
      Type resolved = null;
      if (gsc != null) {
        resolved = resolve(gsc, type, parameterIndex);
        if (resolved == null) {
          // Try with interface
        }
      }
      return resolved;
    } else if (implementation instanceof ParameterizedType) {
      ParameterizedType pt = (ParameterizedType) implementation;
      Type[] typeArgs = pt.getActualTypeArguments();
      Type rawType = pt.getRawType();
      if (rawType == type) {
        return typeArgs[parameterIndex];
      } else if (rawType instanceof Class<?>) {
        Class<?> classRawType = (Class<?>) rawType;
        Type resolved = resolve(classRawType, type, parameterIndex);
        if (resolved == null) {
          return null;
        } else if (resolved instanceof TypeVariable) {
          TypeVariable resolvedTV = (TypeVariable) resolved;
          TypeVariable[] a = classRawType.getTypeParameters();
          for (int i = 0; i < a.length; i++) {
            if (a[i].equals(resolvedTV)) {
              return resolve(implementation, classRawType, i);
            }
          }
          throw new AssertionError();
        } else {
          throw new UnsupportedOperationException("Cannot support resolution of " + resolved);
        }
      } else {
        throw new UnsupportedOperationException();
      }
    } else {
      throw new UnsupportedOperationException(
          "todo " + implementation + " " + implementation.getClass());
    }
  }
  /** Checks for validity for classpath scanning. */
  public static boolean isValid(Class<?> type) {
    if (type.isInterface()) return false;

    if (type.getTypeParameters() != null && type.getTypeParameters().length > 0) {
      return false;
    }

    if (!isValidConstructor(type)) return false;

    return true;
  }
Example #4
0
  /** Resolves <code>TypeVariable</code> with given implementation class. */
  public static Type resolveVariable(TypeVariable variable, final Class implClass) {
    final Class rawType = getRawType(implClass, null);

    int index = ArraysUtil.indexOf(rawType.getTypeParameters(), variable);
    if (index >= 0) {
      return variable;
    }

    final Class[] interfaces = rawType.getInterfaces();
    final Type[] genericInterfaces = rawType.getGenericInterfaces();

    for (int i = 0; i <= interfaces.length; i++) {
      Class rawInterface;

      if (i < interfaces.length) {
        rawInterface = interfaces[i];
      } else {
        rawInterface = rawType.getSuperclass();
        if (rawInterface == null) {
          continue;
        }
      }

      final Type resolved = resolveVariable(variable, rawInterface);
      if (resolved instanceof Class || resolved instanceof ParameterizedType) {
        return resolved;
      }

      if (resolved instanceof TypeVariable) {
        final TypeVariable typeVariable = (TypeVariable) resolved;
        index = ArraysUtil.indexOf(rawInterface.getTypeParameters(), typeVariable);

        if (index < 0) {
          throw new IllegalArgumentException("Invalid type variable:" + typeVariable);
        }

        final Type type =
            i < genericInterfaces.length ? genericInterfaces[i] : rawType.getGenericSuperclass();

        if (type instanceof Class) {
          return Object.class;
        }

        if (type instanceof ParameterizedType) {
          return ((ParameterizedType) type).getActualTypeArguments()[index];
        }

        throw new IllegalArgumentException("Unsupported type: " + type);
      }
    }
    return null;
  }
 private ReferenceTypeUsage toReferenceTypeUsage(Class<?> clazz, Type type) {
   TypeDefinition typeDefinition = new ReflectionBasedTypeDefinition(clazz);
   ReferenceTypeUsage referenceTypeUsage = new ReferenceTypeUsage(typeDefinition);
   if (type instanceof ParameterizedType) {
     ParameterizedType parameterizedType = (ParameterizedType) type;
     for (int tp = 0; tp < clazz.getTypeParameters().length; tp++) {
       TypeVariable<? extends Class<?>> typeVariable = clazz.getTypeParameters()[tp];
       Type parameterType = parameterizedType.getActualTypeArguments()[tp];
       referenceTypeUsage
           .getTypeParameterValues()
           .add(typeVariable.getName(), toTypeUsage(parameterType));
     }
   }
   return referenceTypeUsage;
 }
Example #6
0
  /**
   * @param cls
   * @param toClass
   * @param subtypeVarAssigns
   * @return
   */
  private static Map<TypeVariable<?>, Type> getTypeArguments(
      Class<?> cls, Class<?> toClass, Map<TypeVariable<?>, Type> subtypeVarAssigns) {
    // make sure they're assignable
    if (!isAssignable(cls, toClass)) {
      return null;
    }

    // can't work with primitives
    if (cls.isPrimitive()) {
      // both classes are primitives?
      if (toClass.isPrimitive()) {
        // dealing with widening here. No type arguments to be
        // harvested with these two types.
        return new HashMap<TypeVariable<?>, Type>();
      }

      // work with wrapper the wrapper class instead of the primitive
      cls = ClassUtils.primitiveToWrapper(cls);
    }

    // create a copy of the incoming map, or an empty one if it's null
    HashMap<TypeVariable<?>, Type> typeVarAssigns =
        subtypeVarAssigns == null
            ? new HashMap<TypeVariable<?>, Type>()
            : new HashMap<TypeVariable<?>, Type>(subtypeVarAssigns);

    // no arguments for the parameters, or target class has been reached
    if (cls.getTypeParameters().length > 0 || toClass.equals(cls)) {
      return typeVarAssigns;
    }

    // walk the inheritance hierarchy until the target class is reached
    return getTypeArguments(getClosestParentType(cls, toClass), toClass, typeVarAssigns);
  }
 private void readActualTypeParametersOnDeclaringClass() {
   registerTypeParametersOn(clazz.getTypeParameters());
   registerTypeVariablesOn(clazz.getGenericSuperclass());
   for (Type genericInterface : clazz.getGenericInterfaces()) {
     registerTypeVariablesOn(genericInterface);
   }
 }
Example #8
0
 public static boolean isParamerterizedTypeWithWildcard(Class<?> type) {
   if (isParameterizedType(type)) {
     return containsWildcards(type.getTypeParameters());
   } else {
     return false;
   }
 }
 private static Map getTypeArguments(
     ParameterizedType paramParameterizedType, Class paramClass, Map paramMap) {
   Class localClass = getRawType(paramParameterizedType);
   Object localObject;
   if (!isAssignable(localClass, paramClass)) localObject = null;
   do {
     return localObject;
     Type localType1 = paramParameterizedType.getOwnerType();
     if ((localType1 instanceof ParameterizedType)) {
       ParameterizedType localParameterizedType = (ParameterizedType) localType1;
       localObject =
           getTypeArguments(localParameterizedType, getRawType(localParameterizedType), paramMap);
     }
     while (true) {
       Type[] arrayOfType = paramParameterizedType.getActualTypeArguments();
       TypeVariable[] arrayOfTypeVariable = localClass.getTypeParameters();
       for (int i = 0; i < arrayOfTypeVariable.length; i++) {
         Type localType2 = arrayOfType[i];
         TypeVariable localTypeVariable = arrayOfTypeVariable[i];
         if (((Map) localObject).containsKey(localType2))
           localType2 = (Type) ((Map) localObject).get(localType2);
         ((Map) localObject).put(localTypeVariable, localType2);
       }
       if (paramMap == null) localObject = new HashMap();
       else localObject = new HashMap(paramMap);
     }
   } while (paramClass.equals(localClass));
   return getTypeArguments(
       getClosestParentType(localClass, paramClass), paramClass, (Map) localObject);
 }
Example #10
0
  private void doApplyArguments(Class<?> representingClass, Type[] actualArguments) {
    TypeVariable<?>[] declaredArguments = representingClass.getTypeParameters();

    if (declaredArguments.length == 0) { // declaredArguments==0
      assert (listenerMapping.size() == 0); // TODO ?
      // do nothing
    } else if (actualArguments == null || actualArguments.length == 0) { // actualArguments==0
      List<TypeVariable<?>> toHandleArguments = new LinkedList<TypeVariable<?>>();
      for (TypeVariable<?> declaredArgument : declaredArguments) {
        toHandleArguments.add(declaredArgument);
      }
      Map<TypeVariable<?>, Type> handledArguments = new HashMap<TypeVariable<?>, Type>();
      while (toHandleArguments.size() > 0) {
        for (Iterator<TypeVariable<?>> iterator = toHandleArguments.iterator();
            iterator.hasNext(); ) {
          TypeVariable<?> declaredArgument = iterator.next();
          //					Type defaultType = getDefaultType(declaredArgument.getBounds(), handledArguments,
          // declaredArgument);
          Type defaultType = getDefaultType(declaredArgument, handledArguments);
          if (defaultType != null) { // 没有保存==null的中间状态
            iterator.remove();
            handledArguments.put(declaredArgument, defaultType);
            changeGeneric(declaredArgument, defaultType);
          }
        }
      }
    } else { // actualArguments!=0
      for (int i = 0; i < declaredArguments.length; i++) {
        Type actualArgument = actualArguments[i];
        TypeVariable<?> declaredParameter = declaredArguments[i];
        parseArgument(declaredParameter, actualArgument);
      }
    }
  }
  private void buildGenericTypeVariables(Class<?>[] genericTypes) {
    if (samType.getTypeParameters().length != genericTypes.length)
      throw new LambdaException(
          "SAM class [%s] requires [%d] generic type variables, but only [%d] where provided",
          samType.getName(), samType.getTypeParameters().length, genericTypes.length);

    for (int i = 0; i < samType.getTypeParameters().length; i++) {
      TypeVariable typeVariable = samType.getTypeParameters()[i];
      for (Type bound : typeVariable.getBounds())
        if (bound instanceof Class<?> && !((Class) bound).isAssignableFrom(genericTypes[i]))
          throw new LambdaException(
              "SAM class [%s] generic type variable [%d, %s] is not compatible with generic parameter [%s]",
              samType.getName(), i, samType.getTypeParameters()[i].toString(), genericTypes[i]);
      materializedTypeVariableses.add(
          new MaterializedTypeVariable(typeVariable.getName(), genericTypes[i]));
    }
  }
Example #12
0
 ParameterizedTypeImpl(@Nullable Type var1, Class<?> var2, Type[] var3) {
   Preconditions.checkNotNull(var2);
   Preconditions.checkArgument(var3.length == var2.getTypeParameters().length);
   Types.disallowPrimitiveType(var3, "type parameter");
   this.ownerType = var1;
   this.rawType = var2;
   this.argumentsList = Types.JavaVersion.CURRENT.usedInGenericType(var3);
 }
Example #13
0
 ParameterizedTypeImpl(@Nullable Type ownerType, Class<?> rawType, Type[] typeArguments) {
   checkNotNull(rawType);
   checkArgument(typeArguments.length == rawType.getTypeParameters().length);
   disallowPrimitiveType(typeArguments, "type parameter");
   this.ownerType = ownerType;
   this.rawType = rawType;
   this.argumentsList = JavaVersion.CURRENT.usedInGenericType(typeArguments);
 }
Example #14
0
 public Map<TypeVariable<?>, Type> getVariableGenericArgumentMap() {
   Map<TypeVariable<?>, Type> genericArgumentMap = cloneGenericArgumentMap();
   TypeVariable<?>[] declaredArguments = representingClass.getTypeParameters();
   for (TypeVariable<?> var : declaredArguments) {
     genericArgumentMap.put(var, var);
   }
   return genericArgumentMap;
 }
Example #15
0
  private static ClassTypePair resolveTypeVariable(
      ParameterizedType pt, Class c, Class dc, TypeVariable tv, Map<TypeVariable, Type> map) {
    Type[] typeArguments = pt.getActualTypeArguments();

    TypeVariable[] typeParameters = c.getTypeParameters();

    Map<TypeVariable, Type> submap = new HashMap<TypeVariable, Type>();
    for (int i = 0; i < typeArguments.length; i++) {
      // Substitute a type variable with the Java class
      if (typeArguments[i] instanceof TypeVariable) {
        Type t = map.get(typeArguments[i]);
        submap.put(typeParameters[i], t);
      } else {
        submap.put(typeParameters[i], typeArguments[i]);
      }
    }

    if (c == dc) {
      Type t = submap.get(tv);
      if (t instanceof Class) {
        return new ClassTypePair((Class) t);
      } else if (t instanceof GenericArrayType) {
        t = ((GenericArrayType) t).getGenericComponentType();
        if (t instanceof Class) {
          c = (Class) t;
          try {
            return new ClassTypePair(getArrayClass(c));
          } catch (Exception e) {
          }
          return null;
        } else if (t instanceof ParameterizedType) {
          Type rt = ((ParameterizedType) t).getRawType();
          if (rt instanceof Class) {
            c = (Class) rt;
          } else {
            return null;
          }
          try {
            return new ClassTypePair(getArrayClass(c), t);
          } catch (Exception e) {
            return null;
          }
        } else {
          return null;
        }
      } else if (t instanceof ParameterizedType) {
        pt = (ParameterizedType) t;
        if (pt.getRawType() instanceof Class) {
          return new ClassTypePair((Class) pt.getRawType(), pt);
        } else return null;
      } else {
        return null;
      }
    } else {
      return resolveTypeVariable(c, dc, tv, submap);
    }
  }
Example #16
0
  public DiType(@NotNull Class<?> clazz, @NotNull List<DiType> typeParameters) {
    this.clazz = clazz;
    this.typeParameters = typeParameters;

    if (clazz.getTypeParameters().length != typeParameters.size()) {
      throw new IllegalStateException(
          "type parameter count mismatch: " + clazz + ", " + typeParameters);
    }
  }
Example #17
0
 private Class<?> findConcreteType(
     Type generic, Class<?> resource, Map<String, Type> parametersMap)
     throws ClassNotFoundException {
   for (Type superInterface : resource.getGenericInterfaces()) {
     if (superInterface instanceof ParameterizedType) {
       ParameterizedType p = (ParameterizedType) superInterface;
       Class<?> clazz =
           Class.forName(
               p.getRawType()
                   .toString()
                   .substring(p.getRawType().toString().lastIndexOf(' ') + 1));
       Map<String, Type> map = new HashMap<>();
       for (int i = 0; i < p.getActualTypeArguments().length; i++) {
         if (!map.containsKey(clazz.getTypeParameters()[i].toString())) {
           map.put(clazz.getTypeParameters()[i].toString(), p.getActualTypeArguments()[i]);
         }
       }
       if (map.containsKey(generic.toString())) {
         String type = map.get(generic.toString()).toString();
         try {
           Class<?> returnClass = Class.forName(type.substring(type.lastIndexOf(' ') + 1));
           return returnClass;
         } catch (ClassNotFoundException e) {
           break;
         }
       }
     }
   }
   if (parametersMap.containsKey(generic.toString())) {
     try {
       Type type = parametersMap.get(generic.toString());
       Class<?> returnClass =
           Class.forName(type.toString().substring(type.toString().indexOf(' ') + 1));
       return returnClass;
     } catch (ClassNotFoundException e) {
       return null;
     }
   } else {
     return null;
   }
 }
 private void validateConstructorArguments() {
   TypeVariable /*<?>*/[] formals = rawType.getTypeParameters();
   // check correct arity of actual type args
   if (formals.length != actualTypeArguments.length) {
     throw new MalformedParameterizedTypeException();
   }
   /*
           for (int i = 0; i < actualTypeArguments.length; i++) {
               // check actuals against formals' bounds
           }
   */
 }
Example #19
0
 @Override
 void visitParameterizedType(ParameterizedType parameterizedType) {
   Class<?> rawClass = (Class<?>) parameterizedType.getRawType();
   TypeVariable<?>[] vars = rawClass.getTypeParameters();
   Type[] typeArgs = parameterizedType.getActualTypeArguments();
   checkState(vars.length == typeArgs.length);
   for (int i = 0; i < vars.length; i++) {
     map(vars[i], typeArgs[i]);
   }
   visit(rawClass);
   visit(parameterizedType.getOwnerType());
 }
  /** Private recursive helper function to actually do the type-safe checking of assignability. */
  private static boolean isAssignableFrom(
      Type from, ParameterizedType to, Map<String, Type> typeVarMap) {

    if (from == null) {
      return false;
    }

    if (to.equals(from)) {
      return true;
    }

    // First figure out the class and any type information.
    Class<?> clazz = getRawType(from);
    ParameterizedType ptype = null;
    if (from instanceof ParameterizedType) {
      ptype = (ParameterizedType) from;
    }

    // Load up parameterized variable info if it was parameterized.
    if (ptype != null) {
      Type[] tArgs = ptype.getActualTypeArguments();
      TypeVariable<?>[] tParams = clazz.getTypeParameters();
      for (int i = 0; i < tArgs.length; i++) {
        Type arg = tArgs[i];
        TypeVariable<?> var = tParams[i];
        while (arg instanceof TypeVariable) {
          TypeVariable<?> v = (TypeVariable<?>) arg;
          arg = typeVarMap.get(v.getName());
        }
        typeVarMap.put(var.getName(), arg);
      }

      // check if they are equivalent under our current mapping.
      if (typeEquals(ptype, to, typeVarMap)) {
        return true;
      }
    }

    for (Type itype : clazz.getGenericInterfaces()) {
      if (isAssignableFrom(itype, to, new HashMap<String, Type>(typeVarMap))) {
        return true;
      }
    }

    // Interfaces didn't work, try the superclass.
    Type sType = clazz.getGenericSuperclass();
    if (isAssignableFrom(sType, to, new HashMap<String, Type>(typeVarMap))) {
      return true;
    }

    return false;
  }
Example #21
0
 /**
  * Returns the arguments of the provided generic class or interface.
  *
  * @param type the class to search.
  * @param args the class arguments.
  * @param clazz the generic class or interface of interest.
  * @return the arguments of the generic class or interface, or <code>null</code> if not found.
  */
 protected static Type[] getTypeArguments(Class<?> type, Type[] args, Class<?> clazz) {
   if (type == clazz) {
     return args;
   }
   TypeVariable[] params = type.getTypeParameters();
   for (Type iface : type.getGenericInterfaces()) {
     Type[] result = getTypeArguments(iface, params, args, clazz);
     if (result != null) {
       return result;
     }
   }
   return getTypeArguments(type.getGenericSuperclass(), params, args, clazz);
 }
Example #22
0
  /**
   * @param parameterizedType
   * @param toClass
   * @param subtypeVarAssigns
   * @return
   */
  private static Map<TypeVariable<?>, Type> getTypeArguments(
      ParameterizedType parameterizedType,
      Class<?> toClass,
      Map<TypeVariable<?>, Type> subtypeVarAssigns) {
    Class<?> cls = getRawType(parameterizedType);

    // make sure they're assignable
    if (!isAssignable(cls, toClass)) {
      return null;
    }

    Type ownerType = parameterizedType.getOwnerType();
    Map<TypeVariable<?>, Type> typeVarAssigns;

    if (ownerType instanceof ParameterizedType) {
      // get the owner type arguments first
      ParameterizedType parameterizedOwnerType = (ParameterizedType) ownerType;
      typeVarAssigns =
          getTypeArguments(
              parameterizedOwnerType, getRawType(parameterizedOwnerType), subtypeVarAssigns);
    } else {
      // no owner, prep the type variable assignments map
      typeVarAssigns =
          subtypeVarAssigns == null
              ? new HashMap<TypeVariable<?>, Type>()
              : new HashMap<TypeVariable<?>, Type>(subtypeVarAssigns);
    }

    // get the subject parameterized type's arguments
    Type[] typeArgs = parameterizedType.getActualTypeArguments();
    // and get the corresponding type variables from the raw class
    TypeVariable<?>[] typeParams = cls.getTypeParameters();

    // map the arguments to their respective type variables
    for (int i = 0; i < typeParams.length; i++) {
      Type typeArg = typeArgs[i];
      typeVarAssigns.put(
          typeParams[i],
          typeVarAssigns.containsKey(typeArg) ? typeVarAssigns.get(typeArg) : typeArg);
    }

    if (toClass.equals(cls)) {
      // target class has been reached. Done.
      return typeVarAssigns;
    }

    // walk the inheritance hierarchy until the target class is reached
    return getTypeArguments(getClosestParentType(cls, toClass), toClass, typeVarAssigns);
  }
Example #23
0
  public static void main(String... args) {
    try {
      Class<?> c = Class.forName(args[0]);
      out.format("Class:%n  %s%n%n", c.getCanonicalName());
      out.format("Modifiers:%n  %s%n%n", Modifier.toString(c.getModifiers()));

      out.format("Type Parameters:%n");
      TypeVariable<?>[] tv = c.getTypeParameters();
      if (tv.length != 0) {
        out.format("  ");
        for (TypeVariable<?> t : tv) out.format("%s ", t.getName());
        out.format("%n%n");
      } else {
        out.format("  -- No Type Parameters --%n%n");
      }

      out.format("Implemented Interfaces:%n");
      Type[] intfs = c.getGenericInterfaces();
      if (intfs.length != 0) {
        for (Type intf : intfs) out.format("  %s%n", intf.toString());
        out.format("%n");
      } else {
        out.format("  -- No Implemented Interfaces --%n%n");
      }

      out.format("Inheritance Path:%n");
      List<Class<?>> l = new ArrayList<Class<?>>();
      printAncestor(c, l);
      if (l.size() != 0) {
        for (Class<?> cl : l) out.format("  %s%n", cl.getCanonicalName());
        out.format("%n");
      } else {
        out.format("  -- No Super Classes --%n%n");
      }

      out.format("Annotations:%n");
      Annotation[] ann = c.getAnnotations();
      if (ann.length != 0) {
        for (Annotation a : ann) out.format("  %s%n", a.toString());
        out.format("%n");
      } else {
        out.format("  -- No Annotations --%n%n");
      }

      // production code should handle this exception more gracefully
    } catch (ClassNotFoundException x) {
      x.printStackTrace();
    }
  }
Example #24
0
 private static void mapTypeVariablesToArguments(
     Class paramClass, ParameterizedType paramParameterizedType, Map paramMap) {
   Type localType1 = paramParameterizedType.getOwnerType();
   if ((localType1 instanceof ParameterizedType))
     mapTypeVariablesToArguments(paramClass, (ParameterizedType) localType1, paramMap);
   Type[] arrayOfType = paramParameterizedType.getActualTypeArguments();
   TypeVariable[] arrayOfTypeVariable = getRawType(paramParameterizedType).getTypeParameters();
   List localList = Arrays.asList(paramClass.getTypeParameters());
   for (int i = 0; i < arrayOfType.length; i++) {
     TypeVariable localTypeVariable = arrayOfTypeVariable[i];
     Type localType2 = arrayOfType[i];
     if ((localList.contains(localType2)) && (paramMap.containsKey(localTypeVariable)))
       paramMap.put((TypeVariable) localType2, paramMap.get(localTypeVariable));
   }
 }
  /**
   * @param parameters the parameters of a direct superclass or interface
   * @param childClass an extending class
   * @param childParameters the actual parameters of the extending class
   * @return the actual parameters of the direct superclass or interface, return null if it's
   *     impossible to resolve
   */
  public static Type[] resolveSuperArguments(
      Type[] parameters, Class childClass, Type[] childParameters) {
    Map<TypeVariable, Type> typeMapping;
    if (childParameters != null) {
      TypeVariable<Class>[] declaredChildParameters = childClass.getTypeParameters();

      typeMapping = new HashMap<TypeVariable, Type>();
      for (int i = 0; i < declaredChildParameters.length; ++i) {
        typeMapping.put(declaredChildParameters[i], childParameters[i]);
      }
    } else {
      typeMapping = Collections.emptyMap();
    }

    return resolveTypes(parameters, typeMapping);
  }
Example #26
0
  static Type resolveTypeVariable(Type context, Class<?> contextRawType, TypeVariable<?> unknown) {
    Class<?> declaredByRaw = declaringClassOf(unknown);

    // we can't reduce this further
    if (declaredByRaw == null) {
      return unknown;
    }

    Type declaredBy = getGenericSupertype(context, contextRawType, declaredByRaw);
    if (declaredBy instanceof ParameterizedType) {
      int index = indexOf(declaredByRaw.getTypeParameters(), unknown);
      return ((ParameterizedType) declaredBy).getActualTypeArguments()[index];
    }

    return unknown;
  }
 /** Return a {@link Serializable} variant of {@link Class#getTypeParameters()}. */
 @SuppressWarnings("serial")
 public static Type[] forTypeParameters(final Class<?> type) {
   Type[] result = new Type[type.getTypeParameters().length];
   for (int i = 0; i < result.length; i++) {
     final int index = i;
     result[i] =
         forTypeProvider(
             new DefaultTypeProvider() {
               @Override
               public Type getType() {
                 return type.getTypeParameters()[index];
               }
             });
   }
   return result;
 }
Example #28
0
 private static Map getTypeArguments(Class paramClass1, Class paramClass2, Map paramMap) {
   Object localObject;
   if (!isAssignable(paramClass1, paramClass2)) localObject = null;
   while (true) {
     return localObject;
     if (paramClass1.isPrimitive()) {
       if (paramClass2.isPrimitive()) return new HashMap();
       paramClass1 = ClassUtils.primitiveToWrapper(paramClass1);
     }
     if (paramMap == null) ;
     for (localObject = new HashMap();
         (paramClass1.getTypeParameters().length <= 0) && (!paramClass2.equals(paramClass1));
         localObject = new HashMap(paramMap))
       return getTypeArguments(
           getClosestParentType(paramClass1, paramClass2), paramClass2, (Map) localObject);
   }
 }
 protected static SimpleType _constructSimple(Class<?> rawType, JavaType[] parameterTypes) {
   // Quick sanity check: must match numbers of types with expected...
   TypeVariable<?>[] typeVars = rawType.getTypeParameters();
   if (typeVars.length != parameterTypes.length) {
     throw new IllegalArgumentException(
         "Parameter type mismatch for "
             + rawType.getName()
             + ": expected "
             + typeVars.length
             + " parameters, was given "
             + parameterTypes.length);
   }
   String[] names = new String[typeVars.length];
   for (int i = 0, len = typeVars.length; i < len; ++i) {
     names[i] = typeVars[i].getName();
   }
   return new SimpleType(rawType, names, parameterTypes);
 }
Example #30
0
 /** Build a string representation of a type and optionally its generic type arguments. */
 public static String type(Class<?> raw, String... parameters) {
   if (parameters.length == 0) {
     return raw.getCanonicalName();
   }
   if (raw.getTypeParameters().length != parameters.length) {
     throw new IllegalArgumentException();
   }
   StringBuilder result = new StringBuilder();
   result.append(raw.getCanonicalName());
   result.append("<");
   result.append(parameters[0]);
   for (int i = 1; i < parameters.length; i++) {
     result.append(", ");
     result.append(parameters[i]);
   }
   result.append(">");
   return result.toString();
 }