[webbeans-commits] Webbeans SVN: r284 - in ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans: bean and 6 other directories.
webbeans-commits at lists.jboss.org
webbeans-commits at lists.jboss.org
Sun Nov 9 02:52:06 EST 2008
Author: pete.muir at jboss.org
Date: 2008-11-09 02:52:05 -0500 (Sun, 09 Nov 2008)
New Revision: 284
Added:
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractClassBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EventBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/XmlSimpleBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableMethod.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableParameter.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Injectable.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableField.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableMethod.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableParameter.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableWrapper.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Invokable.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ResolverInjectable.java
Removed:
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/BeanConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/EnterpriseConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableMethod.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableParameter.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Injectable.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableField.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableMethod.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableParameter.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableWrapper.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Invokable.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/JMSConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/MethodConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ResolverInjectable.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/SimpleConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/MergedStereotypesModel.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/bean/
Modified:
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ManagerImpl.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ModelManager.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ResolutionManager.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EnterpriseBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/ProducerMethodBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/SimpleBean.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/exceptions/TypesafeResolutionLocation.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedField.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedMethod.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedParameter.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedItem.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedMember.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedType.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedConstructor.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedField.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedItem.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedMethod.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedParameter.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/AnnotationModel.java
ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/BindingTypeModel.java
Log:
Refactor to remove *Model and *Constructor and xmlAnnotatedItem, part 1
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ManagerImpl.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ManagerImpl.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ManagerImpl.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -37,11 +37,8 @@
import org.jboss.webbeans.event.EventBus;
import org.jboss.webbeans.exceptions.NameResolutionLocation;
import org.jboss.webbeans.exceptions.TypesafeResolutionLocation;
-import org.jboss.webbeans.injectable.Injectable;
-import org.jboss.webbeans.injectable.ResolverInjectable;
-import org.jboss.webbeans.introspector.AnnotatedClass;
-import org.jboss.webbeans.introspector.impl.SimpleAnnotatedClass;
-import org.jboss.webbeans.model.bean.SimpleBeanModel;
+import org.jboss.webbeans.introspector.impl.Injectable;
+import org.jboss.webbeans.introspector.impl.ResolverInjectable;
import org.jboss.webbeans.util.ClientProxy;
import org.jboss.webbeans.util.ProxyPool;
import org.jboss.webbeans.util.Reflections;
@@ -99,8 +96,7 @@
this.proxyPool = new ProxyPool(this);
this.decorators = new HashSet<Decorator>();
this.interceptors = new HashSet<Interceptor>();
- SimpleAnnotatedClass<DefaultEnterpriseBeanLookup> sc = new SimpleAnnotatedClass<DefaultEnterpriseBeanLookup>(DefaultEnterpriseBeanLookup.class, new HashMap<Class<? extends Annotation>, Annotation>());
- addBean( new SimpleBean<DefaultEnterpriseBeanLookup>( new SimpleBeanModel<DefaultEnterpriseBeanLookup>(sc, null, this), this ) );
+ addBean( new SimpleBean<DefaultEnterpriseBeanLookup>( DefaultEnterpriseBeanLookup.class, this ) );
}
protected void initEnabledDeploymentTypes(List<Class<? extends Annotation>> enabledDeploymentTypes)
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ModelManager.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ModelManager.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ModelManager.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -8,7 +8,6 @@
import org.jboss.webbeans.model.BindingTypeModel;
import org.jboss.webbeans.model.ScopeModel;
import org.jboss.webbeans.model.StereotypeModel;
-import org.jboss.webbeans.model.bean.BeanModel;
import com.google.common.collect.ForwardingMap;
@@ -85,8 +84,6 @@
private Map<Class<? extends Annotation>, StereotypeModel<?>> stereotypes = new HashMap<Class<? extends Annotation>, StereotypeModel<?>>();
- private Map<Class<?>, BeanModel<?, ?>> beanModels = new HashMap<Class<?>, BeanModel<?,?>>();
-
private ScopeModelMap scopes = new ScopeModelMap();
private BindingTypeModelMap bindingTypes = new BindingTypeModelMap();
@@ -102,16 +99,6 @@
return stereotypes.get(annotationType);
}
- public void addBeanModel(BeanModel<?, ?> beanModel)
- {
- beanModels.put(beanModel.getType(), beanModel);
- }
-
- public BeanModel<?, ?> getBeanModel(Class<?> clazz)
- {
- return beanModels.get(clazz);
- }
-
public <T extends Annotation> ScopeModel<T> getScopeModel(Class<T> scopeType)
{
return scopes.putIfAbsent(scopeType);
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ResolutionManager.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ResolutionManager.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ResolutionManager.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -13,7 +13,7 @@
import javax.webbeans.NullableDependencyException;
import javax.webbeans.manager.Bean;
-import org.jboss.webbeans.injectable.Injectable;
+import org.jboss.webbeans.introspector.impl.Injectable;
import org.jboss.webbeans.util.ListComparator;
import com.google.common.collect.ForwardingMap;
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,98 +1,463 @@
package org.jboss.webbeans.bean;
import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
import java.util.Set;
+import javax.webbeans.BindingType;
+import javax.webbeans.DefinitionException;
+import javax.webbeans.Dependent;
+import javax.webbeans.DeploymentType;
+import javax.webbeans.Named;
+import javax.webbeans.Production;
+import javax.webbeans.ScopeType;
+import javax.webbeans.Specializes;
+import javax.webbeans.Standard;
+import javax.webbeans.Stereotype;
import javax.webbeans.manager.Bean;
import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.model.MergedStereotypesModel;
-import org.jboss.webbeans.model.bean.BeanModel;
+import org.jboss.webbeans.bindings.CurrentAnnotationLiteral;
+import org.jboss.webbeans.ejb.DefaultEnterpriseBeanLookup;
+import org.jboss.webbeans.introspector.AnnotatedItem;
+import org.jboss.webbeans.introspector.impl.Injectable;
+import org.jboss.webbeans.introspector.impl.InjectableMethod;
+import org.jboss.webbeans.introspector.impl.InjectableParameter;
+import org.jboss.webbeans.log.LogProvider;
+import org.jboss.webbeans.log.Logging;
+import org.jboss.webbeans.util.Reflections;
-public abstract class AbstractBean<T> extends Bean<T>
+public abstract class AbstractBean<T, E> extends Bean<T>
{
+
+ private static Set<Class<?>> STANDARD_WEB_BEAN_CLASSES = new HashSet<Class<?>>(Arrays.asList(DefaultEnterpriseBeanLookup.class));
- public static final String LOGGER_NAME = "bean";
+ public static Class<? extends Annotation> getDeploymentType(List<Class<? extends Annotation>> enabledDeploymentTypes, Map<Class<? extends Annotation>, Annotation> possibleDeploymentTypes)
+ {
+ for (int i = (enabledDeploymentTypes.size() - 1); i > 0; i--)
+ {
+ if (possibleDeploymentTypes.containsKey((enabledDeploymentTypes.get(i))))
+ {
+ return enabledDeploymentTypes.get(i);
+ }
+ }
+ return null;
+ }
- protected ManagerImpl manager;
-
+ // Logger
+ private LogProvider log = Logging.getLogProvider(AbstractBean.class);
+
+ // Reference to WBRI manager
+ private ManagerImpl manager;
+ private Set<Annotation> bindingTypes;
+ protected String name;
+ protected Class<? extends Annotation> scopeType;
+ private MergedStereotypes<T, E> mergedStereotypes;
+ protected Class<? extends Annotation> deploymentType;
+ protected Class<T> type;
+ protected InjectableMethod<?> removeMethod;
+ protected Set<Class<?>> apiTypes;
+ protected Set<Injectable<?, ?>> injectionPoints;
+
+ private boolean primitive;
+
+ // Cached values
+ private Type declaredBeanType;
+
public AbstractBean(ManagerImpl manager)
{
super(manager);
this.manager = manager;
}
- protected void bindInterceptors()
+ protected void init()
{
- // TODO
+ mergedStereotypes = new MergedStereotypes<T, E>(getAnnotatedItem().getAnnotations(Stereotype.class), manager);
+ initType();
+ initPrimitive();
+ log.debug("Building Web Bean bean metadata for " + getType());
+ initBindingTypes();
+ initName();
+ initDeploymentType();
+ checkDeploymentType();
+ initScopeType();
+ initApiTypes();
}
- protected void bindDecorators()
+ protected void initApiTypes()
{
- // TODO
+ apiTypes = getTypeHierachy(getType());
}
+
+ protected void initBindingTypes()
+ {
+
+ this.bindingTypes = new HashSet<Annotation>();
+ if (isDefinedInXml())
+ {
+ boolean xmlSpecialization = false;
+ Set<Annotation> xmlBindingTypes = null;
+ this.bindingTypes.addAll(xmlBindingTypes);
+ if (xmlSpecialization)
+ {
+ this.bindingTypes.addAll(bindingTypes);
+ log.trace("Using binding types " + this.bindingTypes + " specified in XML and specialized type");
+ }
+ else
+ {
+ log.trace("Using binding types " + this.bindingTypes + " specified in XML");
+ }
+ return;
+ }
+ else if (!mergedStereotypes.isDeclaredInXml())
+ {
+ boolean specialization = getAnnotatedItem().isAnnotationPresent(Specializes.class);
+ this.bindingTypes.addAll(getAnnotatedItem().getAnnotations(BindingType.class));
+ if (specialization)
+ {
+ this.bindingTypes.addAll(getSpecializedType().getBindingTypes());
+ log.trace("Using binding types " + bindingTypes + " specified by annotations and specialized supertype");
+ }
+ else if (bindingTypes.size() == 0)
+ {
+ log.trace("Adding default @Current binding type");
+ this.bindingTypes.add(new CurrentAnnotationLiteral());
+ }
+ else
+ {
+ log.trace("Using binding types " + bindingTypes + " specified by annotations");
+ }
+ return;
+ }
+ }
+ protected void initDeploymentType()
+ {
+ if (isDefinedInXml())
+ {
+ Set<Annotation> xmlDeploymentTypes = null;
+ if (xmlDeploymentTypes.size() > 1)
+ {
+ throw new RuntimeException("At most one deployment type may be specified (" + xmlDeploymentTypes + " are specified)");
+ }
+
+ if (xmlDeploymentTypes.size() == 1)
+ {
+ this.deploymentType = xmlDeploymentTypes.iterator().next().annotationType();
+ log.trace("Deployment type " + deploymentType + " specified in XML");
+ return;
+ }
+ }
+ else
+ {
+ Set<Annotation> deploymentTypes = getAnnotatedItem().getAnnotations(DeploymentType.class);
+
+ if (deploymentTypes.size() > 1)
+ {
+ throw new DefinitionException("At most one deployment type may be specified (" + deploymentTypes + " are specified) on " + getAnnotatedItem().toString());
+ }
+ if (deploymentTypes.size() == 1)
+ {
+ this.deploymentType = deploymentTypes.iterator().next().annotationType();
+ log.trace("Deployment type " + deploymentType + " specified by annotation");
+ return;
+ }
+
+ if (getMergedStereotypes().getPossibleDeploymentTypes().size() > 0)
+ {
+ this.deploymentType = getDeploymentType(manager.getEnabledDeploymentTypes(), getMergedStereotypes().getPossibleDeploymentTypes());
+ log.trace("Deployment type " + deploymentType + " specified by stereotype");
+ return;
+ }
+ }
+
+ this.deploymentType = Production.class;
+ log.trace("Using default @Production deployment type");
+ return;
+ }
+
+ protected void initInjectionPoints()
+ {
+ injectionPoints = new HashSet<Injectable<?,?>>();
+ if (removeMethod != null)
+ {
+ for (InjectableParameter<?> injectable : removeMethod.getParameters())
+ {
+ injectionPoints.add(injectable);
+ }
+ }
+ }
+
+ protected void initName()
+ {
+ boolean beanNameDefaulted = false;
+ if (isDefinedInXml())
+ {
+ boolean xmlSpecialization = false;
+ if (xmlSpecialization)
+ {
+ throw new DefinitionException("Name specified for specialized bean (declared in XML)");
+ }
+ String xmlName = "";
+ if ("".equals(xmlName))
+ {
+ log.trace("Using default name (specified in XML)");
+ beanNameDefaulted = true;
+ }
+ else
+ {
+ log.trace("Using name " + xmlName + " specified in XML");
+ this.name = xmlName;
+ return;
+ }
+ }
+ else
+ {
+ boolean specialization = getAnnotatedItem().isAnnotationPresent(Specializes.class);
+ if (getAnnotatedItem().isAnnotationPresent(Named.class))
+ {
+ if (specialization)
+ {
+ throw new DefinitionException("Name specified for specialized bean");
+ }
+ String javaName = getAnnotatedItem().getAnnotation(Named.class).value();
+ if ("".equals(javaName))
+ {
+ log.trace("Using default name (specified by annotations)");
+ beanNameDefaulted = true;
+ }
+ else
+ {
+ log.trace("Using name " + javaName + " specified by annotations");
+ this.name = javaName;
+ return;
+ }
+ }
+ else if (specialization)
+ {
+ this.name = getSpecializedType().getName();
+ log.trace("Using supertype name");
+ return;
+ }
+ }
+
+ if (beanNameDefaulted || getMergedStereotypes().isBeanNameDefaulted())
+ {
+ this.name = getDefaultName();
+ return;
+ }
+ }
+
+ protected void initPrimitive()
+ {
+ this.primitive = Reflections.isPrimitive(getType());
+ }
+
+ /**
+ * Return the scope of the bean
+ */
+ protected void initScopeType()
+ {
+ if (isDefinedInXml())
+ {
+ Set<Class<? extends Annotation>> scopeTypes = null;
+ if (scopeTypes.size() > 1)
+ {
+ throw new DefinitionException("At most one scope may be specified in XML");
+ }
+
+ if (scopeTypes.size() == 1)
+ {
+ this.scopeType = scopeTypes.iterator().next();
+ log.trace("Scope " + scopeType + " specified in XML");
+ return;
+ }
+ }
+ else
+ {
+ if (getAnnotatedItem().getAnnotations(ScopeType.class).size() > 1)
+ {
+ throw new DefinitionException("At most one scope may be specified");
+ }
+
+ if (getAnnotatedItem().getAnnotations(ScopeType.class).size() == 1)
+ {
+ this.scopeType = getAnnotatedItem().getAnnotations(ScopeType.class).iterator().next().annotationType();
+ log.trace("Scope " + scopeType + " specified b annotation");
+ return;
+ }
+ }
+
+ if (getMergedStereotypes().getPossibleScopeTypes().size() == 1)
+ {
+ this.scopeType = getMergedStereotypes().getPossibleScopeTypes().iterator().next().annotationType();
+ log.trace("Scope " + scopeType + " specified by stereotype");
+ return;
+ }
+ else if (getMergedStereotypes().getPossibleScopeTypes().size() > 1)
+ {
+ throw new RuntimeException("All stereotypes must specify the same scope OR a scope must be specified on the bean");
+ }
+ this.scopeType = Dependent.class;
+ log.trace("Using default @Dependent scope");
+ }
+
+ protected abstract void initType();
+
+ protected void checkDeploymentType()
+ {
+ if (deploymentType == null)
+ {
+ throw new RuntimeException("type: " + getType() + " must specify a deployment type");
+ }
+ else if (deploymentType.equals(Standard.class) && !STANDARD_WEB_BEAN_CLASSES.contains(getAnnotatedItem().getType()))
+ {
+ throw new DefinitionException(getAnnotatedItem() + " cannot have deployment type @Standard");
+ }
+ }
+
@Override
public void destroy(T instance)
{
// TODO Auto-generated method stub
-
}
+
+ protected void bindDecorators()
+ {
+ // TODO
+ }
+
+ protected void bindInterceptors()
+ {
+ // TODO
+ }
+
+ protected abstract AnnotatedItem<T, E> getAnnotatedItem();
- @Override
public Set<Annotation> getBindingTypes()
{
- return getModel().getBindingTypes();
+ return bindingTypes;
}
- @Override
+ protected Type getDeclaredBeanType()
+ {
+ if (declaredBeanType == null)
+ {
+ Type type = getClass();
+ if (type instanceof ParameterizedType)
+ {
+ ParameterizedType parameterizedType = (ParameterizedType) type;
+ if (parameterizedType.getActualTypeArguments().length == 1)
+ {
+ declaredBeanType = parameterizedType.getActualTypeArguments()[0];
+ }
+ }
+ }
+ return declaredBeanType;
+ }
+
+ protected abstract String getDefaultName();
+
public Class<? extends Annotation> getDeploymentType()
{
- return getModel().getDeploymentType();
+ return deploymentType;
}
-
+
+ public Set<Injectable<?, ?>> getInjectionPoints()
+ {
+ return injectionPoints;
+ }
+
@Override
+ protected ManagerImpl getManager()
+ {
+ return manager;
+ }
+
+ public MergedStereotypes<T, E> getMergedStereotypes()
+ {
+ return mergedStereotypes;
+ }
+
public String getName()
{
- return getModel().getName();
+ return name;
}
- @Override
+ public InjectableMethod<?> getRemoveMethod()
+ {
+ return removeMethod;
+ }
+
public Class<? extends Annotation> getScopeType()
{
- return getModel().getScopeType();
+ return scopeType;
}
+
+ protected AbstractBean<? extends T, E> getSpecializedType()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+
+ public Class<T> getType()
+ {
+ return type;
+ }
+
+ protected Set<Class<?>> getTypeHierachy(Class<?> clazz)
+ {
+ Set<Class<?>> classes = new HashSet<Class<?>>();
+ if (clazz != null)
+ {
+ classes.add(clazz);
+ classes.addAll(getTypeHierachy(clazz.getSuperclass()));
+ for (Class<?> c : clazz.getInterfaces())
+ {
+ classes.addAll(getTypeHierachy(c));
+ }
+ }
+ return classes;
+ }
+
@Override
public Set<Class<?>> getTypes()
{
- return getModel().getApiTypes();
+ return apiTypes;
}
-
- @Override
- public boolean isNullable()
+
+ public boolean isAssignableFrom(AnnotatedItem<?, ?> annotatedItem)
{
- return !getModel().isPrimitive();
+ return this.getAnnotatedItem().isAssignableFrom(annotatedItem);
}
- @Override
- public boolean isSerializable()
+ protected boolean isDefinedInXml()
{
- // TODO Auto-generated method stub
return false;
}
@Override
- public String toString()
+ public boolean isNullable()
{
- return getModel().toString();
+ return !isPrimitive();
}
- public abstract BeanModel<T, ?> getModel();
+ public boolean isPrimitive()
+ {
+ return primitive;
+ }
- public MergedStereotypesModel<T, ?> getMergedStereotypes()
+ @Override
+ public boolean isSerializable()
{
- return getModel().getMergedStereotypes();
+ // TODO Auto-generated method stub
+ return false;
}
}
Added: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractClassBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractClassBean.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractClassBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,193 @@
+package org.jboss.webbeans.bean;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.webbeans.BindingType;
+import javax.webbeans.DefinitionException;
+import javax.webbeans.Destructor;
+import javax.webbeans.Disposes;
+import javax.webbeans.Initializer;
+import javax.webbeans.Observes;
+import javax.webbeans.Produces;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.introspector.AnnotatedClass;
+import org.jboss.webbeans.introspector.AnnotatedField;
+import org.jboss.webbeans.introspector.AnnotatedMethod;
+import org.jboss.webbeans.introspector.impl.InjectableField;
+import org.jboss.webbeans.introspector.impl.InjectableMethod;
+import org.jboss.webbeans.introspector.impl.SimpleAnnotatedClass;
+import org.jboss.webbeans.log.LogProvider;
+import org.jboss.webbeans.log.Logging;
+import org.jboss.webbeans.util.Reflections;
+import org.jboss.webbeans.util.Strings;
+
+public abstract class AbstractClassBean<T> extends AbstractBean<T, Class<T>>
+{
+
+ private static final LogProvider log = Logging.getLogProvider(AbstractClassBean.class);
+
+ private AnnotatedClass<T> annotatedItem;
+ private Set<InjectableField<?>> injectableFields;
+ private Set<InjectableMethod<Object>> initializerMethods;
+ protected boolean annotationDefined;
+
+ /**
+ *
+ * @param annotatedItem Annotations read from java classes
+ * @param xmlAnnotatedItem Annotations read from XML
+ * @param manager
+ */
+ public AbstractClassBean(Class<T> type, ManagerImpl manager)
+ {
+ super(manager);
+ this.annotatedItem = new SimpleAnnotatedClass<T>(type);
+ }
+
+ @Override
+ protected void init()
+ {
+ super.init();
+ checkRequiredTypesImplemented();
+ checkScopeAllowed();
+ checkBeanImplementation();
+ // TODO Interceptors
+ initInitializerMethods();
+ }
+
+ protected void initType()
+ {
+ if (isDefinedInXml())
+ {
+ log.trace("Bean type specified in Java");
+ }
+ else
+ {
+ log.trace("Bean type specified in Java");
+ this.type = getAnnotatedItem().getType();
+ }
+ }
+
+ @Override
+ protected void initInjectionPoints()
+ {
+ super.initInjectionPoints();
+ injectableFields = new HashSet<InjectableField<?>>();
+ for (AnnotatedField<Object> annotatedField : annotatedItem.getMetaAnnotatedFields(BindingType.class))
+ {
+ if (annotatedField.isStatic())
+ {
+ throw new DefinitionException("Don't place binding annotations on static fields " + annotatedField);
+ }
+ if (annotatedField.isFinal())
+ {
+ throw new DefinitionException("Don't place binding annotations on final fields " + annotatedField);
+ }
+ InjectableField<?> injectableField = new InjectableField<Object>(annotatedField);
+ injectableFields.add(injectableField);
+ super.injectionPoints.add(injectableField);
+ }
+ }
+
+ protected void initInitializerMethods()
+ {
+ if (isDefinedInXml())
+ {
+
+ }
+ else
+ {
+ initializerMethods = new HashSet<InjectableMethod<Object>>();
+ for (AnnotatedMethod<Object> annotatedMethod : annotatedItem.getAnnotatedMethods(Initializer.class))
+ {
+ if (annotatedMethod.isStatic())
+ {
+ throw new DefinitionException("Initializer method " + annotatedMethod.toString() + " cannot be static");
+ }
+ else if (annotatedMethod.getAnnotation(Produces.class) != null)
+ {
+ throw new DefinitionException("Initializer method " + annotatedMethod.toString() + " cannot be annotated @Produces");
+ }
+ else if (annotatedMethod.getAnnotation(Destructor.class) != null)
+ {
+ throw new DefinitionException("Initializer method " + annotatedMethod.toString() + " cannot be annotated @Destructor");
+ }
+ else if (annotatedMethod.getAnnotatedParameters(Disposes.class).size() > 0)
+ {
+ throw new DefinitionException("Initializer method " + annotatedMethod.toString() + " cannot have parameters annotated @Disposes");
+ }
+ else if (annotatedMethod.getAnnotatedParameters(Observes.class).size() > 0)
+ {
+ throw new DefinitionException("Initializer method " + annotatedMethod.toString() + " cannot be annotated @Observes");
+ }
+ else
+ {
+ initializerMethods.add(new InjectableMethod<Object>(annotatedMethod));
+ }
+ }
+ }
+ }
+
+ protected void checkRequiredTypesImplemented()
+ {
+ for (Class<?> requiredType : getMergedStereotypes().getRequiredTypes())
+ {
+ log.trace("Checking if required type " + requiredType + " is implemented");
+ if (!requiredType.isAssignableFrom(type))
+ {
+ throw new DefinitionException("Required type " + requiredType + " isn't implemented on " + type);
+ }
+ }
+ }
+
+ /**
+ * Check that the scope type is allowed by the stereotypes on the bean and the bean type
+ * @param type
+ */
+ protected void checkScopeAllowed()
+ {
+ log.trace("Checking if " + getScopeType() + " is allowed for " + type);
+ if (getMergedStereotypes().getSupportedScopes().size() > 0)
+ {
+ if (!getMergedStereotypes().getSupportedScopes().contains(getScopeType()))
+ {
+ throw new DefinitionException("Scope " + getScopeType() + " is not an allowed by the stereotype for " + type);
+ }
+ }
+ }
+
+ protected void checkBeanImplementation()
+ {
+ if (Reflections.isAbstract(getType()))
+ {
+ throw new DefinitionException("Web Bean implementation class " + type + " cannot be declared abstract");
+ }
+ }
+
+ @Override
+ protected AnnotatedClass<T> getAnnotatedItem()
+ {
+ return annotatedItem;
+ }
+
+ @Override
+ protected String getDefaultName()
+ {
+ String name = Strings.decapitalize(getType().getSimpleName());
+ log.trace("Default name of " + type + " is " + name );
+ return name;
+ }
+
+ public Set<InjectableField<?>> getInjectableFields()
+ {
+ return injectableFields;
+ }
+
+ public Set<InjectableMethod<Object>> getInitializerMethods()
+ {
+ return initializerMethods;
+ }
+
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractClassBean.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EnterpriseBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EnterpriseBean.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EnterpriseBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,69 +1,304 @@
-package org.jboss.webbeans.bean;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.injectable.InjectableField;
-import org.jboss.webbeans.injectable.InjectableMethod;
-import org.jboss.webbeans.model.bean.EnterpriseBeanModel;
-
-public class EnterpriseBean<T> extends AbstractBean<T>
-{
- private EnterpriseBeanModel<T> model;
-
- public EnterpriseBean(EnterpriseBeanModel<T> model, ManagerImpl manager) {
- super(manager);
- this.model = model;
- }
-
- @Override
- public EnterpriseBeanModel<T> getModel()
- {
- return model;
- }
-
- @Override
- public T create()
- {
- T instance = model.getConstructor().invoke(manager);
- bindDecorators();
- bindInterceptors();
- injectEjbAndCommonFields();
- injectBoundFields(instance);
- callInitializers(instance);
- return instance;
- }
-
- @Override
- public void destroy(T instance)
- {
- // TODO Auto-generated method stub
- super.destroy(instance);
- }
-
- protected void callInitializers(T instance)
- {
- for (InjectableMethod<Object> initializer : model.getInitializerMethods())
- {
- initializer.invoke(manager, instance);
- }
- }
-
- protected void injectEjbAndCommonFields()
- {
- // TODO
- }
-
- protected void injectBoundFields(T instance)
- {
- for (InjectableField<?> injectableField : getModel().getInjectableFields())
- {
- injectableField.inject(instance, manager);
- }
- }
-
- public InjectableMethod<?> getRemoveMethod()
- {
- return model.getRemoveMethod();
-
- }
-
-}
+package org.jboss.webbeans.bean;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.webbeans.ApplicationScoped;
+import javax.webbeans.Decorator;
+import javax.webbeans.DefinitionException;
+import javax.webbeans.Dependent;
+import javax.webbeans.Destructor;
+import javax.webbeans.Disposes;
+import javax.webbeans.Initializer;
+import javax.webbeans.Interceptor;
+import javax.webbeans.Observes;
+import javax.webbeans.Produces;
+import javax.webbeans.Specializes;
+import javax.webbeans.manager.EnterpriseBeanLookup;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.ejb.EJB;
+import org.jboss.webbeans.ejb.EjbMetaData;
+import org.jboss.webbeans.introspector.impl.InjectableField;
+import org.jboss.webbeans.introspector.impl.InjectableMethod;
+import org.jboss.webbeans.introspector.impl.InjectableParameter;
+import org.jboss.webbeans.util.Reflections;
+
+public class EnterpriseBean<T> extends AbstractClassBean<T>
+{
+
+ private String location;
+
+ private EjbMetaData<T> ejbMetaData;
+
+ public EnterpriseBean(Class<T> type, ManagerImpl container)
+ {
+ super(type, container);
+ init();
+ }
+
+ @Override
+ protected void init()
+ {
+ super.init();
+ ejbMetaData = new EjbMetaData<T>(getType());
+ initRemoveMethod();
+ initInjectionPoints();
+ checkEnterpriseBeanTypeAllowed();
+ checkEnterpriseScopeAllowed();
+ checkConflictingRoles();
+ checkSpecialization();
+ }
+
+ @Override
+ protected void initInjectionPoints()
+ {
+ super.initInjectionPoints();
+ if (removeMethod != null)
+ {
+ for (InjectableParameter<?> injectable : removeMethod.getParameters())
+ {
+ injectionPoints.add(injectable);
+ }
+ }
+ }
+
+ protected void checkConflictingRoles()
+ {
+ if (getType().isAnnotationPresent(Interceptor.class))
+ {
+ throw new DefinitionException("Enterprise beans can't be interceptors");
+ }
+ if (getType().isAnnotationPresent(Decorator.class))
+ {
+ throw new DefinitionException("Enterprise beans can't be decorators");
+ }
+ }
+
+ /**
+ * Check that the scope type is allowed by the stereotypes on the bean and
+ * the bean type
+ *
+ * @param type
+ */
+ protected void checkEnterpriseScopeAllowed()
+ {
+ if (getEjbMetaData().isStateless()
+ && !getScopeType().equals(Dependent.class))
+ {
+ throw new DefinitionException("Scope " + getScopeType()
+ + " is not allowed on stateless enterpise beans for "
+ + getType()
+ + ". Only @Dependent is allowed on stateless enterprise beans");
+ }
+ if (getEjbMetaData().isSingleton()
+ && (!(getScopeType().equals(Dependent.class) || getScopeType()
+ .equals(ApplicationScoped.class))))
+ {
+ throw new DefinitionException(
+ "Scope "
+ + getScopeType()
+ + " is not allowed on singleton enterpise beans for "
+ + getType()
+ + ". Only @Dependent or @ApplicationScoped is allowed on singleton enterprise beans");
+ }
+ }
+
+ private void checkSpecialization()
+ {
+ if (!getType().isAnnotationPresent(Specializes.class))
+ {
+ return;
+ }
+ if (annotationDefined)
+ {
+ if (!isEJB(getType().getSuperclass()))
+ {
+ throw new DefinitionException("Annotation defined specializing EJB must have EJB superclass");
+ }
+ } else
+ {
+ if (!isEJB(getType()))
+ {
+ throw new DefinitionException("XML defined specializing EJB must have annotation defined EJB implementation");
+ }
+ }
+ }
+
+// TODO logging
+ protected void initRemoveMethod()
+ {
+ if (getEjbMetaData().isStateful())
+ {
+ if (getEjbMetaData().getRemoveMethods().size() == 1)
+ {
+// super.removeMethod = new InjectableMethod<Object>(getEjbMetaData().getRemoveMethods().get(0));
+ super.removeMethod = checkRemoveMethod(getEjbMetaData().getRemoveMethods().get(0));
+ }
+ else if (getEjbMetaData().getRemoveMethods().size() > 1)
+ {
+ List<Method> possibleRemoveMethods = new ArrayList<Method>();
+ for (Method removeMethod : getEjbMetaData().getRemoveMethods())
+ {
+ if (removeMethod.isAnnotationPresent(Destructor.class))
+ {
+ possibleRemoveMethods.add(removeMethod);
+ }
+ }
+ if (possibleRemoveMethods.size() == 1)
+ {
+ super.removeMethod = checkRemoveMethod(possibleRemoveMethods.get(0));
+ }
+ else if (possibleRemoveMethods.size() > 1)
+ {
+ throw new DefinitionException("Multiple remove methods are annotated @Destructor for " + getType());
+ }
+ else if (possibleRemoveMethods.size() == 0)
+ {
+ throw new RuntimeException("Multiple remove methods are declared, and none are annotated @Destructor for " + getType());
+ }
+ }
+ else if (getEjbMetaData().getRemoveMethods().isEmpty() && !getScopeType().equals(Dependent.class))
+ {
+ throw new DefinitionException("No remove methods declared for non-dependent scoped bean " + getType());
+ }
+ }
+ else
+ {
+ List<Method> destroysMethods = Reflections.getMethods(getType(), Destructor.class);
+ if (destroysMethods.size() > 0)
+ {
+ throw new DefinitionException("Only stateful enterprise beans can have methods annotated @Destructor; " + getType() + " is not a stateful enterprise bean");
+ }
+ }
+ }
+
+
+ private InjectableMethod<?> checkRemoveMethod(Method method)
+ {
+ if (method.isAnnotationPresent(Destructor.class) && !method.isAnnotationPresent(EJB.REMOVE_ANNOTATION)) {
+ throw new DefinitionException("Methods marked @Destructor must also be marked @Remove on " + method.getName());
+ }
+ if (method.isAnnotationPresent(Initializer.class)) {
+ throw new DefinitionException("Remove methods cannot be initializers on " + method.getName());
+ }
+ if (method.isAnnotationPresent(Produces.class)) {
+ throw new DefinitionException("Remove methods cannot be producers on " + method.getName());
+ }
+ if (hasParameterAnnotation(method.getParameterAnnotations(), Disposes.class)) {
+ throw new DefinitionException("Remove method can't have @Disposes annotated parameters on " + method.getName());
+ }
+ if (hasParameterAnnotation(method.getParameterAnnotations(), Observes.class)) {
+ throw new DefinitionException("Remove method can't have @Observes annotated parameters on " + method.getName());
+ }
+ return new InjectableMethod<Object>(method);
+ }
+
+ @Override
+ public T create()
+ {
+ T instance = (T) getManager().getInstanceByType(EnterpriseBeanLookup.class).lookup(ejbMetaData.getEjbName());
+ bindDecorators();
+ bindInterceptors();
+ injectEjbAndCommonFields();
+ injectBoundFields(instance);
+ callInitializers(instance);
+ return instance;
+ }
+
+ @Override
+ public void destroy(T instance)
+ {
+ super.destroy(instance);
+ }
+
+ protected void callInitializers(T instance)
+ {
+ for (InjectableMethod<Object> initializer : getInitializerMethods())
+ {
+ initializer.invoke(getManager(), instance);
+ }
+ }
+
+ protected void injectEjbAndCommonFields()
+ {
+ // TODO
+ }
+
+ protected void injectBoundFields(T instance)
+ {
+ for (InjectableField<?> injectableField : getInjectableFields())
+ {
+ injectableField.inject(instance, getManager());
+ }
+ }
+
+ public String getLocation()
+ {
+ if (location == null)
+ {
+ location = "type: Enterprise Bean; declaring class: " + getType() +";";
+ }
+ return location;
+ }
+
+ //FIXME move up?
+ private boolean hasParameterAnnotation(Annotation[][] parameterAnnotations, Class<? extends Annotation> clazz)
+ {
+ for (Annotation[] parameter : parameterAnnotations) {
+ for (Annotation annotation : parameter) {
+ if (annotation.annotationType() == clazz) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ protected AbstractBean<? extends T, Class<T>> getSpecializedType()
+ {
+ //TODO: lots of validation!
+ Class<?> superclass = getAnnotatedItem().getType().getSuperclass();
+ if ( superclass!=null )
+ {
+ return new EnterpriseBean(superclass, getManager());
+ }
+ else {
+ throw new RuntimeException();
+ }
+
+ }
+
+ private boolean isEJB(Class<? super T> clazz)
+ {
+ return clazz.isAnnotationPresent(EJB.SINGLETON_ANNOTATION)
+ || clazz.isAnnotationPresent(EJB.STATEFUL_ANNOTATION)
+ || clazz.isAnnotationPresent(EJB.STATELESS_ANNOTATION);
+ }
+
+ private void checkEnterpriseBeanTypeAllowed()
+ {
+ if (getEjbMetaData().isMessageDriven())
+ {
+ throw new DefinitionException(
+ "Message Driven Beans can't be Web Beans");
+ }
+ }
+
+ protected EjbMetaData<T> getEjbMetaData()
+ {
+ return ejbMetaData;
+ }
+
+ @Override
+ public String toString()
+ {
+ return "EnterpriseBean[" + getType().getName() + "]";
+ }
+
+
+
+}
Added: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EventBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EventBean.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EventBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,121 @@
+package org.jboss.webbeans.bean;
+
+import java.lang.reflect.Field;
+
+import javax.webbeans.Dependent;
+import javax.webbeans.Standard;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.event.EventImpl;
+import org.jboss.webbeans.introspector.AnnotatedField;
+import org.jboss.webbeans.introspector.AnnotatedItem;
+import org.jboss.webbeans.introspector.impl.SimpleAnnotatedField;
+import org.jboss.webbeans.log.LogProvider;
+import org.jboss.webbeans.log.Logging;
+
+public class EventBean<T> extends AbstractBean<EventImpl<T>, Field>
+{
+
+ private static LogProvider log = Logging.getLogProvider(EventBean.class);
+
+ private String location;
+ private AnnotatedField<EventImpl<T>> annotatedItem;
+
+ public EventBean(Field field, ManagerImpl manager)
+ {
+ super(manager);
+ this.annotatedItem = new SimpleAnnotatedField<EventImpl<T>>(field);
+ init();
+ }
+
+ /**
+ * Caches the constructor for this type of bean to avoid future reflections during use.
+ */
+ @SuppressWarnings("unchecked")
+ private void initConstructor()
+ {
+ try
+ {
+ //constructor = new SimpleConstructor<T>((Constructor<T>) EventImpl.class.getConstructor((Class[])null));
+ } catch (Exception e)
+ {
+ log.warn("Unable to get constructor for build-in Event implementation", e);
+ }
+ }
+
+
+ /*public BeanConstructor<T> getConstructor()
+ {
+ return constructor;
+ }*/
+
+ public String getLocation()
+ {
+ if (location == null)
+ {
+ location = "type: Event Bean;";
+ }
+ return location;
+ }
+
+ @Override
+ public String toString()
+ {
+ return "EventBean[" + getType().getName() + "]";
+ }
+
+ @Override
+ protected void initType()
+ {
+ log.trace("Bean type specified in Java");
+ this.type = annotatedItem.getType();
+ }
+
+ @Override
+ protected AnnotatedItem<EventImpl<T>, Field> getAnnotatedItem()
+ {
+ return annotatedItem;
+ }
+
+ @Override
+ protected String getDefaultName()
+ {
+ // No name per 7.4
+ return null;
+ }
+
+ @Override
+ protected void initDeploymentType()
+ {
+ // This is always @Standard per 7.4
+ this.deploymentType = Standard.class;
+ }
+
+ @Override
+ protected void checkDeploymentType()
+ {
+ // No - op
+ }
+
+ @Override
+ protected void initName()
+ {
+ // No name per 7.4
+ this.name = null;
+ }
+
+ @Override
+ protected void initScopeType()
+ {
+ // This is always @Dependent per 7.4
+ this.scopeType = Dependent.class;
+ }
+
+ @Override
+ public EventImpl<T> create()
+ {
+ return new EventImpl<T>();
+ }
+
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/EventBean.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/MergedStereotypesModel.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,92 @@
+package org.jboss.webbeans.bean;
+
+import java.lang.annotation.Annotation;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.model.StereotypeModel;
+
+/**
+ * Meta model for the merged stereotype for a bean
+ * @author pmuir
+ *
+ */
+public class MergedStereotypes<T, E>
+{
+
+ private Map<Class<? extends Annotation>, Annotation> possibleDeploymentTypes;
+ private Set<Annotation> possibleScopeTypes;
+ private boolean beanNameDefaulted;
+ private Set<Class<?>> requiredTypes;
+ private Set<Class<? extends Annotation>> supportedScopes;
+
+ public MergedStereotypes(Set<Annotation> stereotypeAnnotations, ManagerImpl manager)
+ {
+ possibleDeploymentTypes = new HashMap<Class<? extends Annotation>, Annotation>();
+ possibleScopeTypes = new HashSet<Annotation>();
+ requiredTypes = new HashSet<Class<?>>();
+ supportedScopes = new HashSet<Class<? extends Annotation>>();
+ merge(stereotypeAnnotations, manager);
+ }
+
+ protected void merge(Set<Annotation> stereotypeAnnotations, ManagerImpl manager)
+ {
+ for (Annotation stereotypeAnnotation : stereotypeAnnotations)
+ {
+ // Retrieve and merge all metadata from stereotypes
+ StereotypeModel<?> stereotype = manager.getModelManager().getStereotype(stereotypeAnnotation.annotationType());
+ if (stereotype == null)
+ {
+ throw new NullPointerException("Stereotype " + stereotypeAnnotation + " not registered with container");
+ }
+ if (stereotype.getDefaultDeploymentType() != null)
+ {
+ possibleDeploymentTypes.put(stereotype.getDefaultDeploymentType().annotationType(), stereotype.getDefaultDeploymentType());
+ }
+ if (stereotype.getDefaultScopeType() != null)
+ {
+ possibleScopeTypes.add(stereotype.getDefaultScopeType());
+ }
+ requiredTypes.addAll(stereotype.getRequiredTypes());
+ supportedScopes.addAll(stereotype.getSupportedScopes());
+ if (stereotype.isBeanNameDefaulted())
+ {
+ beanNameDefaulted = true;
+ }
+ }
+ }
+
+ public Map<Class<? extends Annotation>, Annotation> getPossibleDeploymentTypes()
+ {
+ return possibleDeploymentTypes;
+ }
+
+ public Set<Annotation> getPossibleScopeTypes()
+ {
+ return possibleScopeTypes;
+ }
+
+ public boolean isBeanNameDefaulted()
+ {
+ return beanNameDefaulted;
+ }
+
+ public Set<Class<?>> getRequiredTypes()
+ {
+ return requiredTypes;
+ }
+
+ public Set<Class<? extends Annotation>> getSupportedScopes()
+ {
+ return supportedScopes;
+ }
+
+ public boolean isDeclaredInXml()
+ {
+ return false;
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/ProducerMethodBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/ProducerMethodBean.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/ProducerMethodBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,39 +1,207 @@
package org.jboss.webbeans.bean;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.webbeans.DefinitionException;
import javax.webbeans.Dependent;
+import javax.webbeans.Destructor;
+import javax.webbeans.Disposes;
import javax.webbeans.IllegalProductException;
+import javax.webbeans.Observes;
import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.model.bean.ProducerMethodBeanModel;
+import org.jboss.webbeans.introspector.AnnotatedMethod;
+import org.jboss.webbeans.introspector.AnnotatedParameter;
+import org.jboss.webbeans.introspector.impl.InjectableMethod;
+import org.jboss.webbeans.introspector.impl.InjectableParameter;
+import org.jboss.webbeans.introspector.impl.SimpleAnnotatedMethod;
-public class ProducerMethodBean<T> extends AbstractBean<T>
+public class ProducerMethodBean<T> extends AbstractBean<T, Method>
{
- private ProducerMethodBeanModel<T> model;
+ private AnnotatedMethod<T> annotatedMethod;
+ private AbstractClassBean<?> declaringBean;
+
+ // Cached values
+ private String location;
- public ProducerMethodBean(ProducerMethodBeanModel<T> model, ManagerImpl manager)
+ public ProducerMethodBean(Method method, AbstractClassBean<?> declaringBean, ManagerImpl manager)
{
super(manager);
- this.model = model;
+ this.annotatedMethod = new SimpleAnnotatedMethod<T>(method);
+ this.declaringBean = declaringBean;
+ init();
}
@Override
- public ProducerMethodBeanModel<T> getModel()
+ public T create()
{
- return model;
+ T instance = annotatedMethod.invoke(getManager(), getManager().getInstance(getDeclaringBean()));
+ if (instance == null && !getScopeType().equals(Dependent.class))
+ {
+ throw new IllegalProductException("Cannot return null from a non-dependent method");
+ }
+ return instance;
}
@Override
- public T create()
+ protected void init()
{
- T instance = model.getConstructor().invoke(manager, manager.getInstance(model.getDeclaringBean()));
- if (instance == null && !model.getScopeType().equals(Dependent.class))
+ super.init();
+ checkProducerMethod();
+ initRemoveMethod();
+ initInjectionPoints();
+ }
+
+ @Override
+ protected void initInjectionPoints()
+ {
+ super.initInjectionPoints();
+ for (AnnotatedParameter<Object> annotatedParameter : annotatedMethod.getParameters())
{
- throw new IllegalProductException("Cannot return null from a non-dependent method");
+ injectionPoints.add(new InjectableParameter<Object>(annotatedParameter));
}
- return instance;
+ if (removeMethod != null)
+ {
+ for (InjectableParameter<?> injectable : removeMethod.getParameters())
+ {
+ injectionPoints.add(injectable);
+ }
+ }
}
+ @Override
+ protected void initDeploymentType()
+ {
+ super.initDeploymentType();
+ if (getDeploymentType() == null)
+ {
+ deploymentType = declaringBean.getDeploymentType();
+ }
+ }
+
+ protected void checkProducerMethod()
+ {
+ if (getAnnotatedItem().isStatic())
+ {
+ throw new DefinitionException("Producer method cannot be static " + annotatedMethod);
+ }
+ else if (getAnnotatedItem().isAnnotationPresent(Destructor.class))
+ {
+ throw new DefinitionException("Producer method cannot be annotated @Destructor");
+ }
+ else if (getAnnotatedItem().getAnnotatedParameters(Observes.class).size() > 0)
+ {
+ throw new DefinitionException("Producer method cannot have parameter annotated @Observes");
+ }
+ else if (getAnnotatedItem().getAnnotatedParameters(Disposes.class).size() > 0)
+ {
+ throw new DefinitionException("Producer method cannot have parameter annotated @Disposes");
+ }
+ else if (getAnnotatedItem().getActualTypeArguments().length > 0)
+ {
+ for (Type type : getAnnotatedItem().getActualTypeArguments())
+ {
+ if (!(type instanceof Class))
+ {
+ throw new DefinitionException("Producer method cannot return type parameterized with type parameter or wildcard");
+ }
+ }
+ }
+ }
+
+ protected void initRemoveMethod()
+ {
+ Set<Method> disposalMethods = getManager().resolveDisposalMethods(getType(), getBindingTypes().toArray(new Annotation[0]));
+ if (disposalMethods.size() == 1)
+ {
+ removeMethod = new InjectableMethod<Object>(disposalMethods.iterator().next());
+ }
+ else if (disposalMethods.size() > 1)
+ {
+ // TODO List out found disposal methods
+ throw new RuntimeException(getLocation() + "Cannot declare multiple disposal methods for this producer method");
+ }
+ }
+
+ @Override
+ public String toString()
+ {
+ return "ProducerMethodBean[" + getType().getName() + "]";
+ }
+ @Override
+ protected AnnotatedMethod<T> getAnnotatedItem()
+ {
+ return annotatedMethod;
+ }
+
+ @Override
+ protected String getDefaultName()
+ {
+ return annotatedMethod.getPropertyName();
+ }
+
+ @Override
+ protected void initType()
+ {
+ try
+ {
+ if (getAnnotatedItem() != null)
+ {
+ this.type = getAnnotatedItem().getType();
+ }
+ }
+ catch (ClassCastException e)
+ {
+ throw new RuntimeException(getLocation() + " Cannot cast producer method return type " + annotatedMethod.getAnnotatedMethod().getReturnType() + " to bean type " + (getDeclaredBeanType() == null ? " unknown " : getDeclaredBeanType()), e);
+ }
+ }
+ @Override
+ protected void initApiTypes()
+ {
+ if (getType().isArray() || getType().isPrimitive())
+ {
+ super.apiTypes = new HashSet<Class<?>>();
+ super.apiTypes.add(getType());
+ super.apiTypes.add(Object.class);
+ }
+ else if (getType().isInterface())
+ {
+ super.initApiTypes();
+ super.apiTypes.add(Object.class);
+ }
+ else
+ {
+ super.initApiTypes();
+ }
+ }
+
+
+
+ public String getLocation()
+ {
+ if (location == null)
+ {
+ location = "type: Producer Method; declaring class: " + annotatedMethod.getAnnotatedMethod().getDeclaringClass() +"; producer method: " + annotatedMethod.getAnnotatedMethod().toString() + ";";
+ }
+ return location;
+ }
+
+ public InjectableMethod<?> getDisposalMethod()
+ {
+ return removeMethod;
+ }
+
+ public AbstractClassBean<?> getDeclaringBean()
+ {
+ return declaringBean;
+ }
+
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/SimpleBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/SimpleBean.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/SimpleBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,26 +1,46 @@
package org.jboss.webbeans.bean;
+import java.util.Collections;
+import java.util.Set;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.webbeans.DefinitionException;
+import javax.webbeans.Initializer;
+
import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.injectable.InjectableField;
-import org.jboss.webbeans.injectable.InjectableMethod;
+import org.jboss.webbeans.introspector.AnnotatedConstructor;
import org.jboss.webbeans.introspector.AnnotatedMethod;
-import org.jboss.webbeans.model.bean.SimpleBeanModel;
+import org.jboss.webbeans.introspector.AnnotatedParameter;
+import org.jboss.webbeans.introspector.impl.InjectableField;
+import org.jboss.webbeans.introspector.impl.InjectableMethod;
+import org.jboss.webbeans.introspector.impl.InjectableParameter;
+import org.jboss.webbeans.log.LogProvider;
+import org.jboss.webbeans.log.Logging;
+import org.jboss.webbeans.util.Reflections;
-public class SimpleBean<T> extends AbstractBean<T>
+public class SimpleBean<T> extends AbstractClassBean<T>
{
- private SimpleBeanModel<T> model;
+ private static LogProvider log = Logging.getLogProvider(SimpleBean.class);
+ private static Set<Class<?>> NO_ARGUMENTS = Collections.emptySet();
- public SimpleBean(SimpleBeanModel<T> model, ManagerImpl manager)
+ private AnnotatedConstructor<T> constructor;
+ private String location;
+
+ private AnnotatedMethod<Object> postConstruct;
+ private AnnotatedMethod<Object> preDestroy;
+
+ public SimpleBean(Class<T> type, ManagerImpl manager)
{
- super(manager);
- this.model = model;
+ super(type, manager);
+ init();
}
@Override
public T create()
{
- T instance = model.getConstructor().invoke(manager);
+ T instance = constructor.newInstance(getManager());
bindDecorators();
bindInterceptors();
injectEjbAndCommonFields();
@@ -38,7 +58,7 @@
protected void callPreDestroy(T instance)
{
- AnnotatedMethod<Object> preDestroy = getModel().getPreDestroy();
+ AnnotatedMethod<Object> preDestroy = getPreDestroy();
if (preDestroy!=null)
{
try
@@ -51,15 +71,15 @@
}
}
}
-
+
protected void callPostConstruct(T instance)
{
- AnnotatedMethod<Object> postConstruct = getModel().getPostConstruct();
+ AnnotatedMethod<Object> postConstruct = getPostConstruct();
if (postConstruct!=null)
{
try
{
- postConstruct.getAnnotatedMethod().invoke(instance);
+ postConstruct.invoke(instance);
}
catch (Exception e)
{
@@ -70,9 +90,9 @@
protected void callInitializers(T instance)
{
- for (InjectableMethod<Object> initializer : model.getInitializerMethods())
+ for (InjectableMethod<Object> initializer : getInitializerMethods())
{
- initializer.invoke(manager, instance);
+ initializer.invoke(getManager(), instance);
}
}
@@ -83,16 +103,155 @@
protected void injectBoundFields(T instance)
{
- for (InjectableField<?> injectableField : getModel().getInjectableFields())
+ for (InjectableField<?> injectableField : getInjectableFields())
{
- injectableField.inject(instance, manager);
+ injectableField.inject(instance, getManager());
}
}
+
+ @Override
+ protected void init()
+ {
+ super.init();
+ initConstructor();
+ checkType(getType());
+ initInjectionPoints();
+ initPostConstruct();
+ initPreDestroy();
+ // TODO Interceptors
+ }
+
+ @Override
+ protected void initInjectionPoints()
+ {
+ super.initInjectionPoints();
+ for (AnnotatedParameter<Object> parameter : constructor.getParameters())
+ {
+ injectionPoints.add(new InjectableParameter<Object>(parameter));
+ }
+ }
+
+ public static void checkType(Class<?> type)
+ {
+ if (Reflections.isNonStaticInnerClass(type))
+ {
+ throw new DefinitionException("Simple Web Bean " + type + " cannot be a non-static inner class");
+ }
+ if (Reflections.isParameterizedType(type))
+ {
+ throw new DefinitionException("Simple Web Bean " + type + " cannot be a parameterized type");
+ }
+ }
+
+ protected void initConstructor()
+ {
+ Set<AnnotatedConstructor<T>> initializerAnnotatedConstructors = getAnnotatedItem().getAnnotatedConstructors(Initializer.class);
+ log.trace("Found " + initializerAnnotatedConstructors + " constructors annotated with @Initializer for " + getType());
+ if (initializerAnnotatedConstructors.size() > 1)
+ {
+ if (initializerAnnotatedConstructors.size() > 1)
+ {
+ throw new DefinitionException("Cannot have more than one constructor annotated with @Initializer for " + getType());
+ }
+ }
+ else if (initializerAnnotatedConstructors.size() == 1)
+ {
+ this.constructor = initializerAnnotatedConstructors.iterator().next();
+ log.trace("Exactly one constructor (" + constructor +") annotated with @Initializer defined, using it as the bean constructor for " + getType());
+ return;
+ }
+
+ if (getAnnotatedItem().getConstructor(NO_ARGUMENTS) != null)
+ {
+
+ this.constructor =getAnnotatedItem().getConstructor(NO_ARGUMENTS);
+ log.trace("Exactly one constructor (" + constructor +") defined, using it as the bean constructor for " + getType());
+ return;
+ }
+
+ throw new DefinitionException("Cannot determine constructor to use for " + getType());
+ }
+
+ protected void initPostConstruct()
+ {
+ Set<AnnotatedMethod<Object>> postConstructMethods = getAnnotatedItem().getAnnotatedMethods(PostConstruct.class);
+ log.trace("Found " + postConstructMethods + " constructors annotated with @Initializer for " + getType());
+ if (postConstructMethods.size() > 1)
+ {
+ //TODO: actually this is wrong, in EJB you can have @PostConstruct methods on the superclass,
+ // though the Web Beans spec is silent on the issue
+ throw new DefinitionException("Cannot have more than one post construct method annotated with @Initializer for " + getType());
+ }
+ else if (postConstructMethods.size() == 1)
+ {
+ this.postConstruct = postConstructMethods.iterator().next();
+ log.trace("Exactly one post construct method (" + postConstruct +") for " + getType());
+ return;
+ }
+ }
+ protected void initPreDestroy()
+ {
+ Set<AnnotatedMethod<Object>> preDestroyMethods = getAnnotatedItem().getAnnotatedMethods(PreDestroy.class);
+ log.trace("Found " + preDestroyMethods + " constructors annotated with @Initializer for " + getType());
+ if (preDestroyMethods.size() > 1)
+ {
+ //TODO: actually this is wrong, in EJB you can have @PreDestroy methods on the superclass,
+ // though the Web Beans spec is silent on the issue
+ throw new DefinitionException("Cannot have more than one pre destroy method annotated with @Initializer for " + getType());
+ }
+ else if (preDestroyMethods.size() == 1)
+ {
+ this.preDestroy = preDestroyMethods.iterator().next();
+ log.trace("Exactly one post construct method (" + preDestroy +") for " + getType());
+ return;
+ }
+ }
+
+
+ public AnnotatedConstructor<T> getConstructor()
+ {
+ return constructor;
+ }
+
+
@Override
- public SimpleBeanModel<T> getModel()
+ public String toString()
{
- return model;
+ return "SimpleWebBean[" + getAnnotatedItem().toString() + "]";
}
+ public String getLocation()
+ {
+ if (location == null)
+ {
+ location = "type: Simple Bean; declaring class: " + getType() +";";
+ }
+ return location;
+ }
+
+ protected AbstractBean<? extends T, Class<T>> getSpecializedType()
+ {
+ //TODO: lots of validation!
+ Class<?> superclass = getAnnotatedItem().getType().getSuperclass();
+ if ( superclass!=null )
+ {
+ return new SimpleBean(superclass, getManager());
+ }
+ else
+ {
+ throw new RuntimeException();
+ }
+ }
+
+ public AnnotatedMethod<Object> getPostConstruct()
+ {
+ return postConstruct;
+ }
+
+ public AnnotatedMethod<Object> getPreDestroy()
+ {
+ return preDestroy;
+ }
+
}
Added: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/XmlSimpleBean.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/XmlSimpleBean.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/XmlSimpleBean.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,17 @@
+package org.jboss.webbeans.bean;
+
+import org.jboss.webbeans.ManagerImpl;
+
+public class XmlSimpleBean<T> extends SimpleBean<T>
+{
+
+ public XmlSimpleBean(Class<T> type, ManagerImpl manager)
+ {
+ super(type, manager);
+ }
+
+ protected boolean isDefinedInXml()
+ {
+ return true;
+ }
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/XmlSimpleBean.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -8,11 +8,11 @@
import javax.webbeans.Observer;
import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.injectable.ForwardingInjectableMethod;
-import org.jboss.webbeans.injectable.ForwardingInjectableParameter;
-import org.jboss.webbeans.injectable.InjectableMethod;
-import org.jboss.webbeans.injectable.InjectableParameter;
-import org.jboss.webbeans.model.bean.BeanModel;
+import org.jboss.webbeans.bean.EventBean;
+import org.jboss.webbeans.introspector.impl.ForwardingInjectableMethod;
+import org.jboss.webbeans.introspector.impl.ForwardingInjectableParameter;
+import org.jboss.webbeans.introspector.impl.InjectableMethod;
+import org.jboss.webbeans.introspector.impl.InjectableParameter;
import com.google.common.collect.ForwardingIterator;
import com.google.common.collect.ForwardingList;
@@ -31,7 +31,7 @@
public class ObserverImpl<T> implements Observer<T>
{
- private final BeanModel<?, ?> beanModel;
+ private EventBean<T> eventBean;
private final InjectableMethod<Object> observerMethod;
private final Class<T> eventType;
@@ -58,10 +58,10 @@
* @param observer The observer method to notify
* @param eventType The type of event being observed
*/
- public ObserverImpl(final BeanModel<?, ?> beanModel,
+ public ObserverImpl(final EventBean<T> eventBean,
final InjectableMethod<Object> observer, final Class<T> eventType)
{
- this.beanModel = beanModel;
+ this.eventBean = eventBean;
this.observerMethod = observer;
this.eventType = eventType;
}
@@ -172,7 +172,6 @@
protected Object getInstance()
{
// Return the most specialized instance of the component
- return manager.getInstanceByType(beanModel.getType(), beanModel
- .getBindingTypes().toArray(new Annotation[0]));
+ return manager.getInstanceByType(eventBean.getType(), eventBean.getBindingTypes().toArray(new Annotation[0]));
}
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/exceptions/TypesafeResolutionLocation.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/exceptions/TypesafeResolutionLocation.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/exceptions/TypesafeResolutionLocation.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -4,7 +4,7 @@
import java.lang.reflect.Type;
import java.util.Set;
-import org.jboss.webbeans.injectable.Injectable;
+import org.jboss.webbeans.introspector.impl.Injectable;
public class TypesafeResolutionLocation extends Location
{
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/BeanConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/BeanConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/BeanConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,10 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import org.jboss.webbeans.ManagerImpl;
-
-public interface BeanConstructor<T, S>
-{
-
- public T invoke(ManagerImpl manager, Object instance);
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/EnterpriseConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/EnterpriseConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/EnterpriseConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,38 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import javax.webbeans.manager.EnterpriseBeanLookup;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.ejb.EjbMetaData;
-
-
-public class EnterpriseConstructor<T> implements BeanConstructor<T, Object>
-{
-
- private EjbMetaData<T> ejbMetaData;
-
- public EnterpriseConstructor(EjbMetaData<T> ejbMetaData)
- {
- this.ejbMetaData = ejbMetaData;
- }
-
- public T invoke(ManagerImpl manager)
- {
- // TODO Hmm, this isn't right
- if (manager instanceof ManagerImpl)
- {
- ManagerImpl containerImpl = (ManagerImpl) manager;
- return (T) containerImpl.getInstanceByType(EnterpriseBeanLookup.class).lookup(ejbMetaData.getEjbName());
- }
- else
- {
- throw new RuntimeException("Error accessing webbeans container");
- }
- }
-
- public T invoke(ManagerImpl manager, Object instance)
- {
- return invoke(manager);
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableMethod.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableMethod.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableMethod.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,63 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.util.List;
-
-import javax.webbeans.manager.Manager;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedMethod;
-
-public abstract class ForwardingInjectableMethod<T> extends InjectableMethod<T>
-{
-
- @Override
- public boolean equals(Object obj)
- {
- return delegate().equals(obj);
- }
-
- @Override
- public AnnotatedMethod<T> getAnnotatedItem()
- {
- return delegate().getAnnotatedItem();
- }
-
- @Override
- public List<InjectableParameter<Object>> getParameters()
- {
- return delegate().getParameters();
- }
-
- @Override
- protected Object[] getParameterValues(ManagerImpl manager)
- {
- return delegate().getParameterValues(manager);
- }
-
- @Override
- public int hashCode()
- {
- return delegate().hashCode();
- }
-
- @Override
- public T invoke(Manager manager, Object instance, Object[] parameters)
- {
- return delegate().invoke(manager, instance, parameters);
- }
-
- @Override
- public T invoke(ManagerImpl manager, Object instance)
- {
- return delegate().invoke(manager, instance);
- }
-
- @Override
- public String toString()
- {
- return delegate().toString();
- }
-
- protected abstract InjectableMethod<T> delegate();
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableParameter.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableParameter.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableParameter.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,41 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.annotation.Annotation;
-import java.util.List;
-import java.util.Set;
-
-import javax.webbeans.manager.Bean;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.ModelManager;
-
-public abstract class ForwardingInjectableParameter<T> extends InjectableParameter<T>
-{
-
- protected abstract InjectableParameter<? extends T> delegate();
-
- @Override
- public Set<Annotation> getBindingTypes()
- {
- return delegate().getBindingTypes();
- }
-
- @Override
- public Set<Bean<?>> getMatchingBeans(List<Bean<?>> possibleBeans, ModelManager modelManager)
- {
- return delegate().getMatchingBeans(possibleBeans, modelManager);
- }
-
- @Override
- public Class<? extends T> getType()
- {
- return delegate().getType();
- }
-
- @Override
- public T getValue(ManagerImpl manager)
- {
- return delegate().getValue(manager);
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Injectable.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Injectable.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Injectable.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,155 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.annotation.Annotation;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import javax.webbeans.BindingType;
-import javax.webbeans.manager.Bean;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.ModelManager;
-import org.jboss.webbeans.bindings.CurrentAnnotationLiteral;
-import org.jboss.webbeans.introspector.AnnotatedItem;
-import org.jboss.webbeans.model.BindingTypeModel;
-
-/**
- * Abstraction of java reflection for Web Beans, represent's something that can
- * be injected
- *
- * @author Pete Muir
- *
- */
-public abstract class Injectable<T, S>
-{
-
- private static final Annotation[] DEFAULT_BINDING_ARRAY = {new CurrentAnnotationLiteral()};
- private static final Set<Annotation> DEFAULT_BINDING = new HashSet<Annotation>(Arrays.asList(DEFAULT_BINDING_ARRAY));
-
- private AnnotatedItem<T, S> annotatedItem;
-
- private boolean useDefaultBinding;
-
- public Injectable(AnnotatedItem<T, S> annotatedItem)
- {
- this.annotatedItem = annotatedItem;
- if (annotatedItem.getAnnotations(BindingType.class).size() == 0)
- {
- useDefaultBinding = true;
- }
- }
-
- public Set<Annotation> getBindingTypes()
- {
- if (useDefaultBinding)
- {
- return DEFAULT_BINDING;
- }
- else
- {
- return annotatedItem.getAnnotations(BindingType.class);
- }
- }
-
- public Annotation[] getBindingTypesAsArray()
- {
- if (useDefaultBinding)
- {
- return DEFAULT_BINDING_ARRAY;
- }
- else
- {
- return annotatedItem.getAnnotationsAsArray(BindingType.class);
- }
- }
-
- protected Injectable() {}
-
- @Override
- public String toString()
- {
- return getClass().getSimpleName() + "[" + getAnnotatedItem().toString() + "]";
- }
-
- public T getValue(ManagerImpl manager)
- {
- return manager.getInstanceByType(getType(), getBindingTypesAsArray());
- }
-
- public Class<? extends T> getType()
- {
- return annotatedItem.getType();
- }
-
- public AnnotatedItem<T, S> getAnnotatedItem()
- {
- return annotatedItem;
- }
-
- public Set<Bean<?>> getMatchingBeans(List<Bean<?>> beans, ModelManager modelManager)
- {
- Set<Bean<?>> resolvedBeans = new HashSet<Bean<?>>();
- for (Bean<?> bean : beans)
- {
- if (getAnnotatedItem().isAssignableFrom(bean.getTypes()) && containsAllBindingBindingTypes(bean.getBindingTypes(), modelManager))
- {
- resolvedBeans.add(bean);
- }
- }
- return resolvedBeans;
- }
-
- @Override
- public boolean equals(Object other)
- {
- // TODO Do we need to check the other direction too?
- if (other instanceof Injectable)
- {
- Injectable<?, ?> that = (Injectable<?, ?>) other;
- return this.getAnnotatedItem().isAssignableFrom(that.getAnnotatedItem()) &&
- that.getBindingTypes().equals(this.getBindingTypes());
- }
- else
- {
- return false;
- }
- }
-
- @Override
- public int hashCode()
- {
- // TODO Implement this!
- return 0;
- }
-
- private boolean containsAllBindingBindingTypes(Set<Annotation> bindingTypes, ModelManager modelManager)
- {
- for (Annotation bindingType : getBindingTypes())
- {
- BindingTypeModel<?> bindingTypeModel = modelManager.getBindingTypeModel(bindingType.annotationType());
- if (bindingTypeModel.getNonBindingTypes().size() > 0)
- {
- boolean matchFound = false;
- for (Annotation otherBindingType : bindingTypes)
- {
- if (bindingTypeModel.isEqual(bindingType, otherBindingType))
- {
- matchFound = true;
- }
- }
- if (!matchFound)
- {
- return false;
- }
- }
- else if (!bindingTypes.contains(bindingType))
- {
- return false;
- }
- }
- return true;
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableField.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableField.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableField.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,34 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.reflect.Field;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedField;
-import org.jboss.webbeans.introspector.impl.SimpleAnnotatedField;
-import org.jboss.webbeans.util.Reflections;
-
-/**
- * Abstraction of Java Reflection
- *
- * @author Pete Muir
- *
- */
-public class InjectableField<T> extends Injectable<T, Field>
-{
-
- public InjectableField(Field field)
- {
- super(new SimpleAnnotatedField<T>(field));
- }
-
- public InjectableField(AnnotatedField<T> annotatedField)
- {
- super(annotatedField);
- }
-
- public void inject(Object instance, ManagerImpl manager)
- {
- Reflections.setAndWrap(getAnnotatedItem().getDelegate(), instance, getValue(manager));
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableMethod.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableMethod.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableMethod.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,50 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import javax.webbeans.manager.Manager;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedMethod;
-import org.jboss.webbeans.introspector.impl.SimpleAnnotatedMethod;
-
-public class InjectableMethod<T> extends Invokable<T, AnnotatedMethod<T>>
-{
-
- private AnnotatedMethod<T> method;
-
- protected InjectableMethod(){}
-
- public InjectableMethod(java.lang.reflect.Method method)
- {
- this(new SimpleAnnotatedMethod<T>(method));
- }
-
- public InjectableMethod(AnnotatedMethod<T> annotatedMethod)
- {
- super(annotatedMethod.getParameters());
- this.method = annotatedMethod;
- }
-
-
- public T invoke(ManagerImpl manager, Object instance)
- {
- return invoke(manager, instance, getParameterValues(manager));
- }
-
- public T invoke(Manager container, Object instance, Object[] parameters)
- {
- try
- {
- return (T) method.getAnnotatedMethod().invoke(instance, parameters);
- }
- catch (Exception e)
- {
- throw new RuntimeException("Unable to invoke " + method + " on " + instance, e);
- }
- }
-
- public AnnotatedMethod<T> getAnnotatedItem()
- {
- return method;
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableParameter.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableParameter.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableParameter.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,31 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.annotation.Annotation;
-
-import org.jboss.webbeans.bindings.CurrentAnnotationLiteral;
-import org.jboss.webbeans.introspector.AnnotatedParameter;
-import org.jboss.webbeans.introspector.impl.SimpleAnnotatedParameter;
-
-public class InjectableParameter<T> extends Injectable<T, Object>
-{
-
- private static Annotation[] currentBinding = {new CurrentAnnotationLiteral()};
-
- protected InjectableParameter() {}
-
- public InjectableParameter(Annotation[] bindingTypes, Class<T> type)
- {
- super(new SimpleAnnotatedParameter<T>(bindingTypes, type));
- }
-
- public InjectableParameter(AnnotatedParameter<T> annotatedParameter)
- {
- super(annotatedParameter);
- }
-
- public InjectableParameter(Class<T> type)
- {
- this(currentBinding, type);
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableWrapper.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableWrapper.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableWrapper.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,46 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.annotation.Annotation;
-import java.util.List;
-import java.util.Set;
-
-import javax.webbeans.manager.Bean;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.ModelManager;
-
-public class InjectableWrapper<T, S> extends Injectable<T, S>
-{
-
- private Injectable<T, S> delegate;
-
- public InjectableWrapper(Injectable<T, S> delegate)
- {
- this.delegate = delegate;
- }
-
- @Override
- public Set<Annotation> getBindingTypes()
- {
- return delegate.getBindingTypes();
- }
-
- @Override
- public Set<Bean<?>> getMatchingBeans(List<Bean<?>> possibleBeans, ModelManager modelManager)
- {
- return delegate.getMatchingBeans(possibleBeans, modelManager);
- }
-
- @Override
- public Class<? extends T> getType()
- {
- return delegate.getType();
- }
-
- @Override
- public T getValue(ManagerImpl manager)
- {
- return delegate.getValue(manager);
- }
-
-}
\ No newline at end of file
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Invokable.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Invokable.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Invokable.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,50 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import javax.webbeans.manager.Manager;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedParameter;
-
-public abstract class Invokable<T, S>
-{
-
- private List<InjectableParameter<Object>> parameters;
-
- protected Invokable() {}
-
- public Invokable(List<AnnotatedParameter<Object>> parameters)
- {
- this.parameters = new ArrayList<InjectableParameter<Object>>();
- for (AnnotatedParameter<Object> parameter : parameters)
- {
- this.parameters.add(new InjectableParameter<Object>(parameter));
- }
- }
-
- public abstract S getAnnotatedItem();
-
- protected Object[] getParameterValues(ManagerImpl manager)
- {
- Object[] parameterValues = new Object[parameters.size()];
- Iterator<InjectableParameter<Object>> iterator = parameters.iterator();
- for (int i = 0; i < parameterValues.length; i++)
- {
- parameterValues[i] = iterator.next().getValue(manager);
- }
- return parameterValues;
- }
-
- public List<InjectableParameter<Object>> getParameters()
- {
- return parameters;
- }
-
- public abstract T invoke(Manager container, Object instance, Object[] parameters);
-
- public abstract T invoke(ManagerImpl container, Object instance);
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/JMSConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/JMSConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/JMSConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,34 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.util.JNDI;
-
-public class JMSConstructor<T> implements BeanConstructor<T, Object>
-{
-
- Class<? extends T> type;
-
- private String jndiName;
-
- public JMSConstructor(String jndiName)
- {
- this.jndiName = jndiName;
- }
-
- public T invoke(ManagerImpl manager)
- {
- return JNDI.lookup(jndiName, type);
- }
-
- public Object getAnnotatedItem()
- {
- // TODO Auto-generated method stub
- return null;
- }
-
- public T invoke(ManagerImpl manager, Object instance)
- {
- return invoke(manager);
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/MethodConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/MethodConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/MethodConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,23 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.reflect.Method;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedMethod;
-import org.jboss.webbeans.util.Reflections;
-
-public class MethodConstructor<T> extends InjectableMethod<T> implements
- BeanConstructor<T, AnnotatedMethod<T>>
-{
-
- public MethodConstructor(Method method)
- {
- super(method);
- }
-
- public T invoke(ManagerImpl manager, Object instance)
- {
- return (T) Reflections.invokeAndWrap(getAnnotatedItem().getDelegate(), instance, getParameterValues(manager));
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ResolverInjectable.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ResolverInjectable.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ResolverInjectable.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,54 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-
-import javax.webbeans.BindingType;
-import javax.webbeans.DuplicateBindingTypeException;
-import javax.webbeans.TypeLiteral;
-
-import org.jboss.webbeans.ModelManager;
-import org.jboss.webbeans.introspector.impl.SimpleAnnotatedItem;
-
-/**
- * TODO Rename this to something which implies it only ever used for resolution
- * @author Pete Muir
- *
- */
-public class ResolverInjectable<T> extends Injectable<T, Object>
-{
-
- public ResolverInjectable(SimpleAnnotatedItem<T, Object> annotatedItem, ModelManager modelManager)
- {
- super(annotatedItem);
- for (Annotation annotation : annotatedItem.getAnnotations())
- {
- if (!modelManager.getBindingTypeModel(annotation.annotationType()).isValid())
- {
- throw new IllegalArgumentException("Not a binding type " + annotation);
- }
- }
- if (annotatedItem.getActualAnnotations().length > annotatedItem.getAnnotations(BindingType.class).size())
- {
- throw new DuplicateBindingTypeException(getAnnotatedItem().toString());
- }
-
-
- }
-
- public ResolverInjectable(Class<T> type, Annotation[] bindingTypes, ModelManager modelManager)
- {
- this(new SimpleAnnotatedItem<T, Object>(bindingTypes, type), modelManager);
- }
-
- public ResolverInjectable(Class<T> type, Annotation[] bindingTypes, ModelManager modelManager, Type ... actualTypeArguments)
- {
- this(new SimpleAnnotatedItem<T, Object>(bindingTypes, type, actualTypeArguments), modelManager);
- }
-
- public ResolverInjectable(TypeLiteral<T> apiType, Annotation[] bindingTypes, ModelManager modelManager)
- {
- this(new SimpleAnnotatedItem<T, Object>(bindingTypes, apiType), modelManager);
- }
-
-}
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/SimpleConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/SimpleConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/SimpleConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,59 +0,0 @@
-package org.jboss.webbeans.injectable;
-
-import java.lang.reflect.Constructor;
-import java.util.logging.Logger;
-
-import javax.webbeans.manager.Manager;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedConstructor;
-import org.jboss.webbeans.util.LoggerUtil;
-
-public class SimpleConstructor<T> extends Invokable<T, AnnotatedConstructor<T>> implements BeanConstructor<T, Constructor<T>>
-{
-
- public static final String LOGGER_NAME = "beanConstructor";
-
- private static Logger log = LoggerUtil.getLogger(LOGGER_NAME);
-
- private AnnotatedConstructor<T> constructor;
-
- public SimpleConstructor(AnnotatedConstructor<T> constructor)
- {
- super(constructor.getParameters());
- this.constructor = constructor;
- log.finest("Initialized metadata for " + constructor);
- }
-
- public T invoke(ManagerImpl manager)
- {
- return invoke(manager, null, getParameterValues(manager));
- }
-
- @Override
- public T invoke(Manager manager, Object instance, Object[] parameters)
- {
- try
- {
- log.finest("Creating new instance of " + constructor);
- return constructor.getAnnotatedConstructor().newInstance(parameters);
- }
- catch (Exception e)
- {
- throw new RuntimeException("Error instantiating " + constructor, e);
- }
- }
-
- @Override
- public T invoke(ManagerImpl manager, Object instance)
- {
- return invoke(manager, instance, getParameterValues(manager));
- }
-
- @Override
- public AnnotatedConstructor<T> getAnnotatedItem()
- {
- return constructor;
- }
-
-}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -4,6 +4,8 @@
import java.lang.reflect.Constructor;
import java.util.List;
+import org.jboss.webbeans.ManagerImpl;
+
/**
* AnnotatedType provides a uniform access to the annotations on an annotated
* class defined either in Java or XML
@@ -14,10 +16,12 @@
public interface AnnotatedConstructor<T> extends AnnotatedItem<T, Constructor<T>>
{
- public Constructor<T> getAnnotatedConstructor();
-
public List<AnnotatedParameter<Object>> getParameters();
public List<AnnotatedParameter<Object>> getAnnotatedParameters(Class<? extends Annotation> metaAnnotationType);
+
+ public T newInstance(ManagerImpl manager);
+
+ public Class<?> getDeclaringClass();
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedField.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedField.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedField.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -2,6 +2,8 @@
import java.lang.reflect.Field;
+import org.jboss.webbeans.ManagerImpl;
+
/**
* AnnotatedField provides a uniform access to the annotations on an annotated
* field
@@ -13,5 +15,11 @@
{
public Field getAnnotatedField();
+
+ public void inject(Object instance, ManagerImpl manager);
+
+ public Class<?> getDeclaringClass();
+
+ public String getPropertyName();
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -62,5 +62,7 @@
public boolean isStatic();
public boolean isFinal();
+
+ public String getName();
}
\ No newline at end of file
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedMethod.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedMethod.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedMethod.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -4,6 +4,8 @@
import java.lang.reflect.Method;
import java.util.List;
+import org.jboss.webbeans.ManagerImpl;
+
/**
* AnnotatedType provides a uniform access to the annotations on an annotated
* class defined either in Java or XML
@@ -20,4 +22,12 @@
public List<AnnotatedParameter<Object>> getAnnotatedParameters(Class<? extends Annotation> metaAnnotationType);
+ public T invoke(ManagerImpl manager, Object instance);
+
+ public T invoke(Object instance, Object...parameters);
+
+ public Class<?> getDeclaringClass();
+
+ public String getPropertyName();
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedParameter.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedParameter.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedParameter.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,6 +1,10 @@
package org.jboss.webbeans.introspector;
+import org.jboss.webbeans.ManagerImpl;
+
public interface AnnotatedParameter<T> extends AnnotatedItem<T, Object>
{
+ public T getValue(ManagerImpl manager);
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedItem.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedItem.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedItem.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -6,12 +6,16 @@
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
+import org.jboss.webbeans.ManagerImpl;
import org.jboss.webbeans.exceptions.TypesafeResolutionLocation;
import org.jboss.webbeans.introspector.AnnotatedItem;
+import org.jboss.webbeans.introspector.AnnotatedParameter;
import org.jboss.webbeans.util.Reflections;
import org.jboss.webbeans.util.Types;
@@ -55,6 +59,17 @@
}
return annotationSet;
}
+
+ protected static Object[] getParameterValues(List<AnnotatedParameter<Object>> parameters, ManagerImpl manager)
+ {
+ Object[] parameterValues = new Object[parameters.size()];
+ Iterator<AnnotatedParameter<Object>> iterator = parameters.iterator();
+ for (int i = 0; i < parameterValues.length; i++)
+ {
+ parameterValues[i] = iterator.next().getValue(manager);
+ }
+ return parameterValues;
+ }
public <A extends Annotation> A getAnnotation(Class<? extends A> annotationType)
{
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedMember.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedMember.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedMember.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -4,11 +4,16 @@
import java.lang.reflect.Member;
import java.util.Map;
+import javax.webbeans.BindingType;
+
+import org.jboss.webbeans.ManagerImpl;
import org.jboss.webbeans.util.Reflections;
public abstract class AbstractAnnotatedMember<T, S extends Member> extends AbstractAnnotatedItem<T, S>
{
+ private String name;
+
public AbstractAnnotatedMember(Map<Class<? extends Annotation>, Annotation> annotationMap)
{
super(annotationMap);
@@ -24,4 +29,23 @@
return Reflections.isFinal(getDelegate());
}
+ public T getValue(ManagerImpl manager)
+ {
+ return manager.getInstanceByType(getType(), getAnnotationsAsArray(BindingType.class));
+ }
+
+ public String getName()
+ {
+ if (name == null)
+ {
+ name = getDelegate().getName();
+ }
+ return name;
+ }
+
+ public Class<?> getDeclaringClass()
+ {
+ return getDelegate().getDeclaringClass();
+ }
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedType.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedType.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/AbstractAnnotatedType.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -23,4 +23,9 @@
return Reflections.isFinal(getDelegate());
}
+ public String getName()
+ {
+ return getDelegate().getName();
+ }
+
}
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableMethod.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableMethod.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableMethod.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableMethod.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,63 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.util.List;
+
+import javax.webbeans.manager.Manager;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.introspector.AnnotatedMethod;
+
+public abstract class ForwardingInjectableMethod<T> extends InjectableMethod<T>
+{
+
+ @Override
+ public boolean equals(Object obj)
+ {
+ return delegate().equals(obj);
+ }
+
+ @Override
+ public AnnotatedMethod<T> getAnnotatedItem()
+ {
+ return delegate().getAnnotatedItem();
+ }
+
+ @Override
+ public List<InjectableParameter<Object>> getParameters()
+ {
+ return delegate().getParameters();
+ }
+
+ @Override
+ protected Object[] getParameterValues(ManagerImpl manager)
+ {
+ return delegate().getParameterValues(manager);
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return delegate().hashCode();
+ }
+
+ @Override
+ public T invoke(Manager manager, Object instance, Object[] parameters)
+ {
+ return delegate().invoke(manager, instance, parameters);
+ }
+
+ @Override
+ public T invoke(ManagerImpl manager, Object instance)
+ {
+ return delegate().invoke(manager, instance);
+ }
+
+ @Override
+ public String toString()
+ {
+ return delegate().toString();
+ }
+
+ protected abstract InjectableMethod<T> delegate();
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableMethod.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableParameter.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ForwardingInjectableParameter.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableParameter.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableParameter.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,41 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Set;
+
+import javax.webbeans.manager.Bean;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.ModelManager;
+
+public abstract class ForwardingInjectableParameter<T> extends InjectableParameter<T>
+{
+
+ protected abstract InjectableParameter<? extends T> delegate();
+
+ @Override
+ public Set<Annotation> getBindingTypes()
+ {
+ return delegate().getBindingTypes();
+ }
+
+ @Override
+ public Set<Bean<?>> getMatchingBeans(List<Bean<?>> possibleBeans, ModelManager modelManager)
+ {
+ return delegate().getMatchingBeans(possibleBeans, modelManager);
+ }
+
+ @Override
+ public Class<? extends T> getType()
+ {
+ return delegate().getType();
+ }
+
+ @Override
+ public T getValue(ManagerImpl manager)
+ {
+ return delegate().getValue(manager);
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ForwardingInjectableParameter.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Injectable.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Injectable.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Injectable.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Injectable.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,155 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.webbeans.BindingType;
+import javax.webbeans.manager.Bean;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.ModelManager;
+import org.jboss.webbeans.bindings.CurrentAnnotationLiteral;
+import org.jboss.webbeans.introspector.AnnotatedItem;
+import org.jboss.webbeans.model.BindingTypeModel;
+
+/**
+ * Abstraction of java reflection for Web Beans, represent's something that can
+ * be injected
+ *
+ * @author Pete Muir
+ *
+ */
+public abstract class Injectable<T, S>
+{
+
+ private static final Annotation[] DEFAULT_BINDING_ARRAY = {new CurrentAnnotationLiteral()};
+ private static final Set<Annotation> DEFAULT_BINDING = new HashSet<Annotation>(Arrays.asList(DEFAULT_BINDING_ARRAY));
+
+ private AnnotatedItem<T, S> annotatedItem;
+
+ private boolean useDefaultBinding;
+
+ public Injectable(AnnotatedItem<T, S> annotatedItem)
+ {
+ this.annotatedItem = annotatedItem;
+ if (annotatedItem.getAnnotations(BindingType.class).size() == 0)
+ {
+ useDefaultBinding = true;
+ }
+ }
+
+ public Set<Annotation> getBindingTypes()
+ {
+ if (useDefaultBinding)
+ {
+ return DEFAULT_BINDING;
+ }
+ else
+ {
+ return annotatedItem.getAnnotations(BindingType.class);
+ }
+ }
+
+ public Annotation[] getBindingTypesAsArray()
+ {
+ if (useDefaultBinding)
+ {
+ return DEFAULT_BINDING_ARRAY;
+ }
+ else
+ {
+ return annotatedItem.getAnnotationsAsArray(BindingType.class);
+ }
+ }
+
+ protected Injectable() {}
+
+ @Override
+ public String toString()
+ {
+ return getClass().getSimpleName() + "[" + getAnnotatedItem().toString() + "]";
+ }
+
+ public T getValue(ManagerImpl manager)
+ {
+ return manager.getInstanceByType(getType(), getBindingTypesAsArray());
+ }
+
+ public Class<? extends T> getType()
+ {
+ return annotatedItem.getType();
+ }
+
+ public AnnotatedItem<T, S> getAnnotatedItem()
+ {
+ return annotatedItem;
+ }
+
+ public Set<Bean<?>> getMatchingBeans(List<Bean<?>> beans, ModelManager modelManager)
+ {
+ Set<Bean<?>> resolvedBeans = new HashSet<Bean<?>>();
+ for (Bean<?> bean : beans)
+ {
+ if (getAnnotatedItem().isAssignableFrom(bean.getTypes()) && containsAllBindingBindingTypes(bean.getBindingTypes(), modelManager))
+ {
+ resolvedBeans.add(bean);
+ }
+ }
+ return resolvedBeans;
+ }
+
+ @Override
+ public boolean equals(Object other)
+ {
+ // TODO Do we need to check the other direction too?
+ if (other instanceof Injectable)
+ {
+ Injectable<?, ?> that = (Injectable<?, ?>) other;
+ return this.getAnnotatedItem().isAssignableFrom(that.getAnnotatedItem()) &&
+ that.getBindingTypes().equals(this.getBindingTypes());
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ @Override
+ public int hashCode()
+ {
+ // TODO Implement this!
+ return 0;
+ }
+
+ private boolean containsAllBindingBindingTypes(Set<Annotation> bindingTypes, ModelManager modelManager)
+ {
+ for (Annotation bindingType : getBindingTypes())
+ {
+ BindingTypeModel<?> bindingTypeModel = modelManager.getBindingTypeModel(bindingType.annotationType());
+ if (bindingTypeModel.getNonBindingTypes().size() > 0)
+ {
+ boolean matchFound = false;
+ for (Annotation otherBindingType : bindingTypes)
+ {
+ if (bindingTypeModel.isEqual(bindingType, otherBindingType))
+ {
+ matchFound = true;
+ }
+ }
+ if (!matchFound)
+ {
+ return false;
+ }
+ }
+ else if (!bindingTypes.contains(bindingType))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Injectable.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableField.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableField.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableField.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableField.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,33 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.lang.reflect.Field;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.introspector.AnnotatedField;
+import org.jboss.webbeans.util.Reflections;
+
+/**
+ * Abstraction of Java Reflection
+ *
+ * @author Pete Muir
+ *
+ */
+public class InjectableField<T> extends Injectable<T, Field>
+{
+
+ public InjectableField(Field field)
+ {
+ super(new SimpleAnnotatedField<T>(field));
+ }
+
+ public InjectableField(AnnotatedField<T> annotatedField)
+ {
+ super(annotatedField);
+ }
+
+ public void inject(Object instance, ManagerImpl manager)
+ {
+ Reflections.setAndWrap(getAnnotatedItem().getDelegate(), instance, getValue(manager));
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableField.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableMethod.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableMethod.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableMethod.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableMethod.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,49 @@
+package org.jboss.webbeans.introspector.impl;
+
+import javax.webbeans.manager.Manager;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.introspector.AnnotatedMethod;
+
+public class InjectableMethod<T> extends Invokable<T, AnnotatedMethod<T>>
+{
+
+ private AnnotatedMethod<T> method;
+
+ protected InjectableMethod(){}
+
+ public InjectableMethod(java.lang.reflect.Method method)
+ {
+ this(new SimpleAnnotatedMethod<T>(method));
+ }
+
+ public InjectableMethod(AnnotatedMethod<T> annotatedMethod)
+ {
+ super(annotatedMethod.getParameters());
+ this.method = annotatedMethod;
+ }
+
+
+ public T invoke(ManagerImpl manager, Object instance)
+ {
+ return invoke(manager, instance, getParameterValues(manager));
+ }
+
+ public T invoke(Manager container, Object instance, Object[] parameters)
+ {
+ try
+ {
+ return (T) method.getAnnotatedMethod().invoke(instance, parameters);
+ }
+ catch (Exception e)
+ {
+ throw new RuntimeException("Unable to invoke " + method + " on " + instance, e);
+ }
+ }
+
+ public AnnotatedMethod<T> getAnnotatedItem()
+ {
+ return method;
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableMethod.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableParameter.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableParameter.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableParameter.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableParameter.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,30 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.lang.annotation.Annotation;
+
+import org.jboss.webbeans.bindings.CurrentAnnotationLiteral;
+import org.jboss.webbeans.introspector.AnnotatedParameter;
+
+public class InjectableParameter<T> extends Injectable<T, Object>
+{
+
+ private static Annotation[] currentBinding = {new CurrentAnnotationLiteral()};
+
+ protected InjectableParameter() {}
+
+ public InjectableParameter(Annotation[] bindingTypes, Class<T> type)
+ {
+ super(new SimpleAnnotatedParameter<T>(bindingTypes, type));
+ }
+
+ public InjectableParameter(AnnotatedParameter<T> annotatedParameter)
+ {
+ super(annotatedParameter);
+ }
+
+ public InjectableParameter(Class<T> type)
+ {
+ this(currentBinding, type);
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableParameter.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableWrapper.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/InjectableWrapper.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableWrapper.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableWrapper.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,46 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Set;
+
+import javax.webbeans.manager.Bean;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.ModelManager;
+
+public class InjectableWrapper<T, S> extends Injectable<T, S>
+{
+
+ private Injectable<T, S> delegate;
+
+ public InjectableWrapper(Injectable<T, S> delegate)
+ {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public Set<Annotation> getBindingTypes()
+ {
+ return delegate.getBindingTypes();
+ }
+
+ @Override
+ public Set<Bean<?>> getMatchingBeans(List<Bean<?>> possibleBeans, ModelManager modelManager)
+ {
+ return delegate.getMatchingBeans(possibleBeans, modelManager);
+ }
+
+ @Override
+ public Class<? extends T> getType()
+ {
+ return delegate.getType();
+ }
+
+ @Override
+ public T getValue(ManagerImpl manager)
+ {
+ return delegate.getValue(manager);
+ }
+
+}
\ No newline at end of file
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/InjectableWrapper.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Invokable.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/Invokable.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Invokable.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Invokable.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,50 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.webbeans.manager.Manager;
+
+import org.jboss.webbeans.ManagerImpl;
+import org.jboss.webbeans.introspector.AnnotatedParameter;
+
+public abstract class Invokable<T, S>
+{
+
+ private List<InjectableParameter<Object>> parameters;
+
+ protected Invokable() {}
+
+ public Invokable(List<AnnotatedParameter<Object>> parameters)
+ {
+ this.parameters = new ArrayList<InjectableParameter<Object>>();
+ for (AnnotatedParameter<Object> parameter : parameters)
+ {
+ this.parameters.add(new InjectableParameter<Object>(parameter));
+ }
+ }
+
+ public abstract S getAnnotatedItem();
+
+ protected Object[] getParameterValues(ManagerImpl manager)
+ {
+ Object[] parameterValues = new Object[parameters.size()];
+ Iterator<InjectableParameter<Object>> iterator = parameters.iterator();
+ for (int i = 0; i < parameterValues.length; i++)
+ {
+ parameterValues[i] = iterator.next().getValue(manager);
+ }
+ return parameterValues;
+ }
+
+ public List<InjectableParameter<Object>> getParameters()
+ {
+ return parameters;
+ }
+
+ public abstract T invoke(Manager container, Object instance, Object[] parameters);
+
+ public abstract T invoke(ManagerImpl container, Object instance);
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/Invokable.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Copied: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ResolverInjectable.java (from rev 272, ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/injectable/ResolverInjectable.java)
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ResolverInjectable.java (rev 0)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ResolverInjectable.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -0,0 +1,53 @@
+package org.jboss.webbeans.introspector.impl;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+
+import javax.webbeans.BindingType;
+import javax.webbeans.DuplicateBindingTypeException;
+import javax.webbeans.TypeLiteral;
+
+import org.jboss.webbeans.ModelManager;
+
+/**
+ * TODO Rename this to something which implies it only ever used for resolution
+ * @author Pete Muir
+ *
+ */
+public class ResolverInjectable<T> extends Injectable<T, Object>
+{
+
+ public ResolverInjectable(SimpleAnnotatedItem<T, Object> annotatedItem, ModelManager modelManager)
+ {
+ super(annotatedItem);
+ for (Annotation annotation : annotatedItem.getAnnotations())
+ {
+ if (!modelManager.getBindingTypeModel(annotation.annotationType()).isValid())
+ {
+ throw new IllegalArgumentException("Not a binding type " + annotation);
+ }
+ }
+ if (annotatedItem.getActualAnnotations().length > annotatedItem.getAnnotations(BindingType.class).size())
+ {
+ throw new DuplicateBindingTypeException(getAnnotatedItem().toString());
+ }
+
+
+ }
+
+ public ResolverInjectable(Class<T> type, Annotation[] bindingTypes, ModelManager modelManager)
+ {
+ this(new SimpleAnnotatedItem<T, Object>(bindingTypes, type), modelManager);
+ }
+
+ public ResolverInjectable(Class<T> type, Annotation[] bindingTypes, ModelManager modelManager, Type ... actualTypeArguments)
+ {
+ this(new SimpleAnnotatedItem<T, Object>(bindingTypes, type, actualTypeArguments), modelManager);
+ }
+
+ public ResolverInjectable(TypeLiteral<T> apiType, Annotation[] bindingTypes, ModelManager modelManager)
+ {
+ this(new SimpleAnnotatedItem<T, Object>(bindingTypes, apiType), modelManager);
+ }
+
+}
Property changes on: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/ResolverInjectable.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedConstructor.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedConstructor.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedConstructor.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -2,12 +2,16 @@
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import javax.webbeans.ExecutionException;
+
+import org.jboss.webbeans.ManagerImpl;
import org.jboss.webbeans.introspector.AnnotatedConstructor;
import org.jboss.webbeans.introspector.AnnotatedParameter;
@@ -126,6 +130,30 @@
return annotatedParameters.get(annotationType);
}
+ public T newInstance(ManagerImpl manager)
+ {
+ try
+ {
+ return getDelegate().newInstance(getParameterValues(parameters, manager));
+ }
+ catch (IllegalArgumentException e)
+ {
+ throw new ExecutionException(e);
+ }
+ catch (InstantiationException e)
+ {
+ throw new ExecutionException(e);
+ }
+ catch (IllegalAccessException e)
+ {
+ throw new ExecutionException(e);
+ }
+ catch (InvocationTargetException e)
+ {
+ throw new ExecutionException(e);
+ }
+ }
+
@Override
public boolean equals(Object other)
{
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedField.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedField.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedField.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -4,7 +4,9 @@
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
+import org.jboss.webbeans.ManagerImpl;
import org.jboss.webbeans.introspector.AnnotatedField;
+import org.jboss.webbeans.util.Reflections;
public class SimpleAnnotatedField<T> extends AbstractAnnotatedMember<T, Field> implements AnnotatedField<T>
{
@@ -44,4 +46,14 @@
return actualTypeArguments;
}
+ public void inject(Object instance, ManagerImpl manager)
+ {
+ Reflections.setAndWrap(getDelegate(), instance, getValue(manager));
+ }
+
+ public String getPropertyName()
+ {
+ return getName();
+ }
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedItem.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedItem.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedItem.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -94,5 +94,10 @@
{
return false;
}
+
+ public String getName()
+ {
+ throw new IllegalArgumentException("Unable to determine name");
+ }
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedMethod.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedMethod.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedMethod.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -9,8 +9,10 @@
import java.util.List;
import java.util.Map;
+import org.jboss.webbeans.ManagerImpl;
import org.jboss.webbeans.introspector.AnnotatedMethod;
import org.jboss.webbeans.introspector.AnnotatedParameter;
+import org.jboss.webbeans.util.Reflections;
public class SimpleAnnotatedMethod<T> extends AbstractAnnotatedMember<T, Method> implements AnnotatedMethod<T>
{
@@ -21,6 +23,8 @@
private List<AnnotatedParameter<Object>> parameters;
private Map<Class<? extends Annotation>, List<AnnotatedParameter<Object>>> annotatedParameters;
+
+ private String propertyName;
public SimpleAnnotatedMethod(Method method)
{
@@ -151,4 +155,27 @@
return getDelegate().hashCode();
}
+ public T invoke(ManagerImpl manager, Object instance)
+ {
+ return (T) Reflections.invokeAndWrap(getDelegate(), instance, getParameterValues(parameters, manager));
+ }
+
+ public T invoke(Object instance, Object... parameters)
+ {
+ return (T) Reflections.invokeAndWrap(getDelegate(), instance, parameters);
+ }
+
+ public String getPropertyName()
+ {
+ if (propertyName == null)
+ {
+ propertyName = Reflections.getPropertyName(getDelegate());
+ if (propertyName == null)
+ {
+ propertyName = getName();
+ }
+ }
+ return propertyName;
+ }
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedParameter.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedParameter.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/impl/SimpleAnnotatedParameter.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -3,6 +3,9 @@
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
+import javax.webbeans.BindingType;
+
+import org.jboss.webbeans.ManagerImpl;
import org.jboss.webbeans.introspector.AnnotatedParameter;
public class SimpleAnnotatedParameter<T> extends AbstractAnnotatedItem<T, Object> implements AnnotatedParameter<T>
@@ -44,5 +47,14 @@
return _static;
}
+ public T getValue(ManagerImpl manager)
+ {
+ return manager.getInstanceByType(getType(), getAnnotationsAsArray(BindingType.class));
+ }
+ public String getName()
+ {
+ throw new IllegalArgumentException("Unable to determine name of parameter");
+ }
+
}
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/AnnotationModel.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/AnnotationModel.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/AnnotationModel.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -40,7 +40,7 @@
public Class<T> getType()
{
- return annotatedAnnotation.getDelegate();
+ return annotatedAnnotation.getType();
}
protected abstract Class<? extends Annotation> getMetaAnnotation();
Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/BindingTypeModel.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/BindingTypeModel.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/BindingTypeModel.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -95,8 +95,8 @@
{
if (!nonBindingTypes.contains(annotatedMethod))
{
- Object thisValue = Reflections.invokeAndWrap(annotatedMethod.getDelegate(), instance);
- Object thatValue = Reflections.invokeAndWrap(annotatedMethod.getDelegate(), other);
+ Object thisValue = annotatedMethod.invoke(instance);
+ Object thatValue = annotatedMethod.invoke(other);
if (!thisValue.equals(thatValue))
{
return false;
Deleted: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/MergedStereotypesModel.java
===================================================================
--- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/MergedStereotypesModel.java 2008-11-08 18:02:13 UTC (rev 283)
+++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/model/MergedStereotypesModel.java 2008-11-09 07:52:05 UTC (rev 284)
@@ -1,105 +0,0 @@
-package org.jboss.webbeans.model;
-
-import java.lang.annotation.Annotation;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import javax.webbeans.Stereotype;
-
-import org.jboss.webbeans.ManagerImpl;
-import org.jboss.webbeans.introspector.AnnotatedItem;
-
-/**
- * Meta model for the merged stereotype for a bean
- * @author pmuir
- *
- */
-public class MergedStereotypesModel<T, E>
-{
-
- private Map<Class<? extends Annotation>, Annotation> possibleDeploymentTypes;
- private Set<Annotation> possibleScopeTypes;
- private boolean beanNameDefaulted;
- private Set<Class<?>> requiredTypes;
- private Set<Class<? extends Annotation>> supportedScopes;
- private boolean isDeclaredInXml;
-
- public MergedStereotypesModel(AnnotatedItem<T, E> annotatedItem, AnnotatedItem<T, E> xmlAnnotatedItem, ManagerImpl manager)
- {
- possibleDeploymentTypes = new HashMap<Class<? extends Annotation>, Annotation>();
- possibleScopeTypes = new HashSet<Annotation>();
- requiredTypes = new HashSet<Class<?>>();
- supportedScopes = new HashSet<Class<? extends Annotation>>();
-
- if (xmlAnnotatedItem != null && xmlAnnotatedItem.getAnnotations(Stereotype.class).size() > 0)
- {
- merge(xmlAnnotatedItem.getAnnotations(Stereotype.class), manager);
- isDeclaredInXml = true;
- }
- else if (annotatedItem != null)
- {
- merge(annotatedItem.getAnnotations(Stereotype.class), manager);
- }
-
- }
-
- private void merge(Set<Annotation> stereotypeAnnotations, ManagerImpl manager)
- {
- for (Annotation stereotypeAnnotation : stereotypeAnnotations)
- {
- // Retrieve and merge all metadata from stereotypes
- StereotypeModel<?> stereotype = manager.getModelManager().getStereotype(stereotypeAnnotation.annotationType());
- if (stereotype == null)
- {
- throw new NullPointerException("Stereotype " + stereotypeAnnotation + " not registered with container");
- }
- if (stereotype.getDefaultDeploymentType() != null)
- {
- possibleDeploymentTypes.put(stereotype.getDefaultDeploymentType().annotationType(), stereotype.getDefaultDeploymentType());
- }
- if (stereotype.getDefaultScopeType() != null)
- {
- possibleScopeTypes.add(stereotype.getDefaultScopeType());
- }
- requiredTypes.addAll(stereotype.getRequiredTypes());
- supportedScopes.addAll(stereotype.getSupportedScopes());
- if (stereotype.isBeanNameDefaulted())
- {
- beanNameDefaulted = true;
- }
- }
- }
-
- public Map<Class<? extends Annotation>, Annotation> getPossibleDeploymentTypes()
- {
- return possibleDeploymentTypes;
- }
-
- public Set<Annotation> getPossibleScopeTypes()
- {
- return possibleScopeTypes;
- }
-
- public boolean isBeanNameDefaulted()
- {
- return beanNameDefaulted;
- }
-
- public Set<Class<?>> getRequiredTypes()
- {
- return requiredTypes;
- }
-
- public Set<Class<? extends Annotation>> getSupportedScopes()
- {
- return supportedScopes;
- }
-
- public boolean isDeclaredInXml()
- {
- return isDeclaredInXml;
- }
-
-}
More information about the weld-commits
mailing list