[weld-commits] Weld SVN: r5480 - in core/trunk: impl/src/main/java/org/jboss/weld/bootstrap/events and 7 other directories.

Author: pete.muir(a)jboss.org Date: 2010-01-15 13:52:18 -0500 (Fri, 15 Jan 2010) New Revision: 5480 Added: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/ExternalAnnotatedType.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotatedType.java core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/EcoFriendlyWashingMachine.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/FastWashingMachine.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Laundry.java core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/WashingMachine.java core/trunk/tests/src/test/resources/org/jboss/weld/tests/extensions/annotatedType/ core/trunk/tests/src/test/resources/org/jboss/weld/tests/extensions/annotatedType/javax.enterprise.inject.spi.Extension Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/NewManagedBean.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotated.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldAnnotated.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java Log: WELD-335 Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -61,6 +61,7 @@ import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.metadata.cache.MetaAnnotationStore; import org.jboss.weld.serialization.spi.helpers.SerializableContextual; +import org.jboss.weld.util.AnnotatedTypes; import org.jboss.weld.util.Beans; import org.jboss.weld.util.reflection.Reflections; import org.slf4j.cal10n.LocLogger; @@ -101,15 +102,31 @@ */ public static <T> ManagedBean<T> of(WeldClass<T> clazz, BeanManagerImpl beanManager) { - return new ManagedBean<T>(clazz, createId(ManagedBean.class.getSimpleName(), clazz), beanManager); + if (clazz.isDiscovered()) + { + return new ManagedBean<T>(clazz, createSimpleId(ManagedBean.class.getSimpleName(), clazz), beanManager); + } + else + { + return new ManagedBean<T>(clazz, createId(ManagedBean.class.getSimpleName(), clazz), beanManager); + } } - protected static String createId(String beanType, WeldClass<?> clazz) + protected static String createSimpleId(String beanType, WeldClass<?> clazz) { return new StringBuilder().append(beanType).append(BEAN_ID_SEPARATOR).append(clazz.getBaseType()).toString(); } /** + * create a more complete id for types that have been added through the SPI + * to prevent duplicate id's + */ + protected static String createId(String beanType, WeldClass<?> clazz) + { + return new StringBuilder().append(beanType).append(BEAN_ID_SEPARATOR).append(AnnotatedTypes.createTypeId(clazz)).toString(); + } + + /** * Constructor * * @param type The type of the bean Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/NewManagedBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/NewManagedBean.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/NewManagedBean.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -43,7 +43,14 @@ */ public static <T> NewManagedBean<T> of(WeldClass<T> clazz, BeanManagerImpl beanManager) { - return new NewManagedBean<T>(clazz, createId(NewManagedBean.class.getSimpleName(), clazz), beanManager); + if (clazz.isDiscovered()) + { + return new NewManagedBean<T>(clazz, createSimpleId(NewManagedBean.class.getSimpleName(), clazz), beanManager); + } + else + { + return new NewManagedBean<T>(clazz, createId(NewManagedBean.class.getSimpleName(), clazz), beanManager); + } } private Set<Annotation> bindings; Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -25,16 +25,40 @@ import org.jboss.weld.bootstrap.BeanDeployment; import org.jboss.weld.bootstrap.spi.BeanDeploymentArchive; import org.jboss.weld.bootstrap.spi.Deployment; -import org.jboss.weld.literal.QualifierLiteral; +import org.jboss.weld.introspector.ForwardingAnnotatedType; import org.jboss.weld.literal.InterceptorBindingTypeLiteral; import org.jboss.weld.literal.NormalScopeLiteral; +import org.jboss.weld.literal.QualifierLiteral; import org.jboss.weld.literal.ScopeLiteral; import org.jboss.weld.literal.StereotypeLiteral; import org.jboss.weld.manager.BeanManagerImpl; public class BeforeBeanDiscoveryImpl extends AbstractBeanDiscoveryEvent implements BeforeBeanDiscovery { + + private static class ExternalAnnotatedTypeWrapper<X> extends ForwardingAnnotatedType<X> implements ExternalAnnotatedType + { + + public static <X> AnnotatedType<X> of(AnnotatedType<X> annotatedType) + { + return new ExternalAnnotatedTypeWrapper<X>(annotatedType); + } + + private final AnnotatedType<X> delegate; + private ExternalAnnotatedTypeWrapper(AnnotatedType<X> delegate) + { + this.delegate = delegate; + } + + @Override + protected AnnotatedType<X> delegate() + { + return delegate; + } + + } + public static void fire(BeanManagerImpl beanManager, Deployment deployment, Map<BeanDeploymentArchive, BeanDeployment> beanDeployments) { new BeforeBeanDiscoveryImpl(beanManager, deployment, beanDeployments).fire(beanDeployments); @@ -78,7 +102,7 @@ public void addAnnotatedType(AnnotatedType<?> type) { - getOrCreateBeanDeployment(type.getJavaClass()).getBeanDeployer().addClass(type); + getOrCreateBeanDeployment(type.getJavaClass()).getBeanDeployer().addClass(ExternalAnnotatedTypeWrapper.of(type)); } } Added: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/ExternalAnnotatedType.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/ExternalAnnotatedType.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/ExternalAnnotatedType.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,6 @@ +package org.jboss.weld.bootstrap.events; + +public interface ExternalAnnotatedType +{ + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/ExternalAnnotatedType.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotated.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotated.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotated.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -30,7 +30,7 @@ * @param <T> the base type * @param <S> the annotated element type */ -public abstract class ForwardingAnnotated<T, S> implements Annotated +public abstract class ForwardingAnnotated implements Annotated { protected abstract Annotated delegate(); Added: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotatedType.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotatedType.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotatedType.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,42 @@ +package org.jboss.weld.introspector; + +import java.util.Set; + +import javax.enterprise.inject.spi.AnnotatedConstructor; +import javax.enterprise.inject.spi.AnnotatedField; +import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.AnnotatedType; + +/** + * Forwarding implementation of AnnotatedType + * + * @author Stuart Douglas <stuart(a)baileyroberts.com.au&gt; + * + */ +public abstract class ForwardingAnnotatedType<X> extends ForwardingAnnotated implements AnnotatedType<X> +{ + + @Override + protected abstract AnnotatedType<X> delegate(); + + public Set<AnnotatedConstructor<X>> getConstructors() + { + return delegate().getConstructors(); + } + + public Set<AnnotatedField<? super X>> getFields() + { + return delegate().getFields(); + } + + public Class<X> getJavaClass() + { + return delegate().getJavaClass(); + } + + public Set<AnnotatedMethod<? super X>> getMethods() + { + return delegate().getMethods(); + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingAnnotatedType.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldAnnotated.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldAnnotated.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldAnnotated.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -28,7 +28,7 @@ * @param <T> * @param <S> */ -public abstract class ForwardingWeldAnnotated<T, S> extends ForwardingAnnotated<T, S> implements WeldAnnotated<T, S> +public abstract class ForwardingWeldAnnotated<T, S> extends ForwardingAnnotated implements WeldAnnotated<T, S> { public Type[] getActualTypeArguments() Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -169,4 +169,8 @@ return delegate().getDeclaredMetaAnnotations(metaAnnotationType); } + public boolean isDiscovered() + { + return delegate().isDiscovered(); + } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -185,6 +185,8 @@ public boolean isAnonymousClass(); public boolean isSerializable(); + + public boolean isDiscovered(); public <S> S cast(Object object); Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2010-01-15 16:36:27 UTC (rev 5479) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -37,6 +37,7 @@ import javax.enterprise.inject.spi.AnnotatedMethod; import javax.enterprise.inject.spi.AnnotatedType; +import org.jboss.weld.bootstrap.events.ExternalAnnotatedType; import org.jboss.weld.introspector.ConstructorSignature; import org.jboss.weld.introspector.MethodSignature; import org.jboss.weld.introspector.WeldClass; @@ -108,6 +109,8 @@ // meta-annotation) of the item private final SetMultimap<Class<? extends Annotation>, Annotation> declaredMetaAnnotationMap; + private final boolean discovered; + public static <T> WeldClass<T> of(Class<T> clazz, ClassTransformer classTransformer) { return new WeldClassImpl<T>(clazz, clazz, null, new HierarchyDiscovery(clazz).getTypeClosure(), buildAnnotationMap(clazz.getAnnotations()), buildAnnotationMap(clazz.getDeclaredAnnotations()), classTransformer); @@ -127,6 +130,15 @@ { super(annotationMap, declaredAnnotationMap, classTransformer, rawType, type, typeClosure); + if (annotatedType instanceof ExternalAnnotatedType) + { + discovered = false; + } + else + { + discovered = true; + } + if (rawType.getSuperclass() != null) { this.superclass = classTransformer.loadClass(rawType.getSuperclass()); @@ -630,4 +642,9 @@ return Collections.unmodifiableSet(declaredMetaAnnotationMap.get(metaAnnotationType)); } + public boolean isDiscovered() + { + return discovered; + } + } \ No newline at end of file Added: core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,415 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.weld.util; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Set; + +import javax.enterprise.inject.spi.AnnotatedCallable; +import javax.enterprise.inject.spi.AnnotatedConstructor; +import javax.enterprise.inject.spi.AnnotatedField; +import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.AnnotatedParameter; +import javax.enterprise.inject.spi.AnnotatedType; + +/** + * Class that can take an AnnotatedType and return a unique string + * representation of that type + * + * @author Stuart Douglas <stuart(a)baileyroberts.com.au&gt; + */ +public class AnnotatedTypes +{ + + /** + * Does the first stage of comparing AnnoatedCallables, however it cannot + * compare the method parameters + */ + private static class AnnotatedCallableComparator<T> implements Comparator<AnnotatedCallable<? super T>> + { + + public int compare(AnnotatedCallable<? super T> arg0, AnnotatedCallable<? super T> arg1) + { + // compare the names first + int result = (arg0.getJavaMember().getName().compareTo(arg1.getJavaMember().getName())); + if (result != 0) + { + return result; + } + result = arg0.getJavaMember().getDeclaringClass().getName().compareTo(arg1.getJavaMember().getDeclaringClass().getName()); + if (result != 0) + { + return result; + } + result = arg0.getParameters().size() - arg1.getParameters().size(); + return result; + } + + } + + private static class AnnotatedMethodComparator<T> implements Comparator<AnnotatedMethod<? super T>> + { + + public static <T> Comparator<AnnotatedMethod<? super T>> instance() + { + return new AnnotatedMethodComparator<T>(); + } + + private AnnotatedCallableComparator<T> callableComparator = new AnnotatedCallableComparator<T>(); + + public int compare(AnnotatedMethod<? super T> arg0, AnnotatedMethod<? super T> arg1) + { + int result = callableComparator.compare(arg0, arg1); + if (result != 0) + { + return result; + } + for (int i = 0; i < arg0.getJavaMember().getParameterTypes().length; ++i) + { + Class<?> p0 = arg0.getJavaMember().getParameterTypes()[i]; + Class<?> p1 = arg1.getJavaMember().getParameterTypes()[i]; + result = p0.getName().compareTo(p1.getName()); + if (result != 0) + { + return result; + } + } + return 0; + } + + } + + private static class AnnotatedConstructorComparator<T> implements Comparator<AnnotatedConstructor<? super T>> + { + + public static <T> Comparator<AnnotatedConstructor<? super T>> instance() + { + return new AnnotatedConstructorComparator<T>(); + } + + private AnnotatedCallableComparator<T> callableComparator = new AnnotatedCallableComparator<T>(); + + public int compare(AnnotatedConstructor<? super T> arg0, AnnotatedConstructor<? super T> arg1) + { + int result = callableComparator.compare(arg0, arg1); + if (result != 0) + { + return result; + } + for (int i = 0; i < arg0.getJavaMember().getParameterTypes().length; ++i) + { + Class<?> p0 = arg0.getJavaMember().getParameterTypes()[i]; + Class<?> p1 = arg1.getJavaMember().getParameterTypes()[i]; + result = p0.getName().compareTo(p1.getName()); + if (result != 0) + { + return result; + } + } + return 0; + } + + } + + private static class AnnotatedFieldComparator<T> implements Comparator<AnnotatedField<? super T>> + { + + public static <T> Comparator<AnnotatedField<? super T>> instance() + { + return new AnnotatedFieldComparator<T>(); + } + + 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()); + } + + } + + private static class AnnotationComparator implements Comparator<Annotation> + { + + public static final Comparator<Annotation> INSTANCE = new AnnotationComparator(); + + public int compare(Annotation arg0, Annotation arg1) + { + return arg0.annotationType().getName().compareTo(arg1.annotationType().getName()); + } + } + + private static class MethodComparator implements Comparator<Method> + { + + public static final Comparator<Method> INSTANCE = new MethodComparator(); + + public int compare(Method arg0, Method arg1) + { + return arg0.getName().compareTo(arg1.getName()); + } + } + + private static final char SEPERATOR = ';'; + + /** + * Generates a unique signature for an annotated type. Members without + * annotations are omitted to reduce the length of the signature + * + * @param <X> + * @param annotatedType + * @return + */ + public static <X> String createTypeId(AnnotatedType<X> annotatedType) + { + return createTypeId(annotatedType.getJavaClass(), annotatedType.getAnnotations(), annotatedType.getMethods(), annotatedType.getFields(), annotatedType.getConstructors()); + } + + /** + * Generates a unique signature for a concrete class + * + * @param <X> + * @param annotatedType + * @return + */ + public static <X> String createTypeId(Class<X> clazz, Collection<Annotation> annotations, Collection<AnnotatedMethod<? super X>> methods, Collection<AnnotatedField<? super X>> fields, Collection<AnnotatedConstructor<X>> constructors) + { + StringBuilder builder = new StringBuilder(); + + builder.append(clazz.getName()); + builder.append(createAnnotationCollectionId(annotations)); + builder.append("{ "); + + // now deal with the fields + List<AnnotatedField<? super X>> sortedFields = new ArrayList<AnnotatedField<? super X>>(); + sortedFields.addAll(fields); + Collections.sort(sortedFields, AnnotatedFieldComparator.<X> instance()); + for (AnnotatedField<? super X> field : sortedFields) + { + if (!field.getAnnotations().isEmpty()) + { + builder.append(createFieldId(field)); + builder.append(SEPERATOR); + } + } + + // methods + List<AnnotatedMethod<? super X>> sortedMethods = new ArrayList<AnnotatedMethod<? super X>>(); + sortedMethods.addAll(methods); + Collections.sort(sortedMethods, AnnotatedMethodComparator.<X> instance()); + for (AnnotatedMethod<? super X> method : sortedMethods) + { + if (!method.getAnnotations().isEmpty() || hasMethodParameters(method)) + { + builder.append(createCallableId(method)); + builder.append(SEPERATOR); + } + } + + // constructors + List<AnnotatedConstructor<? super X>> sortedConstructors = new ArrayList<AnnotatedConstructor<? super X>>(); + sortedConstructors.addAll(constructors); + Collections.sort(sortedConstructors, AnnotatedConstructorComparator.<X> instance()); + for (AnnotatedConstructor<? super X> constructor : sortedConstructors) + { + if (!constructor.getAnnotations().isEmpty() || hasMethodParameters(constructor)) + { + builder.append(createCallableId(constructor)); + builder.append(SEPERATOR); + } + } + builder.append("}"); + + return builder.toString(); + } + + private static <X> boolean hasMethodParameters(AnnotatedCallable<X> callable) + { + for (AnnotatedParameter<X> parameter : callable.getParameters()) + { + if (parameter.getAnnotations().isEmpty()) + { + return true; + } + } + return false; + } + + private static String createAnnotationCollectionId(Collection<Annotation> annotations) + { + if (annotations.isEmpty()) + { + return ""; + } + + StringBuilder builder = new StringBuilder(); + builder.append('['); + + List<Annotation> annotationList = new ArrayList<Annotation>(annotations.size()); + annotationList.addAll(annotations); + Collections.sort(annotationList, AnnotationComparator.INSTANCE); + + for (Annotation a : annotationList) + { + builder.append('@'); + builder.append(a.annotationType().getName()); + builder.append('('); + Method[] declaredMethods = a.annotationType().getDeclaredMethods(); + List<Method> methods = new ArrayList<Method>(declaredMethods.length); + // TODO Shouldn't the declared methods be added here? + Collections.sort(methods, MethodComparator.INSTANCE); + + for (int i = 0; i < methods.size(); ++i) + { + Method method = methods.get(i); + try + { + Object value = method.invoke(a); + builder.append(method.getName()); + builder.append('='); + builder.append(value.toString()); + } + catch (NullPointerException e) + { + throw new RuntimeException("NullPointerException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e); + } + catch (IllegalArgumentException e) + { + throw new RuntimeException("IllegalArgumentException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e); + } + catch (IllegalAccessException e) + { + throw new RuntimeException("IllegalAccessException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e); + } + catch (InvocationTargetException e) + { + throw new RuntimeException("InvocationTargetException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e); + } + if (i + 1 != methods.size()) + { + builder.append(','); + } + } + builder.append(')'); + } + builder.append(']'); + return builder.toString(); + } + + public static <X> String createFieldId(AnnotatedField<X> field) + { + return createFieldId(field.getJavaMember(), field.getAnnotations()); + } + + public static <X> String createFieldId(Field field, Collection<Annotation> annotations) + { + StringBuilder builder = new StringBuilder(); + builder.append(field.getDeclaringClass().getName()); + builder.append('.'); + builder.append(field.getName()); + builder.append(createAnnotationCollectionId(annotations)); + return builder.toString(); + } + + public static <X> String createCallableId(AnnotatedCallable<X> method) + { + StringBuilder builder = new StringBuilder(); + builder.append(method.getJavaMember().getDeclaringClass().getName()); + builder.append('.'); + builder.append(method.getJavaMember().getName()); + builder.append(createAnnotationCollectionId(method.getAnnotations())); + builder.append(createParameterListId(method.getParameters())); + return builder.toString(); + } + + public static <X> String createMethodId(Method method, Set<Annotation> annotations, List<AnnotatedParameter<X>> parameters) + { + StringBuilder builder = new StringBuilder(); + builder.append(method.getDeclaringClass().getName()); + builder.append('.'); + builder.append(method.getName()); + builder.append(createAnnotationCollectionId(annotations)); + builder.append(createParameterListId(parameters)); + return builder.toString(); + } + + 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(); + } + + 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 <X> String createParameterId(AnnotatedParameter<X> annotatedParameter) + { + return createParameterId(annotatedParameter.getBaseType(), annotatedParameter.getAnnotations()); + } + + 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(); + } + + private AnnotatedTypes() + { + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,91 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +import javax.enterprise.event.Observes; +import javax.enterprise.inject.spi.AnnotatedConstructor; +import javax.enterprise.inject.spi.AnnotatedField; +import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.AnnotatedType; +import javax.enterprise.inject.spi.BeforeBeanDiscovery; +import javax.enterprise.inject.spi.Extension; +import javax.enterprise.util.AnnotationLiteral; + +public class AnnotatedTypeExtension implements Extension +{ + + public static class EcoFriendlyWashingMachineLiteral extends AnnotationLiteral<EcoFriendlyWashingMachine> implements EcoFriendlyWashingMachine + { + + public static final EcoFriendlyWashingMachine INSTANCE = new EcoFriendlyWashingMachineLiteral(); + + } + + /** + * Adds an eco friendly wasing machine + * @param beforeBeanDiscovery + */ + public void addWashingMachine(@Observes BeforeBeanDiscovery beforeBeanDiscovery) + { + beforeBeanDiscovery.addAnnotatedType(new AnnotatedType<WashingMachine>() + { + + public Set<AnnotatedConstructor<WashingMachine>> getConstructors() + { + return Collections.emptySet(); + } + + public Set<AnnotatedField<? super WashingMachine>> getFields() + { + return Collections.emptySet(); + } + + public Class<WashingMachine> getJavaClass() + { + return WashingMachine.class; + } + + public Set<AnnotatedMethod<? super WashingMachine>> getMethods() + { + return Collections.emptySet(); + } + + public <T extends Annotation> T getAnnotation(Class<T> annotationType) + { + if(annotationType == EcoFriendlyWashingMachine.class) + { + return annotationType.cast(EcoFriendlyWashingMachineLiteral.INSTANCE); + } + return null; + } + + public Set<Annotation> getAnnotations() + { + return Collections.<Annotation>singleton(EcoFriendlyWashingMachineLiteral.INSTANCE); + } + + public Type getBaseType() + { + return WashingMachine.class; + } + + public Set<Type> getTypeClosure() + { + Set<Type> ret = new HashSet<Type>(); + ret.add(Object.class); + ret.add(WashingMachine.class); + return ret; + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + return annotationType == EcoFriendlyWashingMachine.class; + } + + }); + } +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtension.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,27 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import org.jboss.testharness.impl.packaging.Artifact; +import org.jboss.testharness.impl.packaging.IntegrationTest; +import org.jboss.testharness.impl.packaging.Packaging; +import org.jboss.testharness.impl.packaging.PackagingType; +import org.jboss.testharness.impl.packaging.jsr299.Extension; +import org.jboss.weld.test.AbstractWeldTest; +import org.testng.annotations.Test; + +@Artifact +@IntegrationTest +(a)Packaging(PackagingType.EAR) +(a)Extension(&quot;javax.enterprise.inject.spi.Extension&quot;) +public class AnnotatedTypeExtensionTest extends AbstractWeldTest +{ + + @Test + public void testMultipleBeansOfSameType() + { + Laundry laundry = getReference(Laundry.class); + assert laundry.ecoFriendlyWashingMachine != null; + assert laundry.fastWashingMachine != null; + } + + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/AnnotatedTypeExtensionTest.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/EcoFriendlyWashingMachine.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/EcoFriendlyWashingMachine.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/EcoFriendlyWashingMachine.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,22 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import javax.inject.Qualifier; + +@Target( { TYPE, METHOD, PARAMETER, FIELD }) +@Retention(RUNTIME) +@Documented +@Qualifier +public @interface EcoFriendlyWashingMachine +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/EcoFriendlyWashingMachine.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/FastWashingMachine.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/FastWashingMachine.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/FastWashingMachine.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,22 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import javax.inject.Qualifier; + +@Target( { TYPE, METHOD, PARAMETER, FIELD }) +@Retention(RUNTIME) +@Documented +@Qualifier +public @interface FastWashingMachine +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/FastWashingMachine.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Laundry.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Laundry.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Laundry.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,12 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +import javax.inject.Inject; + +public class Laundry +{ + @Inject @FastWashingMachine + public WashingMachine fastWashingMachine; + + @Inject @EcoFriendlyWashingMachine + public WashingMachine ecoFriendlyWashingMachine; +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/Laundry.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/WashingMachine.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/WashingMachine.java (rev 0) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/WashingMachine.java 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1,7 @@ +package org.jboss.weld.tests.extensions.annotatedType; + +@FastWashingMachine +public class WashingMachine +{ + +} Property changes on: core/trunk/tests/src/test/java/org/jboss/weld/tests/extensions/annotatedType/WashingMachine.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/tests/src/test/resources/org/jboss/weld/tests/extensions/annotatedType/javax.enterprise.inject.spi.Extension =================================================================== --- core/trunk/tests/src/test/resources/org/jboss/weld/tests/extensions/annotatedType/javax.enterprise.inject.spi.Extension (rev 0) +++ core/trunk/tests/src/test/resources/org/jboss/weld/tests/extensions/annotatedType/javax.enterprise.inject.spi.Extension 2010-01-15 18:52:18 UTC (rev 5480) @@ -0,0 +1 @@ +org.jboss.weld.tests.extensions.annotatedType.AnnotatedTypeExtension