@Override public MetaClass getType(final HasAnnotations annotated) { return ((MetaField) annotated).getType(); }
@Override public MetaClass getType() { return field == null ? MetaClassFactory.get(Object.class) : field.getType(); } };
/** * @return The exact type of this injection site. */ public MetaClass getExactType() { if (annotated instanceof MetaField) { return ((MetaField) annotated).getType(); } else if (annotated instanceof MetaParameter) { return ((MetaParameter) annotated).getType(); } else { throw new RuntimeException("Not yet implemented for annotated of type " + annotated.getClass().getName()); } }
private MetaClass getProducedType(final MetaClassMember member) { if (member instanceof MetaField) { return ((MetaField) member).getType(); } else if (member instanceof MetaMethod) { return ((MetaMethod) member).getReturnType(); } else { throw new RuntimeException("Producer members must be fields or methods, but found " + member); } }
@Override public MetaClass getType() { return field == null ? MetaClassFactory.get(Object.class) : field.getType(); } };
ObjectBuilder(final MetaClass type, final Context context, final CallElementBuilder callElementBuilder) { super(context, callElementBuilder); if (context != null) { context.attachClass(type); Arrays.stream(type.getDeclaredFields()). forEach(f -> context.addVariable(Variable.create(f.getName(), f.getType()))); } this.type = type; }
ObjectBuilder(final MetaClass type, final Context context, final CallElementBuilder callElementBuilder) { super(context, callElementBuilder); if (context != null) { context.attachClass(type); Arrays.stream(type.getDeclaredFields()). forEach(f -> context.addVariable(Variable.create(f.getName(), f.getType()))); } this.type = type; }
/** * Returns a string that uniquely identifies this field for purposes of * comparison with other implementations of {@link MetaField}. The returned * string includes the declaring class name, the field name, and the field's * type. * * @return */ public String hashString() { if (_hashString != null) return _hashString; return _hashString = MetaField.class.getName() + ":" + getDeclaringClass().getFullyQualifiedName() + "." + getName() + "::" + getType().getFullyQualifiedName(); }
/** * Returns a string that uniquely identifies this field for purposes of * comparison with other implementations of {@link MetaField}. The returned * string includes the declaring class name, the field name, and the field's * type. * * @return */ public String hashString() { if (_hashString != null) return _hashString; return _hashString = MetaField.class.getName() + ":" + getDeclaringClass().getFullyQualifiedName() + "." + getName() + "::" + getType().getFullyQualifiedName(); }
private Set<Class<?>> extractValidatableBeans(final Set<MetaClass> beans, final GeneratorContext context) { final Set<Class<?>> allBeans = new HashSet<Class<?>>(); for (final MetaClass bean : beans) { allBeans.add(bean.asClass()); } for (final MetaField field : ClassScanner.getFieldsAnnotatedWith(Valid.class, null, context)) { allBeans.add(field.getDeclaringClass().asClass()); allBeans.add(field.getType().asClass()); } for (final MetaMethod method : ClassScanner.getMethodsAnnotatedWith(Valid.class, null, context)) { allBeans.add(method.getDeclaringClass().asClass()); allBeans.add(method.getReturnType().asClass()); } return allBeans; }
public static String getPrivateFieldAccessorName(final MetaField field) { return field.getDeclaringClass().getName() + "_" + getTypeName(field.getType()) + "_" + field.getName(); }
public static String getPrivateFieldAccessorName(final MetaField field) { return field.getDeclaringClass().getName() + "_" + getTypeName(field.getType()) + "_" + field.getName(); }
private void addFieldInjectionPoints(final Injectable typeInjectable, final DependencyGraphBuilder builder, final List<String> problems) { final boolean noPublicFieldsAllowed = typeInjectable.getWiringElementTypes().contains(WiringElementType.NormalScopedBean); final MetaClass type = typeInjectable.getInjectedType(); final Collection<Class<? extends Annotation>> injectAnnotations = injectionContext.getAnnotationsForElementType(WiringElementType.InjectionPoint); for (final Class<? extends Annotation> inject : injectAnnotations) { for (final MetaField field : type.getFieldsAnnotatedWith(inject)) { if (noPublicFieldsAllowed && field.isPublic()) { problems.add("The normal scoped bean " + type.getFullyQualifiedName() + " has a public field " + field.getName()); } builder.addFieldDependency(typeInjectable, field.getType(), qualFactory.forSink(field), field); } } }
@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())); }
@Test public void testFieldWithStringBoundedWildcardTypeParam() throws Exception { final MetaClass metaClass = getMetaClass(ClassWithGenericCollections.class); final MetaField field = metaClass.getDeclaredField("hasWildcardExtendsStringParam"); assertNotNull(field); assertEquals("Collection", field.getType().getName()); assertEquals("java.util.Collection", field.getType().getFullyQualifiedName()); assertEquals("<? extends java.lang.String>", field.getType().getParameterizedType().toString()); assertEquals("java.util.Collection<? extends java.lang.String>", field.getType().getFullyQualifiedNameWithTypeParms()); assertEquals("java.util.Collection", field.getType().getErased().getFullyQualifiedNameWithTypeParms()); assertEquals(1, field.getType().getParameterizedType().getTypeParameters().length); final MetaWildcardType typeParam = (MetaWildcardType) field.getType().getParameterizedType().getTypeParameters()[0]; assertEquals("Should have no lower bound", Arrays.asList(), Arrays.asList(typeParam.getLowerBounds())); assertEquals("Upper bound should be java.lang.String", Arrays.asList(getMetaClass(String.class)), Arrays.asList(typeParam.getUpperBounds())); }
@Test public void testFieldWithUnboundedTypeVarParam() throws Exception { final MetaClass metaClass = getMetaClass(ClassWithGenericCollections.class); final MetaField field = metaClass.getDeclaredField("hasUnboundedTypeVarFromClass"); assertNotNull(field); assertEquals("Collection", field.getType().getName()); assertEquals("java.util.Collection", field.getType().getFullyQualifiedName()); assertEquals("java.util.Collection<T>", field.getType().getParameterizedType().getName()); assertEquals("java.util.Collection<T>", field.getType().getFullyQualifiedNameWithTypeParms()); assertEquals("java.util.Collection", field.getType().getErased().getFullyQualifiedNameWithTypeParms()); assertEquals(1, field.getType().getParameterizedType().getTypeParameters().length); final MetaTypeVariable typeVar = (MetaTypeVariable) field.getType().getParameterizedType().getTypeParameters()[0]; assertEquals("T", typeVar.getName()); assertEquals("Should have no upper bound", Arrays.asList(getMetaClass(Object.class)), Arrays.asList(typeVar.getBounds())); }
@Test public void testHashCodeErrorWithGenericHavingArrayUpperBound() throws Exception { final MetaClass mc = getMetaClass(ClassWithArrayGenerics.class).getField("field").getType(); // Precondition assertNotNull("Failed to find field with type under test.", mc); assertNotNull("Type should be parameterized", mc.getParameterizedType()); final MetaClass superClassWithProblematicBound = mc.getSuperClass(); try { superClassWithProblematicBound.hashCode(); } catch (final Throwable t) { throw new AssertionError("An error occurred.", t); } }
private void processProducerField(final Injectable producerInjectable, final MetaClass producerType, final DependencyGraphBuilder builder, final Collection<MetaMethod> disposesMethods, final MetaField field, final boolean enabled, final List<String> problems) { final Class<? extends Annotation> scopeAnno = getScope(field); final InjectableType injectableType = (enabled ? InjectableType.Producer : InjectableType.Disabled); final Injectable producedInjectable = builder.addInjectable(field.getType(), qualFactory.forSource(field), getPathPredicate(field, problems), scopeAnno, injectableType, getWiringTypeForProducer(producerType, field, scopeAnno)); if (field.isStatic()) { builder.addProducerMemberDependency(producedInjectable, producerType, field); } else { builder.addProducerMemberDependency(producedInjectable, producerInjectable.getInjectedType(), producerInjectable.getQualifier(), field); } if (enabled) { processDisposerDependencies(builder, disposesMethods, field, producedInjectable); } }