Author: pete.muir(a)jboss.org Date: 2010-07-23 17:42:50 -0400 (Fri, 23 Jul 2010) New Revision: 6783 Added: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java Removed: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java Log: Initial refactor of GenericBean onto Property Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -100,7 +100,7 @@ typeAnnotations.add(annotation); } - for (Field field : Reflections.getFields(underlyingType)) + for (Field field : Reflections.getAllFields(underlyingType)) { AnnotationBuilder annotationBuilder = new AnnotationBuilder(); fields.put(field, annotationBuilder); @@ -111,7 +111,7 @@ } } - for (Method method : Reflections.getMethods(underlyingType)) + for (Method method : Reflections.getAllMethods(underlyingType)) { AnnotationBuilder annotationBuilder = new AnnotationBuilder(); method.setAccessible(true); Deleted: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -1,69 +0,0 @@ -/* - * JBoss, Home of Professional Open Source - * Copyright 2010, Red Hat, Inc., 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.extensions.bean.generic; - -import java.lang.reflect.Field; - -import javax.enterprise.context.spi.CreationalContext; -import javax.enterprise.inject.UnsatisfiedResolutionException; -import javax.enterprise.inject.spi.Bean; -import javax.enterprise.inject.spi.BeanManager; - -/** - * Class that is responsible for setting the values of generic producer fields - * - * @author Stuart Douglas <stuart(a)baileyroberts.com.au&gt; - * - */ -class FieldSetter -{ - private final Field field; - private final SyntheticQualifier qualifier; - private final BeanManager beanManager; - - FieldSetter(BeanManager beanManager, Field field, SyntheticQualifier qualifier) - { - this.field = field; - this.field.setAccessible(true); - this.qualifier = qualifier; - this.beanManager = beanManager; - } - - public void set(Object instance, CreationalContext<?> ctx) - { - Bean<?> bean = beanManager.resolve(beanManager.getBeans(field.getType(), qualifier)); - if (bean == null) - { - throw new UnsatisfiedResolutionException("Could not resolve bean for Generic Producer field " + field.getDeclaringClass() + "." + field.getName() + " Type: " + field.getType() + " Qualifiers:" + qualifier); - } - Object value = beanManager.getReference(bean, field.getType(), ctx); - try - { - field.set(instance, value); - } - catch (IllegalArgumentException e) - { - throw new RuntimeException(e); - } - catch (IllegalAccessException e) - { - throw new RuntimeException(e); - } - - } - -} Copied: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java (from rev 6772, extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java) =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java (rev 0) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -0,0 +1,299 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc., 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.extensions.bean.generic; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Member; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Map.Entry; + +import javax.enterprise.event.Observes; +import javax.enterprise.inject.Produces; +import javax.enterprise.inject.spi.AfterBeanDiscovery; +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; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; +import javax.enterprise.inject.spi.BeforeBeanDiscovery; +import javax.enterprise.inject.spi.Extension; +import javax.enterprise.inject.spi.InjectionTarget; +import javax.enterprise.inject.spi.ProcessAnnotatedType; +import javax.enterprise.inject.spi.ProcessInjectionTarget; +import javax.inject.Inject; + +import org.jboss.weld.extensions.annotated.AnnotatedTypeBuilder; +import org.jboss.weld.extensions.bean.BeanBuilder; +import org.jboss.weld.extensions.util.properties.Properties; +import org.jboss.weld.extensions.util.properties.Property; + +/** + * Extension that wires in Generic Beans + * + * @author Pete Muir + * @author Stuart Douglas <stuart(a)baileyroberts.com.au&gt; + * + */ +class GenericBeanExtension implements Extension +{ + + private final Map<Class<?>, Set<AnnotatedType<?>>> genericBeans; + + private final Map<Class<?>, Map<Member, Annotation>> producerFields; + + // A map of a generic annotation type to all instances of that type found on beans + private final Map<Class<?>, Set<Annotation>> concreteGenerics; + + private final SyntheticQualifierManager syntheticQualifierManager; + + GenericBeanExtension() + { + this.genericBeans = new HashMap<Class<?>, Set<AnnotatedType<?>>>(); + this.producerFields = new HashMap<Class<?>, Map<Member, Annotation>>(); + this.concreteGenerics = new HashMap<Class<?>, Set<Annotation>>(); + this.syntheticQualifierManager = new SyntheticQualifierManager(); + } + + void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event) + { + event.addQualifier(SyntheticQualifier.class); + } + + void processAnnotatedType(@Observes ProcessAnnotatedType<?> event) + { + AnnotatedType<?> type = event.getAnnotatedType(); + if (type.isAnnotationPresent(Generic.class)) + { + Generic generic = type.getAnnotation(Generic.class); + if (!genericBeans.containsKey(generic.value())) + { + genericBeans.put(generic.value(), new HashSet<AnnotatedType<?>>()); + } + genericBeans.get(generic.value()).add(type); + // we will install (multiple copies of) this bean later + event.veto(); + + } + // make note of any producer fields that produce generic beans + for (AnnotatedField<?> field : type.getFields()) + { + if (field.isAnnotationPresent(Produces.class)) + { + for (Annotation annotation : field.getAnnotations()) + { + if (annotation.annotationType().isAnnotationPresent(GenericAnnotation.class)) + { + if (!producerFields.containsKey(type.getJavaClass())) + { + producerFields.put(type.getJavaClass(), new HashMap<Member, Annotation>()); + } + if (!concreteGenerics.containsKey(annotation.annotationType())) + { + concreteGenerics.put(annotation.annotationType(), new HashSet<Annotation>()); + } + producerFields.get(type.getJavaClass()).put(field.getJavaMember(), annotation); + concreteGenerics.get(annotation.annotationType()).add(annotation); + } + } + } + } + + // make note of any producer method that produce generic beans + for (AnnotatedMethod<?> method : type.getMethods()) + { + if (method.isAnnotationPresent(Produces.class)) + { + for (Annotation annotation : method.getAnnotations()) + { + if (annotation.annotationType().isAnnotationPresent(GenericAnnotation.class)) + { + if (!producerFields.containsKey(type.getJavaClass())) + { + producerFields.put(type.getJavaClass(), new HashMap<Member, Annotation>()); + } + if (!concreteGenerics.containsKey(annotation.annotationType())) + { + concreteGenerics.put(annotation.annotationType(), new HashSet<Annotation>()); + } + producerFields.get(type.getJavaClass()).put(method.getJavaMember(), annotation); + concreteGenerics.get(annotation.annotationType()).add(annotation); + } + } + } + } + } + + /** + * wraps InjectionTarget to initialise producer fields that produce generic + * beans + */ + <T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event, BeanManager beanManager) + { + Class<?> javaClass = event.getAnnotatedType().getJavaClass(); + if (producerFields.containsKey(javaClass)) + { + Map<Member, Annotation> producers = producerFields.get(javaClass); + List<Property<Object>> setters = new ArrayList<Property<Object>>(); + for (Member field : producers.keySet()) + { + Property<Object> property = Properties.createProperty(field); + setters.add(property); + } + ProducerFieldInjectionTarget<T> it = new ProducerFieldInjectionTarget<T>(event.getInjectionTarget(), beanManager, setters, producers, syntheticQualifierManager); + event.setInjectionTarget(it); + } + + } + + /** + * Installs the generic beans. + */ + public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager beanManager) + { + for (Entry<Class<?>, Set<AnnotatedType<?>>> entry : genericBeans.entrySet()) + { + Set<Annotation> concretes = concreteGenerics.get(entry.getKey()); + if (concretes != null) + { + for (AnnotatedType<?> type : entry.getValue()) + { + for (Annotation conc : concretes) + { + abd.addBean(redefineType(type, conc, beanManager)); + } + } + } + } + } + + private <X> Bean<X> redefineType(AnnotatedType<X> at, Annotation conc, BeanManager beanManager) + { + SyntheticQualifier newQualifier = syntheticQualifierManager.getQualifierForGeneric(conc); + + AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlyingType(); + builder.addToClass(newQualifier); + for (AnnotatedField<? super X> f : at.getFields()) + { + if (f.isAnnotationPresent(Inject.class)) + { + // if this is a configuration injection point + if (conc.annotationType().isAssignableFrom(f.getJavaMember().getType())) + { + builder.removeFromField(f.getJavaMember(), Inject.class); + builder.addToField(f.getJavaMember(), InjectConfiguration.INSTANCE); + } + else + { + // check to see if we should be injecting a generic bean + // we do this by checking if there are any beans that can be + // injected into this point + // if there is not then we assume it is a generic injection + // point + // this has the downside that if it is actually a deployment + // error then it will confuse the user + Annotation[] qls = getQualifiers(f.getAnnotations(), beanManager); + Set<Bean<?>> beans = beanManager.getBeans(f.getJavaMember().getType(), qls); + if (beans.isEmpty()) + { + builder.addToField(f.getJavaMember(), newQualifier); + } + } + } + else if (f.isAnnotationPresent(Produces.class)) + { + // TODO: register a producer with the appropriate qualifier + } + } + for (AnnotatedMethod<?> m : at.getMethods()) + { + // TODO: need to properly handle Observer methods and Disposal + // methods + if (m.isAnnotationPresent(Produces.class)) + { + // TODO: we need to register the producer bean, so this is not + // very useful at the moment + for (AnnotatedParameter<?> pm : m.getParameters()) + { + Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()]; + + // check to see if we should be injecting a generic bean + // we do this by checking if there are any beans that can be + // injected into this point + // if there is not then we assume it is a generic injection + // point + // this has the downside that if it is actually a deployment + // error then it will confuse the user + Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager); + Set<Bean<?>> beans = beanManager.getBeans(paramType, qls); + if (beans.isEmpty()) + { + builder.addToMethod(m.getJavaMember(), newQualifier); + } + } + } + } + + for (AnnotatedConstructor<X> m : at.getConstructors()) + { + if (m.isAnnotationPresent(Inject.class)) + { + for (AnnotatedParameter<X> pm : m.getParameters()) + { + Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()]; + Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager); + Set<Bean<?>> beans = beanManager.getBeans(paramType, qls); + if (beans.isEmpty()) + { + builder.addToConstructorParameter(m.getJavaMember(), pm.getPosition(), newQualifier); + } + } + } + } + AnnotatedType<X> newAnnotatedType = builder.create(); + InjectionTarget<X> it = beanManager.createInjectionTarget(newAnnotatedType); + + it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, conc); + BeanBuilder<X> beanBuilder = new BeanBuilder<X>(newAnnotatedType, beanManager).defineBeanFromAnnotatedType().setInjectionTarget(it); + return beanBuilder.create(); + } + + static Annotation[] getQualifiers(Set<Annotation> annotations, BeanManager manager) + { + List<Annotation> qualifiers = new ArrayList<Annotation>(); + for (Annotation a : annotations) + { + if (manager.isQualifier(a.annotationType())) + { + qualifiers.add(a); + } + } + Annotation[] qls = new Annotation[qualifiers.size()]; + for (int j = 0; j < qls.length; ++j) + { + qls[j] = qualifiers.get(j); + } + return qls; + } + +} Deleted: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -1,280 +0,0 @@ -/* - * JBoss, Home of Professional Open Source - * Copyright 2010, Red Hat, Inc., 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.extensions.bean.generic; - -import java.lang.annotation.Annotation; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.Map.Entry; - -import javax.enterprise.event.Observes; -import javax.enterprise.inject.Produces; -import javax.enterprise.inject.spi.AfterBeanDiscovery; -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; -import javax.enterprise.inject.spi.Bean; -import javax.enterprise.inject.spi.BeanManager; -import javax.enterprise.inject.spi.BeforeBeanDiscovery; -import javax.enterprise.inject.spi.Extension; -import javax.enterprise.inject.spi.InjectionTarget; -import javax.enterprise.inject.spi.ProcessAnnotatedType; -import javax.enterprise.inject.spi.ProcessInjectionTarget; -import javax.inject.Inject; - -import org.jboss.weld.extensions.annotated.AnnotatedTypeBuilder; -import org.jboss.weld.extensions.bean.BeanBuilder; -import org.jboss.weld.extensions.util.AnnotationInstanceProvider; - -public class GenericExtension implements Extension -{ - - private AnnotationInstanceProvider annotationProvider = new AnnotationInstanceProvider(); - - private Map<Class<?>, Set<AnnotatedType<?>>> genericBeans = new HashMap<Class<?>, Set<AnnotatedType<?>>>(); - - private Map<Class<?>, Map<AnnotatedField<?>, Annotation>> producerFields = new HashMap<Class<?>, Map<AnnotatedField<?>, Annotation>>(); - - /** - * map of a generic annotation type to all instances of that type found on - * beans - */ - private Map<Class<?>, Set<Annotation>> concreteGenerics = new HashMap<Class<?>, Set<Annotation>>(); - - /** - * Map of generic Annotation instance to a SyntheticQualifier - */ - private Map<Annotation, SyntheticQualifier> qualifierMap = new HashMap<Annotation, SyntheticQualifier>(); - - long count = 0; - - public void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event) - { - event.addQualifier(SyntheticQualifier.class); - } - - public void processAnnotatedType(@Observes ProcessAnnotatedType<?> event) - { - AnnotatedType<?> type = event.getAnnotatedType(); - if (type.isAnnotationPresent(Generic.class)) - { - Generic an = type.getAnnotation(Generic.class); - if (!genericBeans.containsKey(an.value())) - { - genericBeans.put(an.value(), new HashSet<AnnotatedType<?>>()); - } - genericBeans.get(an.value()).add(type); - // we will install (multiple copies of) this bean later - event.veto(); - - } - // make note of any producer fields that produce generic beans - for (Object f : type.getFields()) - { - AnnotatedField<?> field = (AnnotatedField<?>) f; - if (field.isAnnotationPresent(Produces.class)) - { - for (Annotation a : field.getAnnotations()) - { - if (a.annotationType().isAnnotationPresent(GenericAnnotation.class)) - { - if (!producerFields.containsKey(type.getJavaClass())) - { - producerFields.put(type.getJavaClass(), new HashMap<AnnotatedField<?>, Annotation>()); - } - if (!concreteGenerics.containsKey(a.annotationType())) - { - concreteGenerics.put(a.annotationType(), new HashSet<Annotation>()); - } - producerFields.get(type.getJavaClass()).put(field, a); - concreteGenerics.get(a.annotationType()).add(a); - } - } - } - } - } - - /** - * wraps InjectionTarget to initialise producer fields that produce generic - * beans - */ - public <T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event, BeanManager beanManager) - { - Class<?> javaClass = event.getAnnotatedType().getJavaClass(); - if (producerFields.containsKey(javaClass)) - { - Map<AnnotatedField<?>, Annotation> producers = producerFields.get(javaClass); - List<FieldSetter> setters = new ArrayList<FieldSetter>(); - for (AnnotatedField<?> a : producers.keySet()) - { - SyntheticQualifier qual = this.getQualifierForGeneric(producers.get(a)); - FieldSetter f = new FieldSetter(beanManager, a.getJavaMember(), qual); - setters.add(f); - } - ProducerFieldInjectionTarget<T> it = new ProducerFieldInjectionTarget<T>(event.getInjectionTarget(), setters); - event.setInjectionTarget(it); - } - } - - /** - * Installs the generic beans. - */ - public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager beanManager) - { - for (Entry<Class<?>, Set<AnnotatedType<?>>> entry : genericBeans.entrySet()) - { - Set<Annotation> concretes = concreteGenerics.get(entry.getKey()); - if (concretes != null) - { - for (AnnotatedType<?> type : entry.getValue()) - { - for (Annotation conc : concretes) - { - abd.addBean(redefineType(type, conc, beanManager)); - } - } - } - } - } - - private <X> Bean<X> redefineType(AnnotatedType<X> at, Annotation conc, BeanManager beanManager) - { - SyntheticQualifier newQualifier = getQualifierForGeneric(conc); - - AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlyingType(); - builder.addToClass(newQualifier); - for (AnnotatedField<? super X> f : at.getFields()) - { - if (f.isAnnotationPresent(Inject.class)) - { - // if this is a configuration injection point - if (conc.annotationType().isAssignableFrom(f.getJavaMember().getType())) - { - builder.removeFromField(f.getJavaMember(), Inject.class); - builder.addToField(f.getJavaMember(), InjectConfiguration.INSTANCE); - } - else - { - // check to see if we should be injecting a generic bean - // we do this by checking if there are any beans that can be - // injected into this point - // if there is not then we assume it is a generic injection - // point - // this has the downside that if it is actually a deployment - // error then it will confuse the user - Annotation[] qls = getQualifiers(f.getAnnotations(), beanManager); - Set<Bean<?>> beans = beanManager.getBeans(f.getJavaMember().getType(), qls); - if (beans.isEmpty()) - { - builder.addToField(f.getJavaMember(), newQualifier); - } - } - } - else if (f.isAnnotationPresent(Produces.class)) - { - // TODO: register a producer with the appropriate qualifier - } - } - for (AnnotatedMethod<?> m : at.getMethods()) - { - // TODO: need to properly handle Observer methods and Disposal - // methods - if (m.isAnnotationPresent(Produces.class)) - { - // TODO: we need to register the producer bean, so this is not - // very useful at the moment - for (AnnotatedParameter<?> pm : m.getParameters()) - { - Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()]; - - // check to see if we should be injecting a generic bean - // we do this by checking if there are any beans that can be - // injected into this point - // if there is not then we assume it is a generic injection - // point - // this has the downside that if it is actually a deployment - // error then it will confuse the user - Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager); - Set<Bean<?>> beans = beanManager.getBeans(paramType, qls); - if (beans.isEmpty()) - { - builder.addToMethod(m.getJavaMember(), newQualifier); - } - } - } - } - - for (AnnotatedConstructor<X> m : at.getConstructors()) - { - if (m.isAnnotationPresent(Inject.class)) - { - for (AnnotatedParameter<X> pm : m.getParameters()) - { - Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()]; - Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager); - Set<Bean<?>> beans = beanManager.getBeans(paramType, qls); - if (beans.isEmpty()) - { - builder.addToConstructorParameter(m.getJavaMember(), pm.getPosition(), newQualifier); - } - } - } - } - AnnotatedType<X> newAnnotatedType = builder.create(); - InjectionTarget<X> it = beanManager.createInjectionTarget(newAnnotatedType); - - it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, conc); - BeanBuilder<X> beanBuilder = new BeanBuilder<X>(newAnnotatedType, beanManager).defineBeanFromAnnotatedType().setInjectionTarget(it); - return beanBuilder.create(); - } - - public SyntheticQualifier getQualifierForGeneric(Annotation a) - { - if (!qualifierMap.containsKey(a)) - { - SyntheticQualifier qualifier = annotationProvider.get(SyntheticQualifier.class, (Map) Collections.singletonMap("value", count++)); - qualifierMap.put(a, qualifier); - } - return qualifierMap.get(a); - } - - static Annotation[] getQualifiers(Set<Annotation> annotations, BeanManager manager) - { - List<Annotation> qualifiers = new ArrayList<Annotation>(); - for (Annotation a : annotations) - { - if (manager.isQualifier(a.annotationType())) - { - qualifiers.add(a); - } - } - Annotation[] qls = new Annotation[qualifiers.size()]; - for (int j = 0; j < qls.length; ++j) - { - qls[j] = qualifiers.get(j); - } - return qls; - } - -} Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -16,12 +16,19 @@ */ package org.jboss.weld.extensions.bean.generic; +import java.lang.annotation.Annotation; +import java.lang.reflect.Member; import java.util.List; +import java.util.Map; import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.UnsatisfiedResolutionException; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; import javax.enterprise.inject.spi.InjectionTarget; import org.jboss.weld.extensions.bean.ForwardingInjectionTarget; +import org.jboss.weld.extensions.util.properties.Property; /** * {@link InjectionTarget} wrapper used for beans that have generic producer fields @@ -33,12 +40,19 @@ public class ProducerFieldInjectionTarget<T> extends ForwardingInjectionTarget<T> { private final InjectionTarget<T> delegate; - private final List<FieldSetter> fieldSetters; + + private final BeanManager beanManager; + private final List<Property<Object>> properties; + private final Map<Member, Annotation> producers; + private final SyntheticQualifierManager syntheticQualifierManager; - public ProducerFieldInjectionTarget(InjectionTarget<T> delegate, List<FieldSetter> fieldSetters) + public ProducerFieldInjectionTarget(InjectionTarget<T> delegate, BeanManager beanManager, List<Property<Object>> properties, Map<Member, Annotation> producers, SyntheticQualifierManager syntheticQualifierManager) { this.delegate = delegate; - this.fieldSetters = fieldSetters; + this.beanManager = beanManager; + this.properties = properties; + this.producers = producers; + this.syntheticQualifierManager = syntheticQualifierManager; } @Override @@ -50,9 +64,16 @@ @Override public void inject(T instance, CreationalContext<T> ctx) { - for (FieldSetter f : fieldSetters) + for (Property<Object> property: properties) { - f.set(instance, ctx); + SyntheticQualifier qualifier = syntheticQualifierManager.getQualifierForGeneric(producers.get(property.getMember())); + Bean<?> bean = beanManager.resolve(beanManager.getBeans(property.getBaseType(), qualifier)); + if (bean == null) + { + throw new UnsatisfiedResolutionException("Could not resolve bean for Generic Producer " + property.toString() + ". Type: " + property.getJavaClass() + " Qualifiers:" + qualifier); + } + Object value = beanManager.getReference(bean, property.getBaseType(), ctx); + property.setValue(instance, value); } delegate().inject(instance, ctx); } Added: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java (rev 0) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -0,0 +1,38 @@ +package org.jboss.weld.extensions.bean.generic; + +import java.lang.annotation.Annotation; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import org.jboss.weld.extensions.util.AnnotationInstanceProvider; + +class SyntheticQualifierManager +{ + + + private final AnnotationInstanceProvider annotationProvider; + + //Map of generic Annotation instance to a SyntheticQualifier + private final Map<Annotation, SyntheticQualifier> qualifierMap; + + private long count; + + SyntheticQualifierManager() + { + this.qualifierMap = new HashMap<Annotation, SyntheticQualifier>(); + this.annotationProvider = new AnnotationInstanceProvider(); + this.count = 0; + } + + SyntheticQualifier getQualifierForGeneric(Annotation annotation) + { + if (!qualifierMap.containsKey(annotation)) + { + SyntheticQualifier qualifier = annotationProvider.get(SyntheticQualifier.class, Collections.singletonMap("value", count++)); + qualifierMap.put(annotation, qualifier); + } + return qualifierMap.get(annotation); + } + +} Property changes on: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -46,7 +46,7 @@ * Returns an instance of the given annotation type with member values * specified in the map. */ - public <T extends Annotation> T get(Class<T> annotation, Map<String, Object> values) + public <T extends Annotation> T get(Class<T> annotation, Map<String, ?> values) { if (annotation == null) { Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -57,10 +57,10 @@ private static class SerializationProxy { - private final Map<String, Object> valueMap; + private final Map<String, ?> valueMap; private final Class<? extends Annotation> annotationType; - private SerializationProxy(Map<String, Object> valueMap, Class<? extends Annotation> annotationType) + private SerializationProxy(Map<String, ?> valueMap, Class<? extends Annotation> annotationType) { this.valueMap = valueMap; this.annotationType = annotationType; @@ -81,7 +81,7 @@ private final Method[] members; - AnnotationInvocationHandler(Map<String, Object> values, Class<? extends Annotation> annotationType) + AnnotationInvocationHandler(Map<String, ?> values, Class<? extends Annotation> annotationType) { this.valueMap = new HashMap<String, Object>(); valueMap.putAll(values); Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -4,6 +4,7 @@ package org.jboss.weld.extensions.util.properties; import java.lang.reflect.Field; +import java.lang.reflect.Member; import java.lang.reflect.Type; /** @@ -46,6 +47,11 @@ { return field; } + + public Member getMember() + { + return field; + } @SuppressWarnings("unchecked") public Class<V> getJavaClass() @@ -100,4 +106,22 @@ { return false; } + + @Override + public String toString() + { + return field.toString(); + } + + @Override + public int hashCode() + { + return field.hashCode(); + } + + @Override + public boolean equals(Object obj) + { + return field.equals(obj); + } } \ No newline at end of file Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -3,8 +3,10 @@ */ package org.jboss.weld.extensions.util.properties; +import static org.jboss.weld.extensions.util.Reflections.invokeMethod; + import java.beans.Introspector; -import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Member; import java.lang.reflect.Method; import java.lang.reflect.Type; @@ -59,6 +61,11 @@ return getterMethod; } + public Member getMember() + { + return getterMethod; + } + public V getValue(Object instance) { return getJavaClass().cast(invokeMethod(getterMethod, instance)); @@ -69,46 +76,6 @@ invokeMethod(setterMethod, instance, value); } - private static String buildInvokeMethodErrorMessage(Method method, Object obj, Object... args) - { - StringBuilder message = new StringBuilder(String.format("Exception invoking method [%s] on object [%s], using arguments [", method.getName(), obj)); - if (args != null) - for (int i = 0; i < args.length; i++) - message.append((i > 0 ? "," : "") + args[i]); - message.append("]"); - return message.toString(); - } - - private static Object invokeMethod(Method method, Object obj, Object... args) - { - try - { - return method.invoke(obj, args); - } - catch (IllegalAccessException ex) - { - throw new RuntimeException(buildInvokeMethodErrorMessage(method, obj, args), ex); - } - catch (IllegalArgumentException ex) - { - throw new IllegalArgumentException(buildInvokeMethodErrorMessage(method, obj, args), ex.getCause()); - } - catch (InvocationTargetException ex) - { - throw new RuntimeException(buildInvokeMethodErrorMessage(method, obj, args), ex); - } - catch (NullPointerException ex) - { - NullPointerException ex2 = new NullPointerException(buildInvokeMethodErrorMessage(method, obj, args)); - ex2.initCause(ex.getCause()); - throw ex2; - } - catch (ExceptionInInitializerError e) - { - throw new RuntimeException(buildInvokeMethodErrorMessage(method, obj, args), e); - } - } - private static Method getSetterMethod(Class<?> clazz, String name) { Method[] methods = clazz.getMethods(); @@ -161,5 +128,47 @@ { return setterMethod == null; } + + @Override + public String toString() + { + StringBuilder builder = new StringBuilder(); + if (isReadOnly()) + { + builder.append("read-only ").append(setterMethod.toString()).append("; "); + } + builder.append(getterMethod.toString()); + return builder.toString(); + } + + @Override + public int hashCode() + { + int hash = 1; + hash = hash * 31 + (setterMethod == null ? 0 : setterMethod.hashCode()); + hash = hash * 31 + getterMethod.hashCode(); + return hash; + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof MethodPropertyImpl<?>) + { + MethodPropertyImpl<?> that = (MethodPropertyImpl<?>) obj; + if (this.setterMethod == null) + { + return that.setterMethod == null && this.getterMethod.equals(that.getterMethod); + } + else + { + return this.setterMethod.equals(that.setterMethod) && this.getterMethod.equals(that.getterMethod); + } + } + else + { + return false; + } + } } \ No newline at end of file Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -1,6 +1,7 @@ package org.jboss.weld.extensions.util.properties; import java.lang.reflect.Field; +import java.lang.reflect.Member; import java.lang.reflect.Method; /** @@ -38,4 +39,28 @@ { return new MethodPropertyImpl<V>(method); } + + /** + * Create a JavaBean style property from the specified member + * + * @param <V> + * @param member + * @return + * @throws IllegalArgumentException if the method does not match JavaBean conventions + */ + public static <V> Property<V> createProperty(Member member) + { + if (member instanceof Method) + { + return new MethodPropertyImpl<V>(Method.class.cast(member)); + } + else if (member instanceof Field) + { + return new FieldPropertyImpl<V>(Field.class.cast(member)); + } + else + { + throw new IllegalArgumentException("Cannot make a property of " + member + " - it is neither a method or a field"); + } + } } Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java 2010-07-23 21:41:46 UTC (rev 6782) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java 2010-07-23 21:42:50 UTC (rev 6783) @@ -1,6 +1,7 @@ package org.jboss.weld.extensions.util.properties; import java.lang.reflect.AnnotatedElement; +import java.lang.reflect.Member; import java.lang.reflect.Type; /** @@ -40,13 +41,20 @@ public Class<V> getJavaClass(); /** - * Get the element backing the property + * Get the element responsible for retrieving the property value * * @return */ public AnnotatedElement getAnnotatedElement(); /** + * Get the member responsible for retrieving the property value + * + * @return + */ + public Member getMember(); + + /** * Returns the property value for the specified bean. The property to be * returned is either a field or getter method. *