public static boolean compareAnnotatedField(AnnotatedField<?> f1, AnnotatedField<?> f2) { if (!f1.getJavaMember().equals(f2.getJavaMember())) { return false; } return compareAnnotated(f1, f2); }
@Override public boolean equals(EnhancedAnnotatedField<?, ?> member1, AnnotatedField<?> member2) { return AnnotatedTypes.compareAnnotatedField(member1, member2); }
public static <X> String createConstructorId(Constructor<X> constructor, Set<Annotation> annotations, List<AnnotatedParameter<X>> parameters) { StringBuilder builder = new StringBuilder(); builder.append(constructor.getDeclaringClass().getName()); builder.append('.'); builder.append(constructor.getName()); builder.append(createAnnotationCollectionId(annotations)); builder.append(createParameterListId(parameters)); return builder.toString(); }
private <T> UnbackedAnnotatedMember<T> findMatchingMember(UnbackedAnnotatedType<T> type, String id) { for (AnnotatedField<? super T> field : type.getFields()) { if (id.equals(AnnotatedTypes.createFieldId(field))) { return cast(field); } } for (AnnotatedMethod<? super T> method : type.getMethods()) { if (id.equals(AnnotatedTypes.createMethodId(method.getJavaMember(), method.getAnnotations(), method.getParameters()))) { return Reflections.cast(method); } } for (AnnotatedConstructor<T> constructor : type.getConstructors()) { if (id.equals(AnnotatedTypes.createConstructorId(constructor.getJavaMember(), constructor.getAnnotations(), constructor.getParameters()))) { return cast(constructor); } } throw BeanLogger.LOG.unableToLoadMember(id); } }
if (!t1.getJavaClass().equals(t2.getJavaClass())) { return false; if (!compareAnnotated(t1, t2)) { return false; if (t1.getFields().size() != t2.getFields().size()) { return false; for (AnnotatedField<?> f : t2.getFields()) { fields.put(f.getJavaMember(), f); for (AnnotatedField<?> f : t1.getFields()) { if (fields.containsKey(f.getJavaMember())) { if (!compareAnnotatedField(f, fields.get(f.getJavaMember()))) { return false; for (AnnotatedMethod<?> f : t1.getMethods()) { if (methods.containsKey(f.getJavaMember())) { if (!compareAnnotatedCallable(f, methods.get(f.getJavaMember()))) { return false; for (AnnotatedConstructor<?> f : t1.getConstructors()) { if (constructors.containsKey(f.getJavaMember())) { if (!compareAnnotatedCallable(f, constructors.get(f.getJavaMember()))) { return false;
builder.append(createAnnotationCollectionId(annotations)); builder.append("{"); Collections.sort(sortedFields, AnnotatedFieldComparator.<X>instance()); for (AnnotatedField<? super X> field : sortedFields) { if (!field.getAnnotations().isEmpty()) { builder.append(createFieldId(field)); builder.append(SEPARATOR); Collections.sort(sortedMethods, AnnotatedMethodComparator.<X>instance()); for (AnnotatedMethod<? super X> method : sortedMethods) { if (!method.getAnnotations().isEmpty() || hasMethodParameters(method)) { builder.append(createCallableId(method)); builder.append(SEPARATOR); Collections.sort(sortedConstructors, AnnotatedConstructorComparator.<X>instance()); for (AnnotatedConstructor<? super X> constructor : sortedConstructors) { if (!constructor.getAnnotations().isEmpty() || hasMethodParameters(constructor)) { builder.append(createCallableId(constructor)); builder.append(SEPARATOR);
public static <X> String createFieldId(AnnotatedField<X> field) { return createFieldId(field.getJavaMember(), field.getAnnotations()); }
@Override public boolean equals(Object obj) { if (obj instanceof InferringFieldInjectionPointAttributes<?, ?>) { AnnotatedField<?> field = Reflections.<InferringFieldInjectionPointAttributes<?, ?>> cast(obj).getAnnotated(); return AnnotatedTypes.compareAnnotatedField(getAnnotated(), field); } return false; } }
@Override public boolean equals(Object obj) { if (obj instanceof InferringParameterInjectionPointAttributes<?, ?>) { AnnotatedParameter<?> parameter = Reflections.<InferringParameterInjectionPointAttributes<?, ?>> cast(obj).getAnnotated(); return AnnotatedTypes.compareAnnotatedParameters(getAnnotated(), parameter); } return false; } }
/** * Compares two annotated parameters and returns true if they are equal */ public static boolean compareAnnotatedParameters(AnnotatedParameter<?> p1, AnnotatedParameter<?> p2) { return compareAnnotatedCallable(p1.getDeclaringCallable(), p2.getDeclaringCallable()) && p1.getPosition() == p2.getPosition() && compareAnnotated(p1, p2); }
public static boolean compareAnnotatedCallable(AnnotatedCallable<?> m1, AnnotatedCallable<?> m2) { if (!m1.getJavaMember().equals(m2.getJavaMember())) { return false; } if (!compareAnnotated(m1, m2)) { return false; } return compareAnnotatedParameters(m1.getParameters(), m2.getParameters()); }
public static <X> String createParameterListId(List<AnnotatedParameter<X>> parameters) { StringBuilder builder = new StringBuilder(); builder.append("("); for (int i = 0; i < parameters.size(); ++i) { AnnotatedParameter<X> ap = parameters.get(i); builder.append(createParameterId(ap)); if (i + 1 != parameters.size()) { builder.append(','); } } builder.append(")"); return builder.toString(); }
public static String forProducerMethod(EnhancedAnnotatedMethod<?, ?> method, AbstractClassBean<?> declaringBean) { if (declaringBean.getEnhancedAnnotated().isDiscovered()) { return forProducerMethod(declaringBean.getAnnotated().getIdentifier(), DeclaredMemberIndexer.getIndexForMethod(method.getJavaMember())); } return getPrefix(ProducerMethod.class).append(method.getDeclaringType().slim().getIdentifier()).append(AnnotatedTypes.createCallableId(method)).toString(); }
public static String forProducerField(EnhancedAnnotatedField<?, ?> field, AbstractClassBean<?> declaringBean) { StringBuilder sb = getPrefix(ProducerField.class).append(declaringBean.getAnnotated().getIdentifier().asString()) .append(BEAN_ID_SEPARATOR); if (declaringBean.getEnhancedAnnotated().isDiscovered()) { sb.append(field.getName()); } else { sb.append(AnnotatedTypes.createFieldId(field)); } return sb.toString(); }
private Object writeReplace() throws ObjectStreamException { return new UnbackedMemberIdentifier<X>(getDeclaringType(), AnnotatedTypes.createConstructorId(constructor, getAnnotations(), getParameters())); }
private Object writeReplace() throws ObjectStreamException { return new UnbackedMemberIdentifier<X>(getDeclaringType(), AnnotatedTypes.createMethodId(method, getAnnotations(), getParameters())); }
@Override public boolean equals(Object obj) { if (obj instanceof AbstractCallableInjectionPoint<?, ?, ?>) { AbstractCallableInjectionPoint<?, ?, ?> ip = (AbstractCallableInjectionPoint<?, ?, ?>) obj; if (AnnotatedTypes.compareAnnotatedCallable(getAnnotated(), ip.getAnnotated())) { return true; } } return false; }
public static <X> String createParameterId(Type type, Set<Annotation> annotations) { StringBuilder builder = new StringBuilder(); if (type instanceof Class<?>) { Class<?> c = (Class<?>) type; builder.append(c.getName()); } else { builder.append(type.toString()); } builder.append(createAnnotationCollectionId(annotations)); return builder.toString(); }
if (!t1.getJavaClass().equals(t2.getJavaClass())) { return false; if (!compareAnnotated(t1, t2)) { return false; if (t1.getFields().size() != t2.getFields().size()) { return false; for (AnnotatedField<?> f : t2.getFields()) { fields.put(f.getJavaMember(), f); for (AnnotatedField<?> f : t1.getFields()) { if (fields.containsKey(f.getJavaMember())) { if (!compareAnnotatedField(f, fields.get(f.getJavaMember()))) { return false; for (AnnotatedMethod<?> f : t1.getMethods()) { if (methods.containsKey(f.getJavaMember())) { if (!compareAnnotatedCallable(f, methods.get(f.getJavaMember()))) { return false; for (AnnotatedConstructor<?> f : t1.getConstructors()) { if (constructors.containsKey(f.getJavaMember())) { if (!compareAnnotatedCallable(f, constructors.get(f.getJavaMember()))) { return false;
private <T> UnbackedAnnotatedMember<T> findMatchingMember(UnbackedAnnotatedType<T> type, String id) { for (AnnotatedField<? super T> field : type.getFields()) { if (id.equals(AnnotatedTypes.createFieldId(field))) { return cast(field); } } for (AnnotatedMethod<? super T> method : type.getMethods()) { if (id.equals(AnnotatedTypes.createMethodId(method.getJavaMember(), method.getAnnotations(), method.getParameters()))) { return Reflections.cast(method); } } for (AnnotatedConstructor<T> constructor : type.getConstructors()) { if (id.equals(AnnotatedTypes.createConstructorId(constructor.getJavaMember(), constructor.getAnnotations(), constructor.getParameters()))) { return cast(constructor); } } throw BeanLogger.LOG.unableToLoadMember(id); } }