@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
private String getFieldName(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); if (annotated instanceof AnnotatedField) { AnnotatedField f = (AnnotatedField) annotated; return f.getJavaMember().getName(); } if (annotated instanceof AnnotatedParameter) { AnnotatedParameter p = (AnnotatedParameter) annotated; Member member = ip.getMember(); if (member instanceof Method) { return member.getName() + "_" + p.getPosition(); } if (member instanceof Constructor) { return "new_" + p.getPosition(); } } return ip.getMember().getName(); }
@SuppressWarnings("Duplicates") private String getFieldName(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); if (annotated instanceof AnnotatedField) { AnnotatedField<?> f = (AnnotatedField<?>) annotated; return f.getJavaMember().getName(); } if (annotated instanceof AnnotatedParameter) { AnnotatedParameter<?> p = (AnnotatedParameter<?>) annotated; Member member = ip.getMember(); if (member instanceof Method) { return member.getName() + "_" + p.getPosition(); } if (member instanceof Constructor) { return "new_" + p.getPosition(); } } return ip.getMember().getName(); }
/** * Gets the underlying field * * @return The fields */ public Field getAnnotatedField() { return slim.getJavaMember(); }
/** * Gets the underlying field * * @return The fields */ public Field getAnnotatedField() { return slim.getJavaMember(); }
public int compare(AnnotatedField<? super T> arg0, AnnotatedField<? super T> arg1) { if (arg0.getJavaMember().getName().equals(arg1.getJavaMember().getName())) { return arg0.getJavaMember().getDeclaringClass().getName().compareTo(arg1.getJavaMember().getDeclaringClass().getName()); } return arg0.getJavaMember().getName().compareTo(arg1.getJavaMember().getName()); }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
/** * Add an annotation to the specified field. If the field is not already * present, it will be added. * * @param field the field to add the annotation to * @param annotation the annotation to add * @throws IllegalArgumentException if the annotation is null */ public AnnotatedTypeBuilder<X> addToField(AnnotatedField<? super X> field, Annotation annotation) { return addToField(field.getJavaMember(), annotation); }
@Override public Field getJavaMember() { return delegate().getJavaMember(); } }
public static boolean compareAnnotatedField(AnnotatedField<?> f1, AnnotatedField<?> f2) { if (!f1.getJavaMember().equals(f2.getJavaMember())) { return false; } return compareAnnotated(f1, f2); }
private void checkPublicFields(EnhancedAnnotatedType<E> clazz) { for (AnnotatedField<?> field : clazz.getFields()) { Member member = field.getJavaMember(); if (Modifier.isPublic(member.getModifiers()) && !Modifier.isStatic(member.getModifiers())) { // warn when an extension has a non-static public field BeanLogger.LOG.extensionWithNonStaticPublicField(clazz.getBaseType(), field.getJavaMember()); } } }
/** * * @param fieldInjectionPoint * @param factory */ FieldResourceInjection(FieldInjectionPoint<T, X> fieldInjectionPoint, ResourceReferenceFactory<T> factory) { super(factory); this.accessibleField = AccessController.doPrivileged(new GetAccessibleCopyOfMember<Field>(fieldInjectionPoint.getAnnotated().getJavaMember())); }
Set<Type> getContextFieldTypes() { return replacedFields.stream() .filter(f -> f.isAnnotationPresent(Context.class) || f.isAnnotationPresent(ContextResolved.class)) .map(f -> f.getJavaMember().getAnnotatedType().getType()) .collect(toSet()); }
/** * Generates a deterministic signature for an {@link AnnotatedField}. Two * <code>AnnotatedField</code>s that have the same annotations and * underlying field will generate the same signature. */ public static <X> String createFieldId(AnnotatedField<X> field) { return createFieldId(field.getJavaMember(), field.getAnnotations()); }
public static String formatAnnotatedField(AnnotatedField<?> field) { return Formats.formatSimpleClassName(field) + " " + Formats.addSpaceIfNeeded(Formats.formatAnnotations(field.getAnnotations())) + Formats.addSpaceIfNeeded(Formats.formatModifiers(field.getJavaMember().getModifiers())) + field.getDeclaringType().getJavaClass().getName() + "." + field.getJavaMember().getName(); }
public AnnotatedFieldImpl(AnnotatedField<? super T> field, Set<Annotation> annotations, AnnotatedType<T> declaringType) { this(field.getBaseType(), field.getTypeClosure(), annotations, declaringType, field.getJavaMember(), field.isStatic()); }
public DecoratorInjectionTarget(EnhancedAnnotatedType<T> type, Bean<T> bean, BeanManagerImpl beanManager) { super(type, bean, beanManager); this.delegateInjectionPoint = Decorators.findDelegateInjectionPoint(type, getInjectionPoints()); if (delegateInjectionPoint instanceof FieldInjectionPoint<?, ?>) { FieldInjectionPoint<?, ?> fip = (FieldInjectionPoint<?, ?>) delegateInjectionPoint; this.accessibleField = AccessController.doPrivileged(new GetAccessibleCopyOfMember<Field>(fip.getAnnotated().getJavaMember())); } else { this.accessibleField = null; } checkAbstractMethods(type); }
public AnnotatedFieldImpl(AnnotatedField<? super T> field, AnnotatedType<T> declaringType) { this(field.getBaseType(), field.getTypeClosure(), field.getAnnotations(), declaringType, field.getJavaMember(), field.isStatic()); }
public AnnotatedFieldImpl(AnnotatedField<? super T> field, AnnotatedType<T> declaringType) { this(field.getBaseType(), field.getTypeClosure(), field.getAnnotations(), declaringType, field.getJavaMember(), field.isStatic()); }
public static <X, Y extends X> AnnotatedField<X> of(AnnotatedField<X> originalField, UnbackedAnnotatedType<Y> declaringType, SharedObjectCache cache) { UnbackedAnnotatedType<X> downcastDeclaringType = cast(declaringType); return new UnbackedAnnotatedField<X>(originalField.getBaseType(), originalField.getTypeClosure(), cache.getSharedSet(originalField.getAnnotations()), originalField.getJavaMember(), downcastDeclaringType); }