Refine search
@Override public Collection<MetaClass> provideTypesToExpose() { final Set<MetaClass> types = new HashSet<MetaClass>(); for (final MetaClass metaClass : ClassScanner.getTypesAnnotatedWith(Remote.class)) { for (final MetaMethod method : metaClass.getDeclaredMethods()) { if (!method.getReturnType().isVoid()) { types.add(method.getReturnType().getErased()); } for (final MetaParameter parameter : method.getParameters()) { final MetaClass type = parameter.getType(); types.add(type.getErased()); final MetaParameterizedType parameterizedType = type.getParameterizedType(); if (parameterizedType != null) { for (final MetaType tp : parameterizedType.getTypeParameters()) { if (tp instanceof MetaClass) { types.add(((MetaClass) tp).getErased()); } } } } } } return types; } }
private String getTypeParmsString(final MetaParameterizedType parameterizedType) { final StringBuilder buf = new StringBuilder(512); if (parameterizedType != null && parameterizedType.getTypeParameters().length != 0) { buf.append("<"); for (int i = 0; i < parameterizedType.getTypeParameters().length; i++) { final MetaType typeParameter = parameterizedType.getTypeParameters()[i]; if (typeParameter instanceof MetaParameterizedType) { final MetaParameterizedType parameterizedTypeParameter = (MetaParameterizedType) typeParameter; buf.append(((MetaClass) parameterizedTypeParameter.getRawType()).getFullyQualifiedName()); buf.append(getTypeParmsString(parameterizedTypeParameter)); } else if (typeParameter instanceof MetaWildcardType) { buf.append(((MetaWildcardType) typeParameter).toString()); } else if (typeParameter instanceof MetaTypeVariable) { buf.append(typeParameter.getName()); } else { buf.append(((MetaClass) typeParameter).getFullyQualifiedName()); } if (i + 1 < parameterizedType.getTypeParameters().length) buf.append(", "); } buf.append(">"); } return buf.toString(); }
static boolean hasAssignableTypeParameters(final MetaClass fromType, final MetaClass toType) { final MetaParameterizedType toParamType = toType.getParameterizedType(); final Optional<MetaParameterizedType> fromParamType = GraphUtil.getFromTypeParams(fromType, toType); return toParamType == null || fromParamType.map(type -> toParamType.isAssignableFrom(type)).orElse(true); }
protected MetaClass[] getTypeArguments(final MetaClass type) { final MetaParameterizedType pType = type.getParameterizedType(); final MetaType[] typeArgs = (pType != null ? pType.getTypeParameters() : new MetaType[0]); final MetaClass[] typeArgsClasses = new MetaClass[typeArgs.length]; for (int i = 0; i < typeArgs.length; i++) { final MetaType argType = typeArgs[i]; if (argType instanceof MetaClass) { typeArgsClasses[i] = (MetaClass) argType; } else if (argType instanceof MetaParameterizedType) { typeArgsClasses[i] = (MetaClass) ((MetaParameterizedType) argType).getRawType(); } } return typeArgsClasses; }
private static Optional<MetaClass> getMetaClassFromGeneric(final MetaType genericType) { if (genericType instanceof MetaClass) { return Optional.of((MetaClass) genericType); } else if (genericType instanceof MetaParameterizedType && ((MetaParameterizedType) genericType).getRawType() instanceof MetaClass) { final MetaParameterizedType mpt = (MetaParameterizedType) genericType; @SuppressWarnings({ "unchecked", "rawtypes" }) final MetaType[] typeArgs = Arrays .stream(mpt.getTypeParameters()) .map(arg -> ((Optional<MetaType>) (Optional) getMetaClassFromGeneric(arg)).orElse(arg)) .toArray(MetaType[]::new); return Optional.of(parameterizedAs((MetaClass) mpt.getRawType(), typeParametersOf(typeArgs))); } else { return Optional.empty(); } }
if (!toProxy.isInterface()) { renderEqualsAndHash = true; if (toProxy.isFinal()) { throw new UnproxyableClassException(toProxy, toProxy.getFullyQualifiedName() + " is an unproxiable class because it is final"); int i = 0; for (final MetaTypeVariable metaTypeVariable : toProxy.getTypeParameters()) { typeVariableMap.put(metaTypeVariable.getName(), metaParameterizedType.getTypeParameters()[i++]);
@Test public void testFieldWithStringTypeParam() throws Exception { final MetaClass metaClass = getMetaClass(ClassWithGenericCollections.class); final MetaField field = metaClass.getDeclaredField("hasStringParam"); assertNotNull(field); assertEquals("Collection", field.getType().getName()); assertEquals("java.util.Collection", field.getType().getFullyQualifiedName()); assertEquals("<java.lang.String>", field.getType().getParameterizedType().toString()); assertEquals("java.util.Collection<java.lang.String>", field.getType().getFullyQualifiedNameWithTypeParms()); assertEquals("java.util.Collection", field.getType().getErased().getFullyQualifiedNameWithTypeParms()); assertEquals( Arrays.asList(getMetaClass(String.class)), Arrays.asList(field.getType().getParameterizedType().getTypeParameters())); }
private static BuildMetaClass cloneToBuildMetaClass(final MetaClass clazz, final MetaParameterizedType parameterizedType, final boolean reifyRecursively) { final BuildMetaClass buildMetaClass = new BuildMetaClass(null, clazz.getFullyQualifiedName()); buildMetaClass.setAbstract(clazz.isAbstract()); buildMetaClass.setFinal(clazz.isFinal()); buildMetaClass.setStatic(clazz.isStatic()); buildMetaClass.setInterface(clazz.isInterface()); for (final MetaType metaType : metaParameterizedType.getTypeParameters()) { if (metaType instanceof MetaTypeVariable) { final MetaTypeVariable typeVariable = (MetaTypeVariable) metaType;
private void validateExistingRolesPresent(final Collection<MetaClass> pages, final Multimap<Class<?>, MetaClass> pageRoles) { for (final MetaClass page : pages) { for (final MetaField field : getAllFields(page)) { if (field.getType().getErased().equals(MetaClassFactory.get(TransitionToRole.class))) { final MetaType uniquePageRole = field.getType().getParameterizedType().getTypeParameters()[0]; try { getPageWithRole(uniquePageRole, pageRoles); } catch (IllegalStateException e) { // give a more descriptive error message. throw new GenerationException("No @Page with the UniquePageRole " + uniquePageRole.getName() + " exists to satisfy TransitionToRole<" + uniquePageRole.getName() + "> in " + page.getFullyQualifiedName() + "." + "\nThere must be exactly 1 @Page with this role.", e); } } } } }
MetaMethod method = eventType.getBestMatchingMethod("getAssociatedType", Type.class); for (final MetaMethod m : eventType.getMethods()) { if ("getAssociatedType".equals(m.getName())) { method = m; + eventType.getName() + "]"); logger.debug("parameterizedType: " + parameterizedType.getClass() + " -- " + parameterizedType); final MetaType[] argTypes = parameterizedType.getTypeParameters(); if ((argTypes.length != 1) && argTypes[0] instanceof MetaClass && !((MetaClass) argTypes[0]).isAssignableTo(EventHandler.class)) {
for (final MetaClass iface : converter.getInterfaces()) { if (iface.getErased().equals(MetaClassFactory.get(Converter.class))) { final MetaParameterizedType parameterizedInterface = iface.getParameterizedType(); if (parameterizedInterface != null) { final MetaType[] typeArgs = parameterizedInterface.getTypeParameters(); if (typeArgs != null && typeArgs.length == 2) { registerConverterStatement = Stmt.invokeStatic(Convert.class, "registerDefaultConverter",
Page pageAnnotation = pageClass.getAnnotation(Page.class); List<Class<? extends PageRole>> roles = Arrays.asList(pageAnnotation.role()); if (roles.contains(DefaultPage.class)) { final MetaClass erasedFieldType = field.getType().getErased(); if (erasedFieldType.equals(transitionToType) || erasedFieldType.equals(transitionAnchorType) final MetaType uniquePageRoleType = field.getType().getParameterizedType().getTypeParameters()[0]; targetPageType = getPageWithRole(uniquePageRoleType, pageRoles); targetPageType = field.getType().getParameterizedType().getTypeParameters()[0];
private MetaClass getConstraintType(final MetaClass validator, final MetaClass constraintValidatorIface) { final MetaType annoTypeVariable = constraintValidatorIface.getParameterizedType().getTypeParameters()[0]; if (!(annoTypeVariable instanceof MetaClass)) { throw new RuntimeException("Cannot determine constraint type for " + validator.getFullyQualifiedName()); } final MetaClass annoType = (MetaClass) annoTypeVariable; return annoType; }
private static void addInterfaces(final MetaClass clazz, final BuildMetaClass buildMetaClass, final MetaParameterizedType parameterizedType) { final MetaType[] typeParams = (clazz.getParameterizedType() != null ? clazz.getParameterizedType().getTypeParameters() : clazz.getTypeParameters()); final MetaType[] typeArgs = parameterizedType.getTypeParameters(); validateTypeArgumentsAgainstParameters(clazz, typeParams, typeArgs); final Map<String, MetaType> typeArgsByTypeParam = mapTypeArgsByTypeParamName(typeParams, typeArgs); final List<MetaClass> ifaces = Arrays .stream(clazz.getInterfaces()) .map(iface -> getParameterizedInterface(typeArgsByTypeParam, iface)) .collect(Collectors.toList()); buildMetaClass.setInterfaces(ifaces); }
private static MetaType[] getTypeArgumentsForInterface(final Map<String, MetaType> typeArgsByTypeParam, final MetaClass iface) { return Arrays .stream(Optional.ofNullable(iface.getParameterizedType()) .map(i -> i.getTypeParameters()) .orElseGet(() -> iface.getTypeParameters())) .map(mt -> { if (typeArgsByTypeParam.containsKey(mt.getName())) { return typeArgsByTypeParam.get(mt.getName()); } else { return mt; } }).toArray(size -> new MetaType[size]); }
@Override public boolean isAssignableFrom(final MetaParameterizedType fromType) { final MetaType[] compareFrom = Assert.notNull(fromType).getTypeParameters(); final MetaType[] compareTo = getTypeParameters(); final MetaType to = compareTo[i]; if (from instanceof MetaClass && to instanceof MetaClass) { if (!((MetaClass) from).isAssignableTo((MetaClass) to)) { return false; final MetaClass fromMC = (MetaClass) from; final boolean violatesUpperBound = getConcreteBounds(((MetaWildcardType) to).getUpperBounds()) .filter(bound -> !fromMC.isAssignableTo(bound)) .findAny() .isPresent(); final boolean violatesLowerBound = getConcreteBounds(((MetaWildcardType) to).getLowerBounds()) .filter(bound -> !bound.isAssignableTo(fromMC)) .findAny() .isPresent();
@Test public void testMethodReturnTypeWithUpperBoundedWildcardParameter() { final MetaClass c = getMetaClass(ClassWithGenericMethods.class); final MetaMethod method = c.getMethod("methodReturningUpperBoundedWildcardCollection", new Class[] {}); // TODO (ERRAI-459) decide whether it's correct to have the type param present or not // then adjust this assertion to strict equality rather than startsWith() assertTrue(method.getReturnType().getFullyQualifiedNameWithTypeParms().startsWith("java.util.Collection")); final MetaType genericReturnType = method.getGenericReturnType(); assertNotNull(genericReturnType); assertTrue("Got unexpected return type type " + genericReturnType.getClass(), genericReturnType instanceof MetaParameterizedType); final MetaParameterizedType mpReturnType = (MetaParameterizedType) genericReturnType; assertEquals(1, mpReturnType.getTypeParameters().length); // Sole type parameter should be <? extends String> assertTrue(mpReturnType.getTypeParameters()[0] instanceof MetaWildcardType); final MetaWildcardType typeParam = (MetaWildcardType) mpReturnType.getTypeParameters()[0]; assertArrayEquals(new MetaType[] {}, typeParam.getLowerBounds()); assertArrayEquals(new MetaType[] { getMetaClass(String.class) }, typeParam.getUpperBounds()); }
parameterizedCallParmType = ((MetaClass) callParmType).getParameterizedType(); for (final MetaType typeParm : parameterizedMethodParmType.getTypeParameters()) { if (parameterizedCallParmType != null) { resolveTypeVariable(typeParm, ((MetaParameterizedType) parameterizedCallParmType).getTypeParameters()[typeParmIndex++]);
private Variable createForEachLoopVar(Statement collection, String loopVarName, MetaClass providedLoopVarType, Context context) { // infer the loop variable type MetaClass loopVarType = MetaClassFactory.get(Object.class); final MetaParameterizedType parameterizedType = collection.getType().getParameterizedType(); if (parameterizedType != null && parameterizedType.getTypeParameters().length != 0 && parameterizedType.getTypeParameters()[0] instanceof MetaClass) { loopVarType = (MetaClass) parameterizedType.getTypeParameters()[0]; } else if (collection.getType().getComponentType() != null) { loopVarType = collection.getType().getComponentType(); } // try to use the provided loop variable type if possible (assignable from the inferred type) if (providedLoopVarType != null) { GenUtil.assertAssignableTypes(context, loopVarType, providedLoopVarType); loopVarType = providedLoopVarType; } final Variable loopVar = Variable.create(loopVarName, loopVarType); context.addVariable(loopVar); return loopVar; }
dataModelType = (MetaClass) mp.getType().getParameterizedType().getTypeParameters()[0]; dataBinderRef = getAccessStatementForAutoBoundDataBinder(decorable, controller); dataModelType = (MetaClass) field.getType().getParameterizedType().getTypeParameters()[0]; dataBinderRef = DecorableType.FIELD.getAccessStatement(field, decorable.getFactoryMetaClass()); if (!field.isPublic()) { for (final MetaField field : enclosingType.getFields()) { if (field.isAnnotationPresent(AutoBound.class)) { assertTypeIsDataBinder(field.getType()); dataModelType = (MetaClass) field.getType().getParameterizedType().getTypeParameters()[0]; dataBinderRef = invokeStatic(decorable.getInjectionContext().getProcessingContext().getBootstrapClass(), PrivateAccessUtil.getPrivateFieldAccessorName(field),