Lots of tiding up and javadoc

git-svn-id: http://anonsvn.jboss.org/repos/weld/ri/trunk@332 1c488680-804c-0410-94cd-c6b725194a0e

webbeans-ri/src/main/java/org/jboss/webbeans/ModelManager.java → webbeans-ri/src/main/java/org/jboss/webbeans/MetaDataCache.java

@@ -12,7 +12,7 @@
 
 import com.google.common.collect.ForwardingMap;
 
-public class ModelManager
+public class MetaDataCache
 {
 
    @SuppressWarnings("unchecked")

webbeans-ri/src/main/java/org/jboss/webbeans/ResolutionManager.java → webbeans-ri/src/main/java/org/jboss/webbeans/Resolver.java

@@ -1,6 +1,7 @@
 package org.jboss.webbeans;
 
 import java.lang.annotation.Annotation;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -20,9 +21,19 @@
 
 import com.google.common.collect.ForwardingMap;
 
-public class ResolutionManager
+/**
+ * Implementation of Web Beans type safe and name based bean resolution
+ * @author Pete Muir
+ *
+ */
+public class Resolver
 {
 
+   /**
+    * Extension of an element which bases equality not only on type, but also
+    * on binding type
+    *
+    */
    private abstract class ResolvableAnnotatedItem<T, S> extends ForwardingAnnotatedItem<T, S>
    {
 
@@ -52,6 +63,9 @@ public int hashCode()
 
    // TODO Why can't we generify Set?
 
+   /**
+    * Type safe map for caching annotation metadata
+    */
    @SuppressWarnings("unchecked")
    private class AnnotatedItemMap extends ForwardingMap<AnnotatedItem<?, ?>, Set>
    {
@@ -77,29 +91,32 @@ public <T> Set<Bean<T>> get(AnnotatedItem<T, ?> key)
 
    }
 
-
    private AnnotatedItemMap resolvedInjectionPoints;
    private Set<AnnotatedItem<?, ?>> injectionPoints;
 
    private Map<String, Set<Bean<?>>> resolvedNames;
 
    private ManagerImpl manager;
 
-   public ResolutionManager(ManagerImpl manager)
+   public Resolver(ManagerImpl manager)
    {
+      this.manager = manager;
       this.injectionPoints = new HashSet<AnnotatedItem<?,?>>();
       this.resolvedInjectionPoints = new AnnotatedItemMap();
-      this.manager = manager;
    }
 
-   public <T, S> void addInjectionPoint(final AnnotatedItem<T, S> element)
+   /**
+    * Add multiple injection points for later resolving using 
+    * {@link #registerInjectionPoint(AnnotatedItem)}. Useful during bootstrap.
+    */
+   public void addInjectionPoints(Collection<AnnotatedItem<?, ?>> elements)
    {
-      injectionPoints.add(element);
+      injectionPoints.addAll(elements);
    }
 
    private <T, S> void registerInjectionPoint(final AnnotatedItem<T, S> element)
    {
-      Set<Bean<?>> beans = retainHighestPrecedenceBeans(getMatchingBeans(element, manager.getBeans(), manager.getModelManager()), manager.getEnabledDeploymentTypes());
+      Set<Bean<?>> beans = retainHighestPrecedenceBeans(getMatchingBeans(element, manager.getBeans(), manager.getMetaDataCache()), manager.getEnabledDeploymentTypes());
       if (element.getType().isPrimitive())
       {
          for (Bean<?> bean : beans)
@@ -122,12 +139,19 @@ public AnnotatedItem<T, S> delegate()
       }, beans);
    }
 
+   /**
+    * Reset all cached injection points. You must reset all cached injection
+    * points when you add a bean to the manager
+    */
    public void clear()
    {
       resolvedInjectionPoints = new AnnotatedItemMap();
       resolvedNames = new HashMap<String, Set<Bean<?>>>();
    }
 
+   /**
+    * Resolve all injection points added using {@link #addInjectionPoints(Collection)}
+    */
    public void resolveInjectionPoints()
    {
       for (AnnotatedItem<?, ?> injectable : injectionPoints)
@@ -136,6 +160,9 @@ public void resolveInjectionPoints()
       }
    }
 
+   /**
+    * Get the possible beans for the given element
+    */
    public <T, S> Set<Bean<T>> get(final AnnotatedItem<T, S> key)
    {
       Set<Bean<T>> beans = new HashSet<Bean<T>>();
@@ -168,6 +195,9 @@ public AnnotatedItem<T, S> delegate()
       return Collections.unmodifiableSet(beans);
    }
 
+   /**
+    * Get the possible beans for the given name
+    */
    public Set<Bean<?>> get(String name)
    {
       Set<Bean<?>> beans;
@@ -223,24 +253,24 @@ private static Set<Bean<?>> retainHighestPrecedenceBeans(Set<Bean<?>> beans, Lis
       }
    }
 
-   private static Set<Bean<?>> getMatchingBeans(AnnotatedItem<?, ?> element, List<Bean<?>> beans, ModelManager modelManager)
+   private static Set<Bean<?>> getMatchingBeans(AnnotatedItem<?, ?> element, List<Bean<?>> beans, MetaDataCache metaDataCache)
    {
       Set<Bean<?>> resolvedBeans = new HashSet<Bean<?>>();
       for (Bean<?> bean : beans)
       {
-         if (element.isAssignableFrom(bean.getTypes()) && containsAllBindingBindingTypes(element, bean.getBindingTypes(), modelManager))
+         if (element.isAssignableFrom(bean.getTypes()) && containsAllBindingBindingTypes(element, bean.getBindingTypes(), metaDataCache))
          {
             resolvedBeans.add(bean);
          }
       }
       return resolvedBeans;
    }
 
-   private static boolean containsAllBindingBindingTypes(AnnotatedItem<?, ?> element, Set<Annotation> bindingTypes, ModelManager modelManager)
+   private static boolean containsAllBindingBindingTypes(AnnotatedItem<?, ?> element, Set<Annotation> bindingTypes, MetaDataCache metaDataCache)
    {
       for (Annotation bindingType : element.getBindingTypes())
       {
-         BindingTypeModel<?> bindingTypeModel = modelManager.getBindingTypeModel(bindingType.annotationType());
+         BindingTypeModel<?> bindingTypeModel = metaDataCache.getBindingTypeModel(bindingType.annotationType());
          if (bindingTypeModel.getNonBindingTypes().size() > 0)
          {
             boolean matchFound = false;

webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java

@@ -33,7 +33,7 @@
 
 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 Class<? extends Annotation> getDeploymentType(List<Class<? extends Annotation>> enabledDeploymentTypes, Map<Class<? extends Annotation>, Annotation> possibleDeploymentTypes)
@@ -42,7 +42,7 @@ public static Class<? extends Annotation> getDeploymentType(List<Class<? extends
       {
          if (possibleDeploymentTypes.containsKey((enabledDeploymentTypes.get(i))))
          {
-            return enabledDeploymentTypes.get(i); 
+            return enabledDeploymentTypes.get(i);
          }
       }
       return null;
@@ -79,7 +79,7 @@ protected void init()
       mergedStereotypes = new MergedStereotypes<T, E>(getAnnotatedItem().getMetaAnnotations(Stereotype.class), manager);
       initType();
       initPrimitive();
-      log.debug("Building Web Bean bean metadata for " +  getType());
+      log.debug("Building Web Bean bean metadata for " + getType());
       initBindingTypes();
       initName();
       initDeploymentType();
@@ -107,7 +107,7 @@ protected void initBindingTypes()
             this.bindingTypes.addAll(bindingTypes);
             log.trace("Using binding types " + this.bindingTypes + " specified in XML and specialized type");
          }
-         else 
+         else
          {
             log.trace("Using binding types " + this.bindingTypes + " specified in XML");
          }
@@ -134,7 +134,7 @@ else if (bindingTypes.size() == 0)
          return;
       }
    }
-
+   
    protected void initDeploymentType()
    {
       if (isDefinedInXml())
@@ -147,7 +147,7 @@ protected void initDeploymentType()
 
          if (xmlDeploymentTypes.size() == 1)
          {
-            this.deploymentType = xmlDeploymentTypes.iterator().next().annotationType(); 
+            this.deploymentType = xmlDeploymentTypes.iterator().next().annotationType();
             log.trace("Deployment type " + deploymentType + " specified in XML");
             return;
          }
@@ -179,10 +179,10 @@ protected void initDeploymentType()
       log.trace("Using default @Production deployment type");
       return;
    }
-
+   
    protected void initInjectionPoints()
    {
-      injectionPoints = new HashSet<AnnotatedItem<?,?>>();
+      injectionPoints = new HashSet<AnnotatedItem<?, ?>>();
       if (removeMethod != null)
       {
          for (AnnotatedParameter<?> injectable : removeMethod.getParameters())
@@ -191,14 +191,14 @@ protected void initInjectionPoints()
          }
       }
    }
-
+   
    protected void initName()
    {
       boolean beanNameDefaulted = false;
       if (isDefinedInXml())
       {
          boolean xmlSpecialization = false;
-         if (xmlSpecialization) 
+         if (xmlSpecialization)
          {
             throw new DefinitionException("Name specified for specialized bean (declared in XML)");
          }
@@ -251,12 +251,12 @@ else if (specialization)
          return;
       }
    }
-
+   
    protected void initPrimitive()
    {
       this.primitive = Reflections.isPrimitive(getType());
    }
-
+   
    /**
     * Return the scope of the bean
     */
@@ -337,12 +337,12 @@ protected void bindInterceptors()
    }
 
    protected abstract AnnotatedItem<T, E> getAnnotatedItem();
-
+   
    public Set<Annotation> getBindingTypes()
    {
       return bindingTypes;
    }
-
+   
    protected Type getDeclaredBeanType()
    {
       if (declaredBeanType == null)
@@ -359,7 +359,7 @@ protected Type getDeclaredBeanType()
       }
       return declaredBeanType;
    }
-
+   
    protected abstract String getDefaultName();
 
    public Class<? extends Annotation> getDeploymentType()
@@ -387,24 +387,22 @@ public String getName()
    {
       return name;
    }
-
+   
    public AnnotatedMethod<?> getRemoveMethod()
    {
       return removeMethod;
    }
-
+   
    public Class<? extends Annotation> getScopeType()
    {
       return scopeType;
    }
 
-   protected AbstractBean<? extends T, E> getSpecializedType() 
+   protected AbstractBean<? extends T, E> getSpecializedType()
    {
       throw new UnsupportedOperationException();
    }
 
-
-
    public Class<T> getType()
    {
       return type;
@@ -435,7 +433,7 @@ public boolean isAssignableFrom(AnnotatedItem<?, ?> annotatedItem)
    {
       return this.getAnnotatedItem().isAssignableFrom(annotatedItem);
    }
-
+   
    protected boolean isDefinedInXml()
    {
       return false;
@@ -458,5 +456,5 @@ public boolean isSerializable()
       // TODO Auto-generated method stub
       return false;
    }
-
+   
 }

webbeans-ri/src/main/java/org/jboss/webbeans/bean/EnterpriseBean.java

@@ -109,14 +109,14 @@ private void checkSpecialization()
       }
       if (!isDefinedInXml())
       {
-         if (!getManager().getModelManager().getEjbMetaData(getAnnotatedItem().getSuperclass().getType()).isEjb())
+         if (!getManager().getMetaDataCache().getEjbMetaData(getAnnotatedItem().getSuperclass().getType()).isEjb())
          {
             throw new DefinitionException("Annotation defined specializing EJB must have EJB superclass");
          }
       } 
       else
       {
-         if (getManager().getModelManager().getEjbMetaData(getAnnotatedItem().getSuperclass().getType()).isEjb())
+         if (getManager().getMetaDataCache().getEjbMetaData(getAnnotatedItem().getSuperclass().getType()).isEjb())
          {
             throw new DefinitionException("XML defined specializing EJB must have annotation defined EJB implementation");
          }

webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java

@@ -37,7 +37,7 @@ 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());
+         StereotypeModel<?> stereotype = manager.getMetaDataCache().getStereotype(stereotypeAnnotation.annotationType());
          if (stereotype == null)
          {
             throw new IllegalStateException("Stereotype " + stereotypeAnnotation + " not registered with container");

webbeans-ri/src/main/java/org/jboss/webbeans/bootstrap/Bootstrap.java

@@ -9,11 +9,10 @@
 import java.util.List;
 import java.util.Set;
 
-import javax.webbeans.manager.Bean;
-
 import org.jboss.webbeans.ManagerImpl;
 import org.jboss.webbeans.bean.AbstractBean;
 import org.jboss.webbeans.bean.AbstractClassBean;
+import org.jboss.webbeans.bean.ProducerMethodBean;
 import org.jboss.webbeans.bootstrap.spi.WebBeanDiscovery;
 import org.jboss.webbeans.introspector.AnnotatedMethod;
 import org.jboss.webbeans.log.LogProvider;
@@ -96,6 +95,7 @@ public void registerBeans(Iterable<Class<?>> classes)
    {
       Set<AbstractBean<?, ?>> beans = createBeans(classes);
       manager.setBeans(beans);
+      manager.getResolver().resolveInjectionPoints();
    }
 
    /**
@@ -114,7 +114,7 @@ public void registerBeans(Iterable<Class<?>> classes)
       for (Class<?> clazz : classes)
       {
          AbstractClassBean<?> bean;
-         if (manager.getModelManager().getEjbMetaData(clazz).isEjb())
+         if (manager.getMetaDataCache().getEjbMetaData(clazz).isEjb())
          {
             bean = createEnterpriseBean(clazz, manager);
          }
@@ -123,9 +123,12 @@ public void registerBeans(Iterable<Class<?>> classes)
             bean = createSimpleBean(clazz, manager);
          }
          beans.add(bean);
+         manager.getResolver().addInjectionPoints(bean.getInjectionPoints());
          for (AnnotatedMethod<Object> producerMethod : bean.getProducerMethods())
          {
-            beans.add(createProducerMethodBean(producerMethod.getType(), producerMethod, manager, bean));
+            ProducerMethodBean<?> producerMethodBean = createProducerMethodBean(producerMethod.getType(), producerMethod, manager, bean);
+            beans.add(producerMethodBean);
+            manager.getResolver().addInjectionPoints(producerMethodBean.getInjectionPoints());
          }
 
       }