[weld-commits] Weld SVN: r6795 - in extensions/trunk: impl/src/main/java/org/jboss/weld/extensions/bean and 4 other directories.

Author: pete.muir(a)jboss.org Date: 2010-07-24 08:23:29 -0400 (Sat, 24 Jul 2010) New Revision: 6795 Added: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Arrays2.java Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanBuilder.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanImpl.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycle.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycleImpl.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/PassivationCapableBeanImpl.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Synthetic.java extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/Baz.java extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java extensions/trunk/pom.xml Log: reimpl as Bean rather than IT wrapper Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanBuilder.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanBuilder.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanBuilder.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -23,15 +23,15 @@ import javax.enterprise.context.Dependent; import javax.enterprise.inject.Alternative; -import javax.enterprise.inject.Default; import javax.enterprise.inject.spi.AnnotatedType; import javax.enterprise.inject.spi.Bean; import javax.enterprise.inject.spi.BeanManager; +import javax.enterprise.inject.spi.InjectionPoint; import javax.enterprise.inject.spi.InjectionTarget; -import javax.enterprise.util.AnnotationLiteral; import javax.inject.Named; import org.jboss.weld.extensions.annotated.Annotateds; +import org.jboss.weld.extensions.literal.DefaultLiteral; /** * class that can build a bean from an AnnotatedType. @@ -42,38 +42,43 @@ public class BeanBuilder<T> { - private final AnnotatedType<T> type; private final BeanManager beanManager; - private InjectionTarget<T> injectionTarget; + + private Class<? extends T> javaClass; private String name; private Set<Annotation> qualifiers; private Class<? extends Annotation> scope; private Set<Class<? extends Annotation>> stereotypes; - private Set<Type> types = new HashSet<Type>(); - private boolean alternative = false; - private boolean nullable = false; + private Set<Type> types; + private Set<InjectionPoint> injectionPoints; + private boolean alternative; + private boolean nullable; private BeanLifecycle<T> beanLifecycle; boolean passivationCapable; private String id; - public BeanBuilder(AnnotatedType<T> type, BeanManager beanManager) + public BeanBuilder(BeanManager beanManager) { - this.type = type; this.beanManager = beanManager; } - public BeanBuilder<T> defineBeanFromAnnotatedType() + public BeanBuilder<T> defineBeanFromAnnotatedType(AnnotatedType<T> type) { + this.javaClass = type.getJavaClass(); + InjectionTarget<T> injectionTarget; if (!type.getJavaClass().isInterface()) { - this.injectionTarget = beanManager.createInjectionTarget(type); + injectionTarget = beanManager.createInjectionTarget(type); } else { - this.injectionTarget = new DummyInjectionTarget<T>(); + injectionTarget = new DummyInjectionTarget<T>(); } + this.beanLifecycle = new BeanLifecycleImpl<T>(injectionTarget); + this.injectionPoints = injectionTarget.getInjectionPoints(); this.qualifiers = new HashSet<Annotation>(); this.stereotypes = new HashSet<Class<? extends Annotation>>(); + this.types = new HashSet<Type>(); for (Annotation annotation : type.getAnnotations()) { if (beanManager.isQualifier(annotation.annotationType())) @@ -111,11 +116,8 @@ } if (qualifiers.isEmpty()) { - qualifiers.add(new AnnotationLiteral<Default>() - { - }); + qualifiers.add(DefaultLiteral.INSTANCE); } - this.beanLifecycle = new BeanLifecycleImpl<T>(); this.id = BeanImpl.class.getName() + ":" + Annotateds.createTypeId(type); return this; } @@ -124,23 +126,11 @@ { if (!passivationCapable) { - return new BeanImpl<T>(type.getJavaClass(), injectionTarget, name, qualifiers, scope, stereotypes, types, alternative, nullable, beanLifecycle); + return new BeanImpl<T>(javaClass, name, qualifiers, scope, stereotypes, types, alternative, nullable, injectionPoints, beanLifecycle); } - return new PassivationCapableBeanImpl<T>(id, type.getJavaClass(), injectionTarget, name, qualifiers, scope, stereotypes, types, alternative, nullable, beanLifecycle); - + return new PassivationCapableBeanImpl<T>(id, javaClass, name, qualifiers, scope, stereotypes, types, alternative, nullable, injectionPoints, beanLifecycle); } - public InjectionTarget<T> getInjectionTarget() - { - return injectionTarget; - } - - public BeanBuilder<T> setInjectionTarget(InjectionTarget<T> injectionTarget) - { - this.injectionTarget = injectionTarget; - return this; - } - public Set<Annotation> getQualifiers() { return qualifiers; @@ -218,10 +208,16 @@ return this; } - public AnnotatedType<T> getType() + public Class<? extends T> getJavaClass() { - return type; + return javaClass; } + + public BeanBuilder<T> setJavaClass(Class<? extends T> javaClass) + { + this.javaClass = javaClass; + return this; + } public BeanManager getBeanManager() { @@ -260,5 +256,16 @@ this.id = id; return this; } + + public Set<InjectionPoint> getInjectionPoints() + { + return injectionPoints; + } + + public BeanBuilder<T> setInjectionPoints(Set<InjectionPoint> injectionPoints) + { + this.injectionPoints = injectionPoints; + return this; + } } Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanImpl.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanImpl.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanImpl.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -22,22 +22,30 @@ import java.util.HashSet; import java.util.Set; +import javax.enterprise.context.Dependent; import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.Default; import javax.enterprise.inject.spi.Bean; import javax.enterprise.inject.spi.InjectionPoint; -import javax.enterprise.inject.spi.InjectionTarget; +import org.jboss.weld.extensions.literal.DefaultLiteral; +import org.jboss.weld.extensions.util.Arrays2; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + /** - * An immutable bean. + * An immutable bean which provides basic defaulting and checking of arguments. * * @author stuart + * @author Pete Muir * - * @param <T> */ public class BeanImpl<T> implements Bean<T> { + + private static final Logger log = LoggerFactory.getLogger(BeanImpl.class); + private final Class<?> beanClass; - private final InjectionTarget<T> injectionTarget; private final String name; private final Set<Annotation> qualifiers; private final Class<? extends Annotation> scope; @@ -46,16 +54,79 @@ private final boolean alternative; private final boolean nullable; private final BeanLifecycle<T> beanLifecycle; + private final Set<InjectionPoint> injectionPoints; - BeanImpl(Class<?> beanClass, InjectionTarget<T> injectionTarget, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope, Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative, boolean nullable, BeanLifecycle<T> beanLifecycle) + /** + * Create a new, immutable bean. All arguments passed as collections are defensively copied. + * + * @param beanClass The Bean class, may not be null + * @param name The bean name + * @param qualifiers The bean's qualifiers, if null, a singleton set of + * {@link Default} is used + * @param scope The bean's scope, if null, the default scope of + * {@link Dependent} is used + * @param stereotypes The bean's stereotypes, if null, an empty set is used + * @param types The bean's types, if null, the beanClass and {@link Object} + * will be used + * @param alternative True if the bean is an alternative + * @param nullable True if the bean is nullable + * @param injectionPoints the bean's injection points, if null an empty set is used + * @param beanLifecycle Handler for {@link #create(CreationalContext)} and + * {@link #destroy(Object, CreationalContext)} + * + * @throws IllegalArgumentException if the beanClass is null + */ + public BeanImpl(Class<?> beanClass, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope, Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative, boolean nullable, Set<InjectionPoint> injectionPoints, BeanLifecycle<T> beanLifecycle) { + if (beanClass == null) + { + throw new IllegalArgumentException("beanClass cannot be null"); + } this.beanClass = beanClass; - this.injectionTarget = injectionTarget; this.name = name; - this.qualifiers = new HashSet<Annotation>(qualifiers); - this.scope = scope; - this.stereotypes = new HashSet<Class<? extends Annotation>>(stereotypes); - this.types = new HashSet<Type>(types); + if (qualifiers == null) + { + this.qualifiers = Collections.<Annotation>singleton(DefaultLiteral.INSTANCE); + log.trace("No qualifers provided for bean class " + beanClass + ", using singleton set of @Default"); + } + else + { + this.qualifiers = new HashSet<Annotation>(qualifiers); + } + if (scope == null) + { + this.scope = Dependent.class; + log.trace("No scope provided for bean class " + beanClass + ", using @Dependent"); + } + else + { + this.scope = scope; + } + if (stereotypes == null) + { + this.stereotypes = Collections.emptySet(); + } + else + { + this.stereotypes = new HashSet<Class<? extends Annotation>>(stereotypes); + } + if (types == null) + { + this.types = Arrays2.<Type>asSet(Object.class, beanClass); + log.trace("No types provided for bean class " + beanClass + ", using [java.lang.Object.class, " + beanClass.getName() + ".class]"); + } + else + { + this.types = new HashSet<Type>(types); + } + if (injectionPoints == null) + { + this.injectionPoints = Collections.emptySet(); + } + else + { + this.injectionPoints = new HashSet<InjectionPoint>(injectionPoints); + } this.alternative = alternative; this.nullable = nullable; this.beanLifecycle = beanLifecycle; @@ -68,14 +139,9 @@ public Set<InjectionPoint> getInjectionPoints() { - return injectionTarget.getInjectionPoints(); + return injectionPoints; } - public InjectionTarget<T> getInjectionTarget() - { - return injectionTarget; - } - public String getName() { return name; @@ -120,7 +186,7 @@ { beanLifecycle.destroy(this, arg0, arg1); } - + @Override public String toString() { Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycle.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycle.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycle.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -17,9 +17,12 @@ package org.jboss.weld.extensions.bean; import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.InjectionTarget; /** - * Handler for the create/destroy methods of CustomBean + * Handler for the create/destroy methods of {@link BeanImpl}. By default, the + * {@link InjectionTarget} will be used to create and destroy the bean * * @author stuart * @@ -27,8 +30,8 @@ */ public interface BeanLifecycle<T> { - public T create(BeanImpl<T> bean, CreationalContext<T> arg0); + public T create(Bean<T> bean, CreationalContext<T> arg0); - public void destroy(BeanImpl<T> bean, T arg0, CreationalContext<T> arg1); + public void destroy(Bean<T> bean, T arg0, CreationalContext<T> arg1); } Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycleImpl.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycleImpl.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/BeanLifecycleImpl.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -17,25 +17,32 @@ package org.jboss.weld.extensions.bean; import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.InjectionTarget; -public class BeanLifecycleImpl<T> implements BeanLifecycle<T> +class BeanLifecycleImpl<T> implements BeanLifecycle<T> { - public BeanLifecycleImpl() {} + private final InjectionTarget<T> injectionTarget; - public T create(BeanImpl<T> bean, CreationalContext<T> creationalContext) + BeanLifecycleImpl(InjectionTarget<T> injectionTarget) { - T instance = bean.getInjectionTarget().produce(creationalContext); - bean.getInjectionTarget().inject(instance, creationalContext); - bean.getInjectionTarget().postConstruct(instance); + this.injectionTarget = injectionTarget; + } + + public T create(Bean<T> bean, CreationalContext<T> creationalContext) + { + T instance = injectionTarget.produce(creationalContext); + injectionTarget.inject(instance, creationalContext); + injectionTarget.postConstruct(instance); return instance; } - public void destroy(BeanImpl<T> bean, T instance, CreationalContext<T> creationalContext) + public void destroy(Bean<T> bean, T instance, CreationalContext<T> creationalContext) { try { - bean.getInjectionTarget().preDestroy(instance); + injectionTarget.preDestroy(instance); creationalContext.release(); } catch (Exception e) Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/PassivationCapableBeanImpl.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/PassivationCapableBeanImpl.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/PassivationCapableBeanImpl.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -20,16 +20,16 @@ import java.lang.reflect.Type; import java.util.Set; -import javax.enterprise.inject.spi.InjectionTarget; +import javax.enterprise.inject.spi.InjectionPoint; import javax.enterprise.inject.spi.PassivationCapable; public class PassivationCapableBeanImpl<T> extends BeanImpl<T> implements PassivationCapable { private final String id; - PassivationCapableBeanImpl(String id, Class<?> beanClass, InjectionTarget<T> injectionTarget, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope, Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative, boolean nullable, BeanLifecycle<T> beanLifecycle) + PassivationCapableBeanImpl(String id, Class<?> beanClass, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope, Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative, boolean nullable, Set<InjectionPoint> injectionPoints, BeanLifecycle<T> beanLifecycle) { - super(beanClass, injectionTarget, name, qualifiers, scope, stereotypes, types, alternative, nullable, beanLifecycle); + super(beanClass, name, qualifiers, scope, stereotypes, types, alternative, nullable, injectionPoints, beanLifecycle); this.id = id; } Modified: 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/GenericBeanExtension.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -21,6 +21,7 @@ import java.lang.annotation.Annotation; import java.lang.reflect.Member; +import java.lang.reflect.Type; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; @@ -29,6 +30,8 @@ import java.util.Set; import java.util.Map.Entry; +import javax.enterprise.context.Dependent; +import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.event.Observes; import javax.enterprise.inject.Produces; import javax.enterprise.inject.spi.AfterBeanDiscovery; @@ -41,13 +44,14 @@ 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.bean.BeanLifecycle; +import org.jboss.weld.extensions.util.Arrays2; import org.jboss.weld.extensions.util.Synthetic; import org.jboss.weld.extensions.util.properties.Properties; import org.jboss.weld.extensions.util.properties.Property; @@ -186,7 +190,7 @@ { for (Annotation concrete : concretes) { - event.addBean(redefineType(type, concrete, beanManager)); + event.addBean(redefineType(type, concrete, beanManager, event)); } } } @@ -194,12 +198,12 @@ } // TODO Do we need to do something this complex, can't we just register the relevant beans? - private <X> Bean<X> redefineType(AnnotatedType<X> annotatedType, Annotation concrete, BeanManager beanManager) + private <X> Bean<X> redefineType(AnnotatedType<X> annotatedType, Annotation concrete, BeanManager beanManager, AfterBeanDiscovery event) { - Synthetic syntheticQualifier = syntheticProvider.get(concrete); + Synthetic genericBeanSyntheticQualifier = syntheticProvider.get(concrete); AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(annotatedType).readAnnotationsFromUnderlyingType(); - builder.addToClass(syntheticQualifier); + builder.addToClass(genericBeanSyntheticQualifier); for (AnnotatedField<? super X> field : annotatedType.getFields()) { if (field.isAnnotationPresent(Inject.class)) @@ -207,8 +211,9 @@ // if this is a configuration injection point if (concrete.annotationType().isAssignableFrom(field.getJavaMember().getType())) { - builder.removeFromField(field.getJavaMember(), Inject.class); - builder.addToField(field.getJavaMember(), InjectConfiguration.INSTANCE); + Synthetic genericConfigurationQualifier = syntheticProvider.get(); + builder.addToField(field.getJavaMember(), genericConfigurationQualifier); + event.addBean(createConfigurationBean(beanManager, concrete, genericConfigurationQualifier)); } else { @@ -224,7 +229,7 @@ Set<Bean<?>> beans = beanManager.getBeans(field.getJavaMember().getType(), qualifiers); if (beans.isEmpty()) { - builder.addToField(field.getJavaMember(), syntheticQualifier); + builder.addToField(field.getJavaMember(), genericBeanSyntheticQualifier); } } } @@ -256,7 +261,7 @@ Set<Bean<?>> beans = beanManager.getBeans(paramType, qualifiers); if (beans.isEmpty()) { - builder.addToMethod(method.getJavaMember(), syntheticQualifier); + builder.addToMethod(method.getJavaMember(), genericBeanSyntheticQualifier); } } } @@ -273,17 +278,38 @@ Set<Bean<?>> beans = beanManager.getBeans(paramType, qualifiers); if (beans.isEmpty()) { - builder.addToConstructorParameter(constructor.getJavaMember(), parameter.getPosition(), syntheticQualifier); + builder.addToConstructorParameter(constructor.getJavaMember(), parameter.getPosition(), genericBeanSyntheticQualifier); } } } } - AnnotatedType<X> newAnnotatedType = builder.create(); - InjectionTarget<X> it = beanManager.createInjectionTarget(newAnnotatedType); - - it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, concrete); - BeanBuilder<X> beanBuilder = new BeanBuilder<X>(newAnnotatedType, beanManager).defineBeanFromAnnotatedType().setInjectionTarget(it); + BeanBuilder<X> beanBuilder = new BeanBuilder<X>(beanManager).defineBeanFromAnnotatedType(builder.create()); return beanBuilder.create(); } + + private Bean<Annotation> createConfigurationBean(BeanManager beanManager, final Annotation genericConfiguration, Annotation syntheticQualifier) + { + BeanBuilder<Annotation> builder = new BeanBuilder<Annotation>(beanManager) + .setJavaClass(genericConfiguration.annotationType()) + .setTypes(Arrays2.<Type>asSet(genericConfiguration.annotationType(), Object.class)) + .setScope(Dependent.class) + .setQualifiers(Arrays2.asSet(syntheticQualifier)) + // TODO make this passivation capable? + .setBeanLifecycle(new BeanLifecycle<Annotation>() + { + + public void destroy(Bean<Annotation> bean, Annotation arg0, CreationalContext<Annotation> arg1) + { + // No-op + } + + public Annotation create(Bean<Annotation> bean, CreationalContext<Annotation> arg0) + { + return genericConfiguration; + } + }); + + return builder.create(); + } } Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -161,7 +161,7 @@ annotatedTypeBuilder.addToClass(ann); } AnnotatedType<X> construtsAnnotatedType = builder.create(); - additionalBeans.add(new BeanBuilder<X>(construtsAnnotatedType, beanManager).create()); + additionalBeans.add(new BeanBuilder<X>(beanManager).defineBeanFromAnnotatedType(construtsAnnotatedType).create()); } } } Added: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Arrays2.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Arrays2.java (rev 0) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Arrays2.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -0,0 +1,41 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, 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.util; + +import java.util.HashSet; +import java.util.Set; + +/** + * @author pmuir + * + */ +public class Arrays2 +{ + + private Arrays2() {} + + public static <T> Set<T> asSet(T... array) + { + Set<T> result = new HashSet<T>(); + for (T a : array) + { + result.add(a); + } + return result; + } + +} Property changes on: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Arrays2.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Synthetic.java =================================================================== --- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Synthetic.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Synthetic.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -26,7 +26,8 @@ import javax.enterprise.util.AnnotationLiteral; /** - * A synthetic qualifier that can be used to replace other user-supplied configuration at deployment + * A synthetic qualifier that can be used to replace other user-supplied + * configuration at deployment * * @author Stuart Douglas <stuart(a)baileyroberts.com.au&gt; * @author Pete Muir @@ -35,18 +36,18 @@ @Retention(RetentionPolicy.RUNTIME) public @interface Synthetic { - + long index(); - + String namespace(); - + public static class SyntheticLiteral extends AnnotationLiteral<Synthetic> implements Synthetic { - + private final Long index; - + private final String namespace; - + public SyntheticLiteral(String namespace, Long index) { this.namespace = namespace; @@ -57,23 +58,29 @@ { return index; } - + public String namespace() { return namespace; } - + } - + + /** + * Provides a unique Synthetic qualifier for the specified namespace + * + * @author pmuir + * + */ public static class Provider { - + //Map of generic Annotation instance to a SyntheticQualifier private final Map<Annotation, Synthetic> synthetics; private final String namespace; - + private AtomicLong count; - + public Provider(String namespace) { this.synthetics = new HashMap<Annotation, Synthetic>(); @@ -81,6 +88,13 @@ this.count = new AtomicLong(); } + /** + * Get a synthetic qualifier. The provided annotation is used to map the + * generated qualifier, allowing later retrieval. + * + * @param annotation + * @return + */ public Synthetic get(Annotation annotation) { if (!synthetics.containsKey(annotation)) @@ -89,6 +103,17 @@ } return synthetics.get(annotation); } + + /** + * Get a synthetic qualifier. The qualifier will not be stored for later + * retrieval. + * + * @return + */ + public Synthetic get() + { + return new Synthetic.SyntheticLiteral(namespace, count.getAndIncrement()); + } } - + } Modified: extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/Baz.java =================================================================== --- extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/Baz.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/Baz.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -36,6 +36,9 @@ @Inject private Corge corge; + + @Inject + private Garply garply; public Bar getBar() { @@ -46,4 +49,9 @@ { return corge; } + + public Garply getGarply() + { + return garply; + } } Modified: extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java =================================================================== --- extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java 2010-07-24 12:23:29 UTC (rev 6795) @@ -46,7 +46,11 @@ @Test public void testGeneric() { - // Test that the generic injection wiring is working! + // Test that the generic configuration injection wiring is working! + assert baz1.getGarply() != null; + assert baz1.getGarply().equals("hello1"); + assert baz2.getGarply() != null; + assert baz2.getGarply().equals("hello2"); assert baz1.getBar() != null; assert baz1.getBar().getInjectedGarply() != null; assert baz1.getBar().getInjectedGarply().value().equals("hello1"); Modified: extensions/trunk/pom.xml =================================================================== --- extensions/trunk/pom.xml 2010-07-24 12:15:41 UTC (rev 6794) +++ extensions/trunk/pom.xml 2010-07-24 12:23:29 UTC (rev 6795) @@ -62,8 +62,8 @@ </ciManagement> <properties> - <weld.api.version>1.0-SP1</weld.api.version> - <weld.core.version>1.0.1-Final</weld.core.version> + <weld.api.version>1.1-SNAPSHOT</weld.api.version> + <weld.core.version>1.1.0-SNAPSHOT</weld.core.version> <slf4j.version>1.5.10</slf4j.version> <testng.version>5.12.1</testng.version> <jboss.test.harness.version>1.1.0-CR3</jboss.test.harness.version>