[weld-commits] Weld SVN: r6196 - in extensions/trunk/src/main/java/org/jboss/weld/extensions: bean/generic and 2 other directories.
weld-commits at lists.jboss.org
weld-commits at lists.jboss.org
Thu Apr 29 15:24:24 EDT 2010
Author: pete.muir at jboss.org
Date: 2010-04-29 15:24:23 -0400 (Thu, 29 Apr 2010)
New Revision: 6196
Removed:
extensions/trunk/src/main/java/org/jboss/weld/extensions/ExactLiteral.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/util/BeanImpl.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/util/reannotated/
Modified:
extensions/trunk/src/main/java/org/jboss/weld/extensions/CoreExtension.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/Exact.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanInjectionTargetWrapper.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/InjectConfiguration.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/util/ReflectionUtils.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationBuilder.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationRedefiner.java
extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/NewAnnotatedTypeBuilder.java
Log:
remove reannotated stuff (first pass, still needs more cleaning)
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/CoreExtension.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/CoreExtension.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/CoreExtension.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -16,38 +16,46 @@
*/
package org.jboss.weld.extensions;
+import static org.jboss.weld.extensions.util.ReflectionUtils.getAnnotationsWithMetatype;
+import static org.jboss.weld.extensions.util.ReflectionUtils.getMemberType;
+
import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Set;
import javax.enterprise.event.Observes;
-import javax.enterprise.inject.Default;
import javax.enterprise.inject.Produces;
import javax.enterprise.inject.spi.AfterBeanDiscovery;
-import javax.enterprise.inject.spi.Annotated;
import javax.enterprise.inject.spi.AnnotatedConstructor;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.Extension;
import javax.enterprise.inject.spi.ProcessAnnotatedType;
-import javax.enterprise.util.AnnotationLiteral;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Qualifier;
-import org.jboss.weld.extensions.util.BeanImpl;
-import org.jboss.weld.extensions.util.reannotated.AnnotationRedefinition;
-import org.jboss.weld.extensions.util.reannotated.Reannotated;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedMember;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedType;
+import org.jboss.weld.extensions.Exact.ExactLiteral;
+import org.jboss.weld.extensions.bean.CustomBeanBuilder;
+import org.jboss.weld.extensions.util.annotated.AnnotationBuilder;
+import org.jboss.weld.extensions.util.annotated.MemberAnnotationRedefiner;
+import org.jboss.weld.extensions.util.annotated.NewAnnotatedTypeBuilder;
+import org.jboss.weld.extensions.util.annotated.Parameter;
+import org.jboss.weld.extensions.util.annotated.ParameterAnnotationRedefiner;
-public class CoreExtension implements Extension
+class CoreExtension implements Extension
{
- Collection<Bean<?>> additionalBeans = new ArrayList<Bean<?>>();
+ private final Collection<Bean<?>> additionalBeans;
+ CoreExtension()
+ {
+ this.additionalBeans = new ArrayList<Bean<?>>();
+ }
+
<X> void processAnnotatedType(@Observes final ProcessAnnotatedType<X> pat, BeanManager bm)
{
if (pat.getAnnotatedType().isAnnotationPresent(Veto.class))
@@ -57,30 +65,23 @@
}
final AnnotatedType<X> at = pat.getAnnotatedType();
+ NewAnnotatedTypeBuilder<X> builder = NewAnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlying();
- ReannotatedType<X> rt = new ReannotatedType<X>(at);
-
// support for @Named packages
Package pkg = at.getJavaClass().getPackage();
if (pkg.isAnnotationPresent(Named.class))
{
final String packageName = getPackageName(pkg);
- if (at.isAnnotationPresent(Named.class))
+
+ builder.redefineMembers(Named.class, new MemberAnnotationRedefiner<Named>()
{
- String className = at.getJavaClass().getSimpleName();
- String beanName = getName(at, className);
- rt.define(new NamedLiteral(packageName + '.' + beanName));
- }
- rt.redefineMembers(Named.class, new AnnotationRedefinition<Named>()
- {
-
- @SuppressWarnings("unchecked")
- public Named redefine(Named annotation, Reannotated reannotated)
+
+ public Named redefine(Named annotation, Member member, AnnotationBuilder annotations)
{
- if (reannotated.isAnnotationPresent(Produces.class))
+ if (annotations.isAnnotationPresent(Produces.class))
{
- String memberName = ((ReannotatedMember<? super X>) reannotated).getJavaMember().getName();
- String beanName = getName(reannotated, memberName);
+ String memberName = member.getName();
+ String beanName = getName(annotation, memberName);
return new NamedLiteral(packageName + '.' + beanName);
}
else
@@ -90,26 +91,31 @@
}
});
+
+ if (at.isAnnotationPresent(Named.class))
+ {
+ String className = at.getJavaClass().getSimpleName();
+ String beanName = getName(at.getAnnotation(Named.class), className);
+ builder.addToClass(new NamedLiteral(packageName + '.' + beanName));
+ }
+
}
// support for @Exact
- Set<Annotation> qualfiers = rt.getAnnotationsWithMetatype(Qualifier.class);
- boolean defaultQualifier = qualfiers.isEmpty() || (qualfiers.size() == 1 && qualfiers.iterator().next().annotationType() == Named.class);
- if (defaultQualifier)
+ Set<Annotation> qualfiers = getAnnotationsWithMetatype(at.getAnnotations(), Qualifier.class);
+ if (qualfiers.isEmpty() || (qualfiers.size() == 1 && qualfiers.iterator().next().annotationType() == Named.class))
{
- rt.define(new AnnotationLiteral<Default>()
- {
- });
+ builder.addToClass(DefaultLiteral.INSTANCE);
}
- rt.define(new ExactLiteral(at.getJavaClass()));
- rt.redefineMembersAndParameters(Exact.class, new AnnotationRedefinition<Exact>()
+ builder.addToClass(new Exact.ExactLiteral(at.getJavaClass()));
+ builder.redefineMembers(Exact.class, new MemberAnnotationRedefiner<Exact>()
{
-
- public Exact redefine(Exact annotation, Reannotated reannotated)
+
+ public Exact redefine(Exact annotation, Member annotated, AnnotationBuilder annotations)
{
if (annotation.value() == void.class)
{
- return new ExactLiteral(reannotated.getJavaClass());
+ return new ExactLiteral(getMemberType(annotated));
}
else
{
@@ -118,43 +124,47 @@
}
});
- pat.setAnnotatedType(rt);
+ builder.redefineMemberParameters(Exact.class, new ParameterAnnotationRedefiner<Exact>()
+ {
+ public Exact redefine(Exact annotation, Parameter annotated, AnnotationBuilder annotations)
+ {
+ if (annotation.value() == void.class)
+ {
+ return new ExactLiteral(getMemberType(annotated.getDeclaringMember()));
+ }
+ else
+ {
+ return annotation;
+ }
+ }
+
+ });
+
+ pat.setAnnotatedType(builder.create());
+
// support for @Constructs
for (AnnotatedConstructor<X> constructor : at.getConstructors())
{
if (constructor.isAnnotationPresent(Constructs.class))
{
- ReannotatedType<X> rtc = new ReannotatedType<X>(at);
+ NewAnnotatedTypeBuilder<X> annotatedTypeBuilder = NewAnnotatedTypeBuilder.newInstance(pat.getAnnotatedType()).readAnnotationsFromUnderlying();
// remove class-level @Named annotation
- rtc.redefine(Named.class, new AnnotationRedefinition<Named>()
+ annotatedTypeBuilder.removeFromClass(Named.class);
+ // remove bean constructors annotated @Inject
+ for (AnnotatedConstructor<X> constructor2 : at.getConstructors())
{
-
- public Named redefine(Named annotation, Reannotated reannotated)
- {
- return null;
- }
- });
- // remove bean constructor annotated @Inject
- rtc.redefineConstructors(Inject.class, new AnnotationRedefinition<Inject>()
- {
-
- public Inject redefine(Inject annotation, Reannotated reannotated)
- {
- return null;
- }
- });
+ annotatedTypeBuilder.removeFromConstructor(constructor2.getJavaMember(), Inject.class);
+ }
// make the constructor annotated @Constructs the bean constructor
- rtc.getConstructor(constructor.getJavaMember()).define(new AnnotationLiteral<Inject>()
- {
- });
+ annotatedTypeBuilder.addToConstructor(constructor.getJavaMember(), InjectLiteral.INSTANCE);
// add all the annotations of this constructor to the class
for (Annotation ann : constructor.getAnnotations())
{
- rtc.define(ann);
+ annotatedTypeBuilder.addToClass(ann);
}
-
- additionalBeans.add(new BeanImpl<X>(bm.createInjectionTarget(rtc), rtc));
+ AnnotatedType<X> construtsAnnotatedType = builder.create();
+ additionalBeans.add(new CustomBeanBuilder<X>(construtsAnnotatedType, bm).build());
}
}
}
@@ -177,9 +187,9 @@
return packageName;
}
- private <X> String getName(Annotated annotated, String defaultName)
+ private <X> String getName(Named named, String defaultName)
{
- String beanName = annotated.getAnnotation(Named.class).value();
+ String beanName = named.value();
if (beanName.length() == 0)
{
beanName = defaultName.substring(0, 1).toLowerCase() + defaultName.substring(1);
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/Exact.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/Exact.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/Exact.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -26,20 +26,39 @@
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
+import javax.enterprise.util.AnnotationLiteral;
import javax.inject.Qualifier;
/**
- * An injection point qualifier that may be used to select
- * the exact bean to be injected, by specifying its implementation
- * class.
+ * An injection point qualifier that may be used to select the exact bean to be
+ * injected, by specifying its implementation class.
*
* @author Gavin King
- *
+ *
*/
@Retention(RUNTIME)
- at Target({METHOD, TYPE, FIELD, PARAMETER})
+ at Target( { METHOD, TYPE, FIELD, PARAMETER })
@Documented
@Qualifier
-public @interface Exact {
- Class<?> value() default void.class;
+public @interface Exact
+{
+ Class<?> value() default void.class;
+
+ static class ExactLiteral extends AnnotationLiteral<Exact> implements Exact
+ {
+
+ private static final long serialVersionUID = 4907169607105615674L;
+
+ final Class<?> clazz;
+
+ ExactLiteral(Class<?> clazz)
+ {
+ this.clazz = clazz;
+ }
+
+ public Class<?> value()
+ {
+ return clazz;
+ }
+ }
}
Deleted: extensions/trunk/src/main/java/org/jboss/weld/extensions/ExactLiteral.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/ExactLiteral.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/ExactLiteral.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -1,37 +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;
-
-import javax.enterprise.util.AnnotationLiteral;
-
-class ExactLiteral extends AnnotationLiteral<Exact> implements Exact
-{
-
- private static final long serialVersionUID = 4907169607105615674L;
-
- final Class<?> clazz;
-
- ExactLiteral(Class<?> clazz)
- {
- this.clazz = clazz;
- }
-
- public Class<?> value()
- {
- return clazz;
- }
-}
\ No newline at end of file
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanInjectionTargetWrapper.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanInjectionTargetWrapper.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanInjectionTargetWrapper.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -16,6 +16,8 @@
*/
package org.jboss.weld.extensions.bean.generic;
+import static org.jboss.weld.extensions.util.ReflectionUtils.getField;
+
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.Arrays;
@@ -23,12 +25,11 @@
import java.util.Set;
import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.InjectionPoint;
import javax.enterprise.inject.spi.InjectionTarget;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedField;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedType;
-
/**
* injection target wrapper that injects the configuration for generic beans
*
@@ -53,9 +54,9 @@
private final InjectionTarget<T> delegate;
private final Annotation annotation;
- private final ReannotatedType<T> annotatedType;
+ private final AnnotatedType<T> annotatedType;
- public GenericBeanInjectionTargetWrapper(ReannotatedType<T> annotatedType, InjectionTarget<T> delegate, Annotation annotation)
+ public GenericBeanInjectionTargetWrapper(AnnotatedType<T> annotatedType, InjectionTarget<T> delegate, Annotation annotation)
{
this.annotation = annotation;
this.delegate = delegate;
@@ -69,8 +70,8 @@
if (annotation.annotationType().isAssignableFrom(f.getType()))
{
- ReannotatedField<? super T> reannotatedField = annotatedType.getField(f);
- if (reannotatedField.isAnnotationPresent(InjectConfiguration.class))
+ AnnotatedField<? super T> annotatedField = getField(annotatedType, f);
+ if (annotatedField.isAnnotationPresent(InjectConfiguration.class))
{
try
{
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -41,14 +41,11 @@
import javax.enterprise.inject.spi.InjectionTarget;
import javax.enterprise.inject.spi.ProcessAnnotatedType;
import javax.enterprise.inject.spi.ProcessInjectionTarget;
-import javax.enterprise.util.AnnotationLiteral;
import javax.inject.Inject;
import org.jboss.weld.extensions.bean.CustomBeanBuilder;
import org.jboss.weld.extensions.util.AnnotationInstanceProvider;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedField;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedParameter;
-import org.jboss.weld.extensions.util.reannotated.ReannotatedType;
+import org.jboss.weld.extensions.util.annotated.NewAnnotatedTypeBuilder;
public class GenericExtension implements Extension
{
@@ -92,7 +89,7 @@
event.veto();
}
- //make note of any producer fields that produce generic beans
+ // make note of any producer fields that produce generic beans
for (Object f : type.getFields())
{
AnnotatedField<?> field = (AnnotatedField<?>) f;
@@ -119,7 +116,8 @@
}
/**
- * wraps InjectionTarget to initialise producer fields that produce generic beans
+ * wraps InjectionTarget to initialise producer fields that produce generic
+ * beans
*/
public <T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event, BeanManager beanManager)
{
@@ -140,111 +138,115 @@
}
/**
- * Installs the generic beans.
+ * Installs the generic beans.
*/
- public void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager beanManager)
+ public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager beanManager)
{
- for (Entry<Class<?>, Set<AnnotatedType<?>>> i : genericBeans.entrySet())
+ for (Entry<Class<?>, Set<AnnotatedType<?>>> entry : genericBeans.entrySet())
{
- Set<Annotation> concretes = concreteGenerics.get(i.getKey());
+ Set<Annotation> concretes = concreteGenerics.get(entry.getKey());
if (concretes != null)
{
- for (AnnotatedType<?> at : i.getValue())
+ for (AnnotatedType<?> type : entry.getValue())
{
for (Annotation conc : concretes)
{
- final SyntheticQualifier newQualifier = getQualifierForGeneric(conc);
- ReannotatedType<?> rt = new ReannotatedType(at);
+ abd.addBean(redefineType(type, conc, beanManager));
+ }
+ }
+ }
+ }
+ }
- rt.define(newQualifier);
- for (AnnotatedField<?> f : rt.getFields())
- {
- ReannotatedField<?> field = (ReannotatedField<?>) f;
+ private <X> Bean<X> redefineType(AnnotatedType<X> at, Annotation conc, BeanManager beanManager)
+ {
+ SyntheticQualifier newQualifier = getQualifierForGeneric(conc);
- if (field.isAnnotationPresent(Inject.class))
- {
- //if this is a configuration injection point
- if (conc.annotationType().isAssignableFrom(field.getJavaMember().getType()))
- {
- field.undefine(Inject.class);
- field.define(new AnnotationLiteral<InjectConfiguration>()
- {
- });
- }
- 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(field.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(field.getJavaMember().getType(), qls);
- if (beans.isEmpty())
- {
- field.define(newQualifier);
- }
- }
- }
- else if (field.isAnnotationPresent(Produces.class))
- {
- //TODO: register a producer with the appropriate qualifier
- }
- }
- for (AnnotatedMethod<?> m : rt.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())
- {
- ReannotatedParameter<?> param = (ReannotatedParameter<?>) pm;
+ NewAnnotatedTypeBuilder<X> builder = NewAnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlying();
+ 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()];
- Class<?> paramType = m.getJavaMember().getParameterTypes()[param.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);
+ }
+ }
+ }
+ }
- //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(param.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
- if (beans.isEmpty())
- {
- param.define(newQualifier);
- }
- }
- }
- }
-
- for (AnnotatedConstructor<?> m : rt.getConstructors())
- {
- if (m.isAnnotationPresent(Inject.class))
- {
- for (AnnotatedParameter<?> pm : m.getParameters())
- {
- ReannotatedParameter<?> param = (ReannotatedParameter<?>) pm;
-
- Class paramType = m.getJavaMember().getParameterTypes()[param.getPosition()];
- Annotation[] qls = getQualifiers(param.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
- if (beans.isEmpty())
- {
- param.define(newQualifier);
- }
- }
- }
- }
- InjectionTarget<?> it = beanManager.createInjectionTarget(rt);
-
- it = new GenericBeanInjectionTargetWrapper(rt, it, conc);
- CustomBeanBuilder<?> builder = new CustomBeanBuilder(rt,beanManager,it);
- event.addBean(builder.build());
-
+ 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);
+ CustomBeanBuilder<X> beanBuilder = new CustomBeanBuilder<X>(newAnnotatedType, beanManager, it);
+ return beanBuilder.build();
}
public SyntheticQualifier getQualifierForGeneric(Annotation a)
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/InjectConfiguration.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/InjectConfiguration.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/bean/generic/InjectConfiguration.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -19,6 +19,8 @@
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
+import javax.enterprise.util.AnnotationLiteral;
+
/**
* synthetic qualifier that is added to Generic beans to signify configuration annotation injection points
*
@@ -28,4 +30,14 @@
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectConfiguration
{
+
+ public static class InjectConfigurationLiteral extends AnnotationLiteral<InjectConfiguration> implements InjectConfiguration
+ {
+
+ private static final long serialVersionUID = 5365615929893138969L;
+
+ }
+
+ public static final InjectConfiguration INSTANCE = new InjectConfigurationLiteral();
+
}
Deleted: extensions/trunk/src/main/java/org/jboss/weld/extensions/util/BeanImpl.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/util/BeanImpl.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/util/BeanImpl.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -1,152 +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.util;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.util.Collections;
-import java.util.Set;
-
-import javax.enterprise.context.Dependent;
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.Alternative;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.InjectionPoint;
-import javax.enterprise.inject.spi.InjectionTarget;
-import javax.inject.Named;
-import javax.inject.Qualifier;
-import javax.inject.Scope;
-
-import org.jboss.weld.extensions.util.reannotated.ReannotatedType;
-
-/**
- * This implementation of Bean is immutable and threadsafe.
- *
- * @author Gavin King
- * @author Pete Muir
- *
- * @param <T>
- */
-public class BeanImpl<T> implements Bean<T>
-{
-
- private final InjectionTarget<T> injectionTarget;
- private final Set<Type> types;
- private final String name;
- private final Set<Annotation> qualifiers;
- private final Class<? extends Annotation> scope;
- private final boolean alternative;
- private final Class<?> beanClass;
-
- public BeanImpl(InjectionTarget<T> it, ReannotatedType<T> rtc)
- {
- // create the Bean
- this.injectionTarget = it;
- // TODO: this stuff does not handle stereotypes
- Set<? extends Annotation> scopes = rtc.getAnnotationsWithMetatype(Scope.class);
- this.scope = scopes.isEmpty() ? Dependent.class : scopes.iterator().next().annotationType();
- if (rtc.isAnnotationPresent(Named.class))
- {
- this.name = rtc.getAnnotation(Named.class).value();
- // no name defaulting for constructors
- if (this.name.length() == 0)
- {
- throw new RuntimeException();
- }
- }
- else
- {
- this.name = null;
- }
- alternative = rtc.isAnnotationPresent(Alternative.class);
- qualifiers = rtc.getAnnotationsWithMetatype(Qualifier.class);
- types = rtc.getTypeClosure();
- beanClass = rtc.getJavaClass();
- }
-
- public BeanImpl(InjectionTarget<T> injectionTarget, Set<Type> types, Set<Annotation> qualifiers, Class<? extends Annotation> scope, String name, boolean alternative, Class<?> beanClass)
- {
- this.injectionTarget = injectionTarget;
- this.types = types;
- this.qualifiers = qualifiers;
- this.scope = scope;
- this.name = name;
- this.alternative = alternative;
- this.beanClass = beanClass;
- // TODO: stereotypes!!!
- }
-
- public Class<?> getBeanClass()
- {
- return beanClass;
- }
-
- public Set<InjectionPoint> getInjectionPoints()
- {
- return injectionTarget.getInjectionPoints();
- }
-
- public String getName()
- {
- return name;
- }
-
- public Set<Annotation> getQualifiers()
- {
- return Collections.unmodifiableSet(qualifiers);
- }
-
- public Class<? extends Annotation> getScope()
- {
- return scope;
- }
-
- public Set<Class<? extends Annotation>> getStereotypes()
- {
- return Collections.emptySet(); // TODO
- }
-
- public Set<Type> getTypes()
- {
- return Collections.unmodifiableSet(types);
- }
-
- public boolean isAlternative()
- {
- return alternative;
- }
-
- public boolean isNullable()
- {
- return false;
- }
-
- public T create(CreationalContext<T> ctx)
- {
- T instance = injectionTarget.produce(ctx);
- injectionTarget.inject(instance, ctx);
- injectionTarget.postConstruct(instance);
- return instance;
- }
-
- public void destroy(T instance, CreationalContext<T> creationalContext)
- {
- injectionTarget.preDestroy(instance);
- creationalContext.release();
- }
-
-}
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/util/ReflectionUtils.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/util/ReflectionUtils.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/util/ReflectionUtils.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -16,12 +16,17 @@
*/
package org.jboss.weld.extensions.util;
+import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
+import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedType;
+
/**
* class that provides a way of retrieving all methods and fields from a class
*
@@ -63,7 +68,33 @@
}
return null;
}
+
+ public static <X> AnnotatedField<? super X> getField(AnnotatedType<X> annotatedType, Field field)
+ {
+ for (AnnotatedField<? super X> annotatedField : annotatedType.getFields())
+ {
+ if (annotatedField.getDeclaringType().getJavaClass().equals(field.getDeclaringClass()) && annotatedField.getJavaMember().getName().equals(field.getName()))
+ {
+ return annotatedField;
+ }
+ }
+ return null;
+ }
+
+ public static Set<Annotation> getAnnotationsWithMetatype(Set<Annotation> annotations, Class<? extends Annotation> metaAnnotationType)
+ {
+ Set<Annotation> set = new HashSet<Annotation>();
+ for (Annotation annotation : annotations)
+ {
+ if (annotation.annotationType().isAnnotationPresent(metaAnnotationType))
+ {
+ set.add(annotation);
+ }
+ }
+ return set;
+ }
+
public static boolean methodExists(Class<?> parent, String name)
{
Class<?> p = parent;
@@ -134,7 +165,7 @@
public static Set<Constructor<?>> getConstructors(Class<?> clazz)
{
- HashSet<Constructor<?>> ret = new HashSet();
+ HashSet<Constructor<?>> ret = new HashSet<Constructor<?>>();
Class<?> p = clazz;
while (p != null && p != Object.class)
{
@@ -146,4 +177,25 @@
}
return ret;
}
+
+ public static Class<?> getMemberType(Member member)
+ {
+ if (member instanceof Field)
+ {
+ return ((Field) member).getType();
+ }
+ else if (member instanceof Method)
+ {
+ return ((Method) member).getReturnType();
+ }
+ else if (member instanceof Constructor<?>)
+ {
+ return ((Constructor<?>) member).getDeclaringClass();
+ }
+ else
+ {
+ throw new UnsupportedOperationException("Cannot operate on a member of type " + member.getClass());
+ }
+ }
+
}
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationBuilder.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationBuilder.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationBuilder.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -28,7 +28,7 @@
* @author Stuart Douglas
*
*/
-class AnnotationBuilder
+public class AnnotationBuilder
{
private HashMap<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>();
private Set<Annotation> annotationSet = new HashSet<Annotation>();
@@ -90,5 +90,16 @@
{
return (T) annotationMap.get(anType);
}
+
+ public boolean isAnnotationPresent(Class<?> annotationType)
+ {
+ return annotationMap.containsKey(annotationType);
+ }
+
+ @Override
+ public String toString()
+ {
+ return annotationSet.toString();
+ }
}
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationRedefiner.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationRedefiner.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/AnnotationRedefiner.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -18,7 +18,7 @@
import java.lang.annotation.Annotation;
-public interface AnnotationRedefiner<X extends Annotation>
+public interface AnnotationRedefiner<T extends Annotation, A>
{
- public X redefine(X annotation, AnnotationBuilder annotations);
+ public T redefine(T annotation, A annotated, AnnotationBuilder annotations);
}
Modified: extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/NewAnnotatedTypeBuilder.java
===================================================================
--- extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/NewAnnotatedTypeBuilder.java 2010-04-29 19:00:25 UTC (rev 6195)
+++ extensions/trunk/src/main/java/org/jboss/weld/extensions/util/annotated/NewAnnotatedTypeBuilder.java 2010-04-29 19:24:23 UTC (rev 6196)
@@ -38,7 +38,7 @@
* Class for constructing a new AnnotatedType. A new instance of builder must be
* used for each annotated type.
*
- * In can either be created with no annotations, or the annotations can be read
+ * In can either be created with no annotations, or the annotations can be read
* from the underlying class or an AnnotatedType
*
* @author Stuart Douglas
@@ -59,136 +59,89 @@
private Map<Method, Map<Integer, Type>> methodParameterTypes = new HashMap<Method, Map<Integer, Type>>();
private Map<Constructor<?>, Map<Integer, Type>> constructorParameterTypes = new HashMap<Constructor<?>, Map<Integer, Type>>();
- public NewAnnotatedTypeBuilder(Class<X> underlying)
+ public static <X> NewAnnotatedTypeBuilder<X> newInstance(Class<X> underlying)
{
- this(underlying, false);
+ return new NewAnnotatedTypeBuilder<X>(underlying);
}
- public NewAnnotatedTypeBuilder(Class<X> underlying, boolean readAnnotations)
+ public static <X> NewAnnotatedTypeBuilder<X> newInstance(AnnotatedType<X> underlying)
{
+ return new NewAnnotatedTypeBuilder<X>(underlying);
+ }
+
+ protected NewAnnotatedTypeBuilder(Class<X> underlying)
+ {
this.underlying = underlying;
- if (readAnnotations)
- {
- for (Annotation a : underlying.getAnnotations())
- {
- typeAnnotations.add(a);
- }
+ }
- for (Field f : ReflectionUtils.getFields(underlying))
- {
- AnnotationBuilder ab = new AnnotationBuilder();
- fields.put(f, ab);
- for (Annotation a : f.getAnnotations())
- {
- ab.add(a);
- }
- }
+ protected NewAnnotatedTypeBuilder(AnnotatedType<X> underlying)
+ {
+ this.underlying = underlying.getJavaClass();
- for (Method m : ReflectionUtils.getMethods(underlying))
- {
- AnnotationBuilder ab = new AnnotationBuilder();
- methods.put(m, ab);
- for (Annotation a : m.getAnnotations())
- {
- ab.add(a);
- }
- Map<Integer, AnnotationBuilder> mparams = new HashMap<Integer, AnnotationBuilder>();
- methodParameters.put(m, mparams);
- for (int i = 0; i < m.getParameterTypes().length; ++i)
- {
- AnnotationBuilder mab = new AnnotationBuilder();
- mparams.put(i, mab);
- for (Annotation a : m.getParameterAnnotations()[i])
- {
- mab.add(a);
- }
- }
- }
-
- for (Constructor m : underlying.getConstructors())
- {
- AnnotationBuilder ab = new AnnotationBuilder();
- constructors.put(m, ab);
- for (Annotation a : m.getAnnotations())
- {
- ab.add(a);
- }
- Map<Integer, AnnotationBuilder> mparams = new HashMap<Integer, AnnotationBuilder>();
- constructorParameters.put(m, mparams);
- for (int i = 0; i < m.getParameterTypes().length; ++i)
- {
- AnnotationBuilder mab = new AnnotationBuilder();
- mparams.put(i, mab);
- for (Annotation a : m.getParameterAnnotations()[i])
- {
- mab.add(a);
- }
- }
- }
-
- }
}
- public NewAnnotatedTypeBuilder(AnnotatedType<X> type)
+ public NewAnnotatedTypeBuilder<X> readAnnotationsFromUnderlying()
{
- this.underlying = type.getJavaClass();
- for (Annotation a : type.getAnnotations())
+ for (Annotation a : underlying.getAnnotations())
{
typeAnnotations.add(a);
}
- for (AnnotatedField<? super X> f : type.getFields())
+ for (Field f : ReflectionUtils.getFields(underlying))
{
AnnotationBuilder ab = new AnnotationBuilder();
- fields.put(f.getJavaMember(), ab);
+ fields.put(f, ab);
+ f.setAccessible(true);
for (Annotation a : f.getAnnotations())
{
ab.add(a);
}
}
- for (AnnotatedMethod<? super X> m : type.getMethods())
+ for (Method m : ReflectionUtils.getMethods(underlying))
{
AnnotationBuilder ab = new AnnotationBuilder();
- methods.put(m.getJavaMember(), ab);
+ m.setAccessible(true);
+ methods.put(m, ab);
for (Annotation a : m.getAnnotations())
{
ab.add(a);
}
Map<Integer, AnnotationBuilder> mparams = new HashMap<Integer, AnnotationBuilder>();
- methodParameters.put(m.getJavaMember(), mparams);
- for (AnnotatedParameter<? super X> p : m.getParameters())
+ methodParameters.put(m, mparams);
+ for (int i = 0; i < m.getParameterTypes().length; ++i)
{
AnnotationBuilder mab = new AnnotationBuilder();
- mparams.put(p.getPosition(), mab);
- for (Annotation a : p.getAnnotations())
+ mparams.put(i, mab);
+ for (Annotation a : m.getParameterAnnotations()[i])
{
mab.add(a);
}
}
}
- for (AnnotatedConstructor<X> m : type.getConstructors())
+ for (Constructor m : underlying.getDeclaredConstructors())
{
AnnotationBuilder ab = new AnnotationBuilder();
- constructors.put(m.getJavaMember(), ab);
+ m.setAccessible(true);
+ constructors.put(m, ab);
for (Annotation a : m.getAnnotations())
{
ab.add(a);
}
Map<Integer, AnnotationBuilder> mparams = new HashMap<Integer, AnnotationBuilder>();
- constructorParameters.put(m.getJavaMember(), mparams);
- for (AnnotatedParameter<? super X> p : m.getParameters())
+ constructorParameters.put(m, mparams);
+ for (int i = 0; i < m.getParameterTypes().length; ++i)
{
AnnotationBuilder mab = new AnnotationBuilder();
- mparams.put(p.getPosition(), mab);
- for (Annotation a : p.getAnnotations())
+ mparams.put(i, mab);
+ for (Annotation a : m.getParameterAnnotations()[i])
{
mab.add(a);
}
}
}
-
+ return this;
}
public NewAnnotatedTypeBuilder<X> addToClass(Annotation a)
@@ -375,47 +328,57 @@
return this;
}
- public <T extends Annotation> NewAnnotatedTypeBuilder<X> redefine(Class<T> annotationType, AnnotationRedefiner<T> redefinition)
+ public <T extends Annotation> NewAnnotatedTypeBuilder<X> redefineMemberParameters(Class<T> annotationType, ParameterAnnotationRedefiner<T> redefinition)
{
- redefineAnnotationBuilder(annotationType, redefinition, typeAnnotations);
- for (Entry<Field, AnnotationBuilder> e : fields.entrySet())
- {
- redefineAnnotationBuilder(annotationType, redefinition, e.getValue());
- }
for (Entry<Method, AnnotationBuilder> e : methods.entrySet())
{
- redefineAnnotationBuilder(annotationType, redefinition, e.getValue());
Map<Integer, AnnotationBuilder> params = methodParameters.get(e.getKey());
if (params != null)
{
for (Entry<Integer, AnnotationBuilder> p : params.entrySet())
{
- redefineAnnotationBuilder(annotationType, redefinition, p.getValue());
+ redefineAnnotationBuilder(annotationType, redefinition, new Parameter(e.getKey(), p.getKey()), p.getValue());
}
}
}
for (Entry<Constructor<X>, AnnotationBuilder> e : constructors.entrySet())
{
- redefineAnnotationBuilder(annotationType, redefinition, e.getValue());
Map<Integer, AnnotationBuilder> params = constructorParameters.get(e.getKey());
if (params != null)
{
for (Entry<Integer, AnnotationBuilder> p : params.entrySet())
{
- redefineAnnotationBuilder(annotationType, redefinition, p.getValue());
+ redefineAnnotationBuilder(annotationType, redefinition, new Parameter(e.getKey(), p.getKey()), p.getValue());
}
}
}
return this;
}
+
+ public <T extends Annotation> NewAnnotatedTypeBuilder<X> redefineMembers(Class<T> annotationType, MemberAnnotationRedefiner<T> redefinition)
+ {
+ for (Entry<Field, AnnotationBuilder> e : fields.entrySet())
+ {
+ redefineAnnotationBuilder(annotationType, redefinition, e.getKey(), e.getValue());
+ }
+ for (Entry<Method, AnnotationBuilder> e : methods.entrySet())
+ {
+ redefineAnnotationBuilder(annotationType, redefinition, e.getKey(), e.getValue());
+ }
+ for (Entry<Constructor<X>, AnnotationBuilder> e : constructors.entrySet())
+ {
+ redefineAnnotationBuilder(annotationType, redefinition, e.getKey(), e.getValue());
+ }
+ return this;
+ }
- protected <T extends Annotation> void redefineAnnotationBuilder(Class<T> annotationType, AnnotationRedefiner<T> redefinition, AnnotationBuilder builder)
+ protected <T extends Annotation, A> void redefineAnnotationBuilder(Class<T> annotationType, AnnotationRedefiner<T, A> redefinition, A annotated, AnnotationBuilder builder)
{
T an = builder.getAnnotation(annotationType);
- if(an != null)
+ if (an != null)
{
builder.remove(annotationType);
- T newAn = redefinition.redefine(an, builder);
+ T newAn = redefinition.redefine(an, annotated, builder);
if (newAn != null)
{
builder.add(newAn);
@@ -424,8 +387,10 @@
}
/**
- * merges the annotations from an existing AnnoatedType. If they both have the same annotation
- * on an element overwriteExisting determines which one to keep
+ * merges the annotations from an existing AnnotatedType. If they both have
+ * the same annotation on an element overwriteExisting determines which one
+ * to keep
+ *
* @param type
* @param overwriteExisting
* @return
@@ -461,7 +426,7 @@
methodParameters.put(method.getJavaMember(), params);
}
AnnotationBuilder builder = params.get(p.getPosition());
- if(builder == null)
+ if (builder == null)
{
builder = new AnnotationBuilder();
params.put(p.getPosition(), builder);
@@ -519,17 +484,17 @@
public AnnotatedType<X> create()
{
- Map<Constructor<X>, Map<Integer, AnnotationStore>> constructorParameterAnnnotations = new HashMap<Constructor<X>, Map<Integer,AnnotationStore>>();
+ Map<Constructor<X>, Map<Integer, AnnotationStore>> constructorParameterAnnnotations = new HashMap<Constructor<X>, Map<Integer, AnnotationStore>>();
Map<Constructor<X>, AnnotationStore> constructorAnnotations = new HashMap<Constructor<X>, AnnotationStore>();
- Map<Method, Map<Integer, AnnotationStore>> methodParameterAnnnotations = new HashMap<Method, Map<Integer,AnnotationStore>>();
+ Map<Method, Map<Integer, AnnotationStore>> methodParameterAnnnotations = new HashMap<Method, Map<Integer, AnnotationStore>>();
Map<Method, AnnotationStore> methodAnnotations = new HashMap<Method, AnnotationStore>();
Map<Field, AnnotationStore> fieldAnnotations = new HashMap<Field, AnnotationStore>();
-
+
for (Entry<Field, AnnotationBuilder> e : fields.entrySet())
{
fieldAnnotations.put(e.getKey(), e.getValue().create());
}
-
+
for (Entry<Method, AnnotationBuilder> e : methods.entrySet())
{
methodAnnotations.put(e.getKey(), e.getValue().create());
@@ -543,7 +508,7 @@
parameterAnnotations.put(pe.getKey(), pe.getValue().create());
}
}
-
+
for (Entry<Constructor<X>, AnnotationBuilder> e : constructors.entrySet())
{
constructorAnnotations.put(e.getKey(), e.getValue().create());
More information about the weld-commits
mailing list