[weld-commits] Weld SVN: r6006 - in extensions/trunk: core/src/main/java/org/jboss/weld/extensions/beans and 2 other directories.

weld-commits at lists.jboss.org weld-commits at lists.jboss.org
Fri Mar 5 07:18:52 EST 2010


Author: swd847
Date: 2010-03-05 07:18:51 -0500 (Fri, 05 Mar 2010)
New Revision: 6006

Added:
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/BeanLifecycle.java
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBean.java
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBeanBuilder.java
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/PassivationCapableCustomBean.java
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/SimpleBeanLifecycle.java
   extensions/trunk/core/src/main/java/org/jboss/weld/extensions/util/AnnotatedTypeUtils.java
Modified:
   extensions/trunk/genericbeans/src/main/java/org/jboss/weld/extensions/genericbeans/GenericExtension.java
Log:
Added Custom bean implementation



Added: extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/BeanLifecycle.java
===================================================================
--- extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/BeanLifecycle.java	                        (rev 0)
+++ extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/BeanLifecycle.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -0,0 +1,11 @@
+package org.jboss.weld.extensions.beans;
+
+import javax.enterprise.context.spi.CreationalContext;
+
+public interface BeanLifecycle<T>
+{
+   public T create(CustomBean<T> bean, CreationalContext<T> arg0);
+
+   public void destroy(CustomBean<T> bean, T arg0, CreationalContext<T> arg1);
+
+}

Added: extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBean.java
===================================================================
--- extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBean.java	                        (rev 0)
+++ extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBean.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -0,0 +1,101 @@
+package org.jboss.weld.extensions.beans;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.enterprise.inject.spi.InjectionTarget;
+
+public class CustomBean<T> implements Bean<T>
+{
+   final Class<?> beanClass;
+   final InjectionTarget<T> injectionTarget;
+   final String name;
+   final Set<Annotation> qualifiers;
+   final Class<? extends Annotation> scope;
+   final Set<Class<? extends Annotation>> stereotypes;
+   final Set<Type> types;
+   final boolean alternative;
+   final boolean nullable;
+   final BeanLifecycle<T> beanLifecycle;
+
+   CustomBean(Class<?> beanClass, InjectionTarget<T> injectionTarget, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope, Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative, boolean nullable, BeanLifecycle<T> beanLifecycle)
+   {
+      this.beanClass = beanClass;
+      this.injectionTarget = injectionTarget;
+      this.name = name;
+      this.qualifiers = new HashSet<Annotation>(qualifiers);
+      this.scope = scope;
+      this.stereotypes = new HashSet<Class<? extends Annotation>>(stereotypes);
+      this.types = new HashSet<Type>(types);
+      this.alternative = alternative;
+      this.nullable = nullable;
+      this.beanLifecycle = beanLifecycle;
+   }
+
+   public Class<?> getBeanClass()
+   {
+      return beanClass;
+   }
+
+   public Set<InjectionPoint> getInjectionPoints()
+   {
+      return injectionTarget.getInjectionPoints();
+   }
+
+   public InjectionTarget<T> getInjectionTarget()
+   {
+      return injectionTarget;
+   }
+
+   public String getName()
+   {
+      return name;
+   }
+
+   public Set<Annotation> getQualifiers()
+   {
+      return Collections.unmodifiableSet(qualifiers);
+   }
+
+   public Class<? extends Annotation> getScope()
+   {
+      return scope;
+   }
+
+   public Set<Class<? extends Annotation>> getStereotypes()
+   {
+      return Collections.unmodifiableSet(stereotypes);
+   }
+
+   public Set<Type> getTypes()
+   {
+      return Collections.unmodifiableSet(types);
+   }
+
+   public boolean isAlternative()
+   {
+      return alternative;
+   }
+
+   public boolean isNullable()
+   {
+      return nullable;
+   }
+
+   public T create(CreationalContext<T> arg0)
+   {
+      return beanLifecycle.create(this, arg0);
+   }
+
+   public void destroy(T arg0, CreationalContext<T> arg1)
+   {
+      beanLifecycle.destroy(this, arg0, arg1);
+   }
+
+}

Added: extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBeanBuilder.java
===================================================================
--- extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBeanBuilder.java	                        (rev 0)
+++ extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/CustomBeanBuilder.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -0,0 +1,226 @@
+package org.jboss.weld.extensions.beans;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.enterprise.context.Dependent;
+import javax.enterprise.inject.Alternative;
+import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.InjectionTarget;
+import javax.inject.Named;
+
+import org.jboss.weld.extensions.util.AnnotatedTypeUtils;
+
+/**
+ * class that can build a bean from an AnnotatedType.
+ * 
+ * @author stuart
+ * 
+ */
+public class CustomBeanBuilder<T>
+{
+
+   final AnnotatedType<T> type;
+   final BeanManager beanManager;
+   InjectionTarget<T> injectionTarget;
+   String name;
+   Set<Annotation> qualifiers;
+   Class<? extends Annotation> scope;
+   Set<Class<? extends Annotation>> stereotypes;
+   Set<Type> types = new HashSet<Type>();
+   boolean alternative = false;
+   boolean nullable = false;
+   BeanLifecycle<T> beanLifecycle;
+   boolean passivationCapable;
+   String id;
+
+   public CustomBeanBuilder(AnnotatedType<T> type, BeanManager beanManager)
+   {
+      this(type, beanManager, beanManager.createInjectionTarget(type));
+   }
+
+   public CustomBeanBuilder(AnnotatedType<T> type, BeanManager beanManager, InjectionTarget<T> injectionTarget)
+   {
+      this.type = type;
+      this.beanManager = beanManager;
+      this.injectionTarget = injectionTarget;
+      qualifiers = new HashSet<Annotation>();
+      stereotypes = new HashSet<Class<? extends Annotation>>();
+      for (Annotation a : type.getAnnotations())
+      {
+         if (beanManager.isQualifier(a.annotationType()))
+         {
+            qualifiers.add(a);
+         }
+         else if (beanManager.isScope(a.annotationType()))
+         {
+            scope = a.annotationType();
+         }
+         else if (beanManager.isStereotype(a.annotationType()))
+         {
+            stereotypes.add(a.annotationType());
+         }
+         if (a instanceof Named)
+         {
+            Named n = (Named) a;
+            name = n.value();
+         }
+         if (a instanceof Alternative)
+         {
+            alternative = true;
+         }
+      }
+      if (scope == null)
+      {
+         scope = Dependent.class;
+      }
+
+      Class<?> c = type.getJavaClass();
+      do
+      {
+         types.add(c);
+         c = c.getSuperclass();
+      }
+      while (c != null);
+      for (Class<?> i : type.getJavaClass().getInterfaces())
+      {
+         types.add(i);
+      }
+      beanLifecycle = new SimpleBeanLifecycle<T>(type.getJavaClass(), beanManager);
+      id = CustomBean.class.getName() + ":" + AnnotatedTypeUtils.createTypeId(type);
+   }
+
+   public Bean<T> build()
+   {
+      if (!passivationCapable)
+      {
+         return new CustomBean<T>(type.getJavaClass(), injectionTarget, name, qualifiers, scope, stereotypes, types, alternative, nullable, beanLifecycle);
+      }
+      return new PassivationCapableCustomBean<T>(id, type.getJavaClass(), injectionTarget, name, qualifiers, scope, stereotypes, types, alternative, nullable, beanLifecycle);
+
+   }
+
+   public InjectionTarget<T> getInjectionTarget()
+   {
+      return injectionTarget;
+   }
+
+   public void setInjectionTarget(InjectionTarget<T> injectionTarget)
+   {
+      this.injectionTarget = injectionTarget;
+   }
+   public Set<Annotation> getQualifiers()
+   {
+      return qualifiers;
+   }
+
+   public void setQualifiers(Set<Annotation> qualifiers)
+   {
+      this.qualifiers = qualifiers;
+   }
+
+   public Class<? extends Annotation> getScope()
+   {
+      return scope;
+   }
+
+   public void setScope(Class<? extends Annotation> scope)
+   {
+      this.scope = scope;
+   }
+
+   public Set<Class<? extends Annotation>> getStereotypes()
+   {
+      return stereotypes;
+   }
+
+   public void setStereotypes(Set<Class<? extends Annotation>> stereotypes)
+   {
+      this.stereotypes = stereotypes;
+   }
+
+   public Set<Type> getTypes()
+   {
+      return types;
+   }
+
+   public void setTypes(Set<Type> types)
+   {
+      this.types = types;
+   }
+
+   public boolean isAlternative()
+   {
+      return alternative;
+   }
+
+   public void setAlternative(boolean alternative)
+   {
+      this.alternative = alternative;
+   }
+
+   public boolean isNullable()
+   {
+      return nullable;
+   }
+
+   public void setNullable(boolean nullable)
+   {
+      this.nullable = nullable;
+   }
+
+   public BeanLifecycle<T> getBeanLifecycle()
+   {
+      return beanLifecycle;
+   }
+
+   public void setBeanLifecycle(BeanLifecycle<T> beanLifecycle)
+   {
+      this.beanLifecycle = beanLifecycle;
+   }
+
+   public AnnotatedType<T> getType()
+   {
+      return type;
+   }
+
+   public BeanManager getBeanManager()
+   {
+      return beanManager;
+   }
+
+   public String getName()
+   {
+      return name;
+   }
+
+   public void setName(String name)
+   {
+      this.name = name;
+   }
+
+   public boolean isPassivationCapable()
+   {
+      return passivationCapable;
+   }
+
+   public void setPassivationCapable(boolean passivationCapable)
+   {
+      this.passivationCapable = passivationCapable;
+   }
+
+   public String getId()
+   {
+      return id;
+   }
+
+   public void setId(String id)
+   {
+      this.id = id;
+   }
+
+}

Added: extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/PassivationCapableCustomBean.java
===================================================================
--- extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/PassivationCapableCustomBean.java	                        (rev 0)
+++ extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/PassivationCapableCustomBean.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -0,0 +1,25 @@
+package org.jboss.weld.extensions.beans;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Set;
+
+import javax.enterprise.inject.spi.InjectionTarget;
+import javax.enterprise.inject.spi.PassivationCapable;
+
+public class PassivationCapableCustomBean<T> extends CustomBean<T> implements PassivationCapable
+{
+   final String id;
+
+   PassivationCapableCustomBean(String id, Class<?> beanClass, InjectionTarget<T> injectionTarget, String name, Set<Annotation> qualifiers, Class<? extends Annotation> scope, Set<Class<? extends Annotation>> stereotypes, Set<Type> types, boolean alternative, boolean nullable, BeanLifecycle<T> beanLifecycle)
+   {
+      super(beanClass, injectionTarget, name, qualifiers, scope, stereotypes, types, alternative, nullable, beanLifecycle);
+      this.id = id;
+   }
+
+   public String getId()
+   {
+      return id;
+   }
+
+}

Added: extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/SimpleBeanLifecycle.java
===================================================================
--- extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/SimpleBeanLifecycle.java	                        (rev 0)
+++ extensions/trunk/core/src/main/java/org/jboss/weld/extensions/beans/SimpleBeanLifecycle.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -0,0 +1,38 @@
+package org.jboss.weld.extensions.beans;
+
+import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.BeanManager;
+
+public class SimpleBeanLifecycle<T> implements BeanLifecycle<T>
+{
+   final Class<T> type;
+   final BeanManager beanManager;
+
+   public SimpleBeanLifecycle(Class<T> type, BeanManager beanManager)
+   {
+      this.type = type;
+      this.beanManager = beanManager;
+   }
+
+   public T create(CustomBean<T> bean, CreationalContext<T> creationalContext)
+   {
+      T instance = bean.getInjectionTarget().produce(creationalContext);
+      bean.getInjectionTarget().inject(instance, creationalContext);
+      bean.getInjectionTarget().postConstruct(instance);
+      return instance;
+   }
+
+   public void destroy(CustomBean<T> bean, T instance, CreationalContext<T> creationalContext)
+   {
+      try
+      {
+         bean.getInjectionTarget().preDestroy(instance);
+         creationalContext.release();
+      }
+      catch (Exception e)
+      {
+         throw new RuntimeException(e);
+      }
+   }
+
+}

Added: extensions/trunk/core/src/main/java/org/jboss/weld/extensions/util/AnnotatedTypeUtils.java
===================================================================
--- extensions/trunk/core/src/main/java/org/jboss/weld/extensions/util/AnnotatedTypeUtils.java	                        (rev 0)
+++ extensions/trunk/core/src/main/java/org/jboss/weld/extensions/util/AnnotatedTypeUtils.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -0,0 +1,564 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat, Inc., and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,  
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jboss.weld.extensions.util;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.enterprise.inject.spi.Annotated;
+import javax.enterprise.inject.spi.AnnotatedCallable;
+import javax.enterprise.inject.spi.AnnotatedConstructor;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedParameter;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+/**
+ * Class that can take an AnnotatedType and return a unique string
+ * representation of that type
+ * 
+ * @author Stuart Douglas <stuart at baileyroberts.com.au>
+ */
+public class AnnotatedTypeUtils
+{
+
+   /**
+    * Does the first stage of comparing AnnoatedCallables, however it cannot
+    * compare the method parameters
+    */
+   private static class AnnotatedCallableComparator<T> implements Comparator<AnnotatedCallable<? super T>>
+   {
+
+      public int compare(AnnotatedCallable<? super T> arg0, AnnotatedCallable<? super T> arg1)
+      {
+         // compare the names first
+         int result = (arg0.getJavaMember().getName().compareTo(arg1.getJavaMember().getName()));
+         if (result != 0)
+         {
+            return result;
+         }
+         result = arg0.getJavaMember().getDeclaringClass().getName().compareTo(arg1.getJavaMember().getDeclaringClass().getName());
+         if (result != 0)
+         {
+            return result;
+         }
+         result = arg0.getParameters().size() - arg1.getParameters().size();
+         return result;
+      }
+
+   }
+
+   private static class AnnotatedMethodComparator<T> implements Comparator<AnnotatedMethod<? super T>>
+   {
+
+      public static <T> Comparator<AnnotatedMethod<? super T>> instance()
+      {
+         return new AnnotatedMethodComparator<T>();
+      }
+
+      private AnnotatedCallableComparator<T> callableComparator = new AnnotatedCallableComparator<T>();
+
+      public int compare(AnnotatedMethod<? super T> arg0, AnnotatedMethod<? super T> arg1)
+      {
+         int result = callableComparator.compare(arg0, arg1);
+         if (result != 0)
+         {
+            return result;
+         }
+         for (int i = 0; i < arg0.getJavaMember().getParameterTypes().length; ++i)
+         {
+            Class<?> p0 = arg0.getJavaMember().getParameterTypes()[i];
+            Class<?> p1 = arg1.getJavaMember().getParameterTypes()[i];
+            result = p0.getName().compareTo(p1.getName());
+            if (result != 0)
+            {
+               return result;
+            }
+         }
+         return 0;
+      }
+
+   }
+
+   private static class AnnotatedConstructorComparator<T> implements Comparator<AnnotatedConstructor<? super T>>
+   {
+
+      public static <T> Comparator<AnnotatedConstructor<? super T>> instance()
+      {
+         return new AnnotatedConstructorComparator<T>();
+      }
+
+      private AnnotatedCallableComparator<T> callableComparator = new AnnotatedCallableComparator<T>();
+
+      public int compare(AnnotatedConstructor<? super T> arg0, AnnotatedConstructor<? super T> arg1)
+      {
+         int result = callableComparator.compare(arg0, arg1);
+         if (result != 0)
+         {
+            return result;
+         }
+         for (int i = 0; i < arg0.getJavaMember().getParameterTypes().length; ++i)
+         {
+            Class<?> p0 = arg0.getJavaMember().getParameterTypes()[i];
+            Class<?> p1 = arg1.getJavaMember().getParameterTypes()[i];
+            result = p0.getName().compareTo(p1.getName());
+            if (result != 0)
+            {
+               return result;
+            }
+         }
+         return 0;
+      }
+
+   }
+
+   private static class AnnotatedFieldComparator<T> implements Comparator<AnnotatedField<? super T>>
+   {
+
+      public static <T> Comparator<AnnotatedField<? super T>> instance()
+      {
+         return new AnnotatedFieldComparator<T>();
+      }
+
+      public int compare(AnnotatedField<? super T> arg0, AnnotatedField<? super T> arg1)
+      {
+         if (arg0.getJavaMember().getName().equals(arg1.getJavaMember().getName()))
+         {
+            return arg0.getJavaMember().getDeclaringClass().getName().compareTo(arg1.getJavaMember().getDeclaringClass().getName());
+         }
+         return arg0.getJavaMember().getName().compareTo(arg1.getJavaMember().getName());
+      }
+
+   }
+
+   private static class AnnotationComparator implements Comparator<Annotation>
+   {
+
+      public static final Comparator<Annotation> INSTANCE = new AnnotationComparator();
+
+      public int compare(Annotation arg0, Annotation arg1)
+      {
+         return arg0.annotationType().getName().compareTo(arg1.annotationType().getName());
+      }
+   }
+
+   private static class MethodComparator implements Comparator<Method>
+   {
+      
+      public static final Comparator<Method> INSTANCE = new MethodComparator();
+
+      public int compare(Method arg0, Method arg1)
+      {
+         return arg0.getName().compareTo(arg1.getName());
+      }
+   }
+
+   private static final char SEPERATOR = ';';
+
+   /**
+    * Generates a unique signature for an annotated type. Members without
+    * annotations are omitted to reduce the length of the signature
+    * 
+    * @param <X>
+    * @param annotatedType
+    * @return
+    */
+   public static <X> String createTypeId(AnnotatedType<X> annotatedType)
+   {
+      return createTypeId(annotatedType.getJavaClass(), annotatedType.getAnnotations(), annotatedType.getMethods(), annotatedType.getFields(), annotatedType.getConstructors());
+   }
+
+   /**
+    * Generates a unique signature for a concrete class
+    * 
+    * @param <X>
+    * @param annotatedType
+    * @return
+    */
+   public static <X> String createTypeId(Class<X> clazz, Collection<Annotation> annotations, Collection<AnnotatedMethod<? super X>> methods, Collection<AnnotatedField<? super X>> fields, Collection<AnnotatedConstructor<X>> constructors)
+   {
+      StringBuilder builder = new StringBuilder();
+
+      builder.append(clazz.getName());
+      builder.append(createAnnotationCollectionId(annotations));
+      builder.append("{");
+
+      // now deal with the fields
+      List<AnnotatedField<? super X>> sortedFields = new ArrayList<AnnotatedField<? super X>>();
+      sortedFields.addAll(fields);
+      Collections.sort(sortedFields, AnnotatedFieldComparator.<X> instance());
+      for (AnnotatedField<? super X> field : sortedFields)
+      {
+         if (!field.getAnnotations().isEmpty())
+         {
+            builder.append(createFieldId(field));
+            builder.append(SEPERATOR);
+         }
+      }
+
+      // methods
+      List<AnnotatedMethod<? super X>> sortedMethods = new ArrayList<AnnotatedMethod<? super X>>();
+      sortedMethods.addAll(methods);
+      Collections.sort(sortedMethods, AnnotatedMethodComparator.<X> instance());
+      for (AnnotatedMethod<? super X> method : sortedMethods)
+      {
+         if (!method.getAnnotations().isEmpty() || hasMethodParameters(method))
+         {
+            builder.append(createCallableId(method));
+            builder.append(SEPERATOR);
+         }
+      }
+
+      // constructors
+      List<AnnotatedConstructor<? super X>> sortedConstructors = new ArrayList<AnnotatedConstructor<? super X>>();
+      sortedConstructors.addAll(constructors);
+      Collections.sort(sortedConstructors, AnnotatedConstructorComparator.<X> instance());
+      for (AnnotatedConstructor<? super X> constructor : sortedConstructors)
+      {
+         if (!constructor.getAnnotations().isEmpty() || hasMethodParameters(constructor))
+         {
+            builder.append(createCallableId(constructor));
+            builder.append(SEPERATOR);
+         }
+      }
+      builder.append("}");
+
+      return builder.toString();
+   }
+
+   private static <X> boolean hasMethodParameters(AnnotatedCallable<X> callable)
+   {
+      for (AnnotatedParameter<X> parameter : callable.getParameters())
+      {
+         if (!parameter.getAnnotations().isEmpty())
+         {
+            return true;
+         }
+      }
+      return false;
+   }
+
+   private static String createAnnotationCollectionId(Collection<Annotation> annotations)
+   {
+      if (annotations.isEmpty())
+      {
+         return "";
+      }
+      
+      StringBuilder builder = new StringBuilder();
+      builder.append('[');
+
+      List<Annotation> annotationList = new ArrayList<Annotation>(annotations.size());
+      annotationList.addAll(annotations);
+      Collections.sort(annotationList, AnnotationComparator.INSTANCE);
+      
+      for (Annotation a : annotationList)
+      {
+         builder.append('@');
+         builder.append(a.annotationType().getName());
+         builder.append('(');
+         Method[] declaredMethods = a.annotationType().getDeclaredMethods();
+         List<Method> methods = new ArrayList<Method>(declaredMethods.length);
+         for (Method m : declaredMethods)
+         {
+            methods.add(m);
+         }
+         Collections.sort(methods, MethodComparator.INSTANCE);
+
+         for (int i = 0; i < methods.size(); ++i)
+         {
+            Method method = methods.get(i);
+            try
+            {
+               Object value = method.invoke(a);
+               builder.append(method.getName());
+               builder.append('=');
+               builder.append(value.toString());
+            }
+            catch (NullPointerException e)
+            {
+               throw new RuntimeException("NullPointerException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e);
+            }
+            catch (IllegalArgumentException e)
+            {
+               throw new RuntimeException("IllegalArgumentException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e);
+            }
+            catch (IllegalAccessException e)
+            {
+               throw new RuntimeException("IllegalAccessException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e);
+            }
+            catch (InvocationTargetException e)
+            {
+               throw new RuntimeException("InvocationTargetException accessing annotation member, annotation:" + a.annotationType().getName() + " member: " + method.getName(), e);
+            }
+            if (i + 1 != methods.size())
+            {
+               builder.append(',');
+            }
+         }
+         builder.append(')');
+      }
+      builder.append(']');
+      return builder.toString();
+   }
+
+   public static <X> String createFieldId(AnnotatedField<X> field)
+   {
+      return createFieldId(field.getJavaMember(), field.getAnnotations());
+   }
+
+   public static <X> String createFieldId(Field field, Collection<Annotation> annotations)
+   {
+      StringBuilder builder = new StringBuilder();
+      builder.append(field.getDeclaringClass().getName());
+      builder.append('.');
+      builder.append(field.getName());
+      builder.append(createAnnotationCollectionId(annotations));
+      return builder.toString();
+   }
+
+   public static <X> String createCallableId(AnnotatedCallable<X> method)
+   {
+      StringBuilder builder = new StringBuilder();
+      builder.append(method.getJavaMember().getDeclaringClass().getName());
+      builder.append('.');
+      builder.append(method.getJavaMember().getName());
+      builder.append(createAnnotationCollectionId(method.getAnnotations()));
+      builder.append(createParameterListId(method.getParameters()));
+      return builder.toString();
+   }
+
+   public static <X> String createMethodId(Method method, Set<Annotation> annotations, List<AnnotatedParameter<X>> parameters)
+   {
+      StringBuilder builder = new StringBuilder();
+      builder.append(method.getDeclaringClass().getName());
+      builder.append('.');
+      builder.append(method.getName());
+      builder.append(createAnnotationCollectionId(annotations));
+      builder.append(createParameterListId(parameters));
+      return builder.toString();
+   }
+
+   public static <X> String createConstructorId(Constructor<X> constructor, Set<Annotation> annotations, List<AnnotatedParameter<X>> parameters)
+   {
+      StringBuilder builder = new StringBuilder();
+      builder.append(constructor.getDeclaringClass().getName());
+      builder.append('.');
+      builder.append(constructor.getName());
+      builder.append(createAnnotationCollectionId(annotations));
+      builder.append(createParameterListId(parameters));
+      return builder.toString();
+   }
+
+   public static <X> String createParameterListId(List<AnnotatedParameter<X>> parameters)
+   {
+      StringBuilder builder = new StringBuilder();
+      builder.append("(");
+      for (int i = 0; i < parameters.size(); ++i)
+      {
+         AnnotatedParameter<X> ap = parameters.get(i);
+         builder.append(createParameterId(ap));
+         if (i + 1 != parameters.size())
+         {
+            builder.append(',');
+         }
+      }
+      builder.append(")");
+      return builder.toString();
+   }
+
+   public static <X> String createParameterId(AnnotatedParameter<X> annotatedParameter)
+   {
+      return createParameterId(annotatedParameter.getBaseType(), annotatedParameter.getAnnotations());
+   }
+
+   public static <X> String createParameterId(Type type, Set<Annotation> annotations)
+   {
+      StringBuilder builder = new StringBuilder();
+      if (type instanceof Class<?>)
+      {
+         Class<?> c = (Class<?>) type;
+         builder.append(c.getName());
+      }
+      else
+      {
+         builder.append(type.toString());
+      }
+      builder.append(createAnnotationCollectionId(annotations));
+      return builder.toString();
+   }
+
+   /**
+    * compares two annotated elemetes to see if they have the same annotations
+    * 
+    * @param a1
+    * @param a2
+    * @return
+    */
+   private static boolean compareAnnotated(Annotated a1, Annotated a2)
+   {
+      return a1.getAnnotations().equals(a2.getAnnotations());
+   }
+
+   /**
+    * compares two annotated elements to see if they have the same annotations
+    * 
+    */
+   private static boolean compareAnnotatedParameters(List<? extends AnnotatedParameter<?>> p1, List<? extends AnnotatedParameter<?>> p2)
+   {
+      if (p1.size() != p2.size())
+      {
+         return false;
+      }
+      for (int i = 0; i < p1.size(); ++i)
+      {
+         if (!compareAnnotated(p1.get(i), p2.get(i)))
+         {
+            return false;
+         }
+      }
+      return true;
+   }
+
+   public static boolean compareAnnotatedField(AnnotatedField<?> f1, AnnotatedField<?> f2)
+   {
+      if (!f1.getJavaMember().equals(f2.getJavaMember()))
+      {
+         return false;
+      }
+      return compareAnnotated(f1, f2);
+   }
+
+   public static boolean compareAnnotatedCallable(AnnotatedCallable<?> m1, AnnotatedCallable<?> m2)
+   {
+      if (!m1.getJavaMember().equals(m2.getJavaMember()))
+      {
+         return false;
+      }
+      if(!compareAnnotated(m1, m2))
+      {
+         return false;
+      }
+      return compareAnnotatedParameters(m1.getParameters(), m2.getParameters());
+   }
+
+   /**
+    * Compares two annotated types and returns true if they are the same
+    */
+   public static boolean compareAnnotatedTypes(AnnotatedType<?> t1, AnnotatedType<?> t2)
+   {
+      if (!t1.getJavaClass().equals(t2.getJavaClass()))
+      {
+         return false;
+      }
+      if (!compareAnnotated(t1, t2))
+      {
+         return false;
+      }
+
+      if (t1.getFields().size() != t2.getFields().size())
+      {
+         return false;
+      }
+      Map<Field, AnnotatedField<?>> fields = new HashMap<Field, AnnotatedField<?>>();
+      for (AnnotatedField<?> f : t2.getFields())
+      {
+         fields.put(f.getJavaMember(), f);
+      }
+      for (AnnotatedField<?> f : t1.getFields())
+      {
+         if (fields.containsKey(f.getJavaMember()))
+         {
+            if (!compareAnnotatedField(f, fields.get(f.getJavaMember())))
+            {
+               return false;
+            }
+         }
+         else
+         {
+            return false;
+         }
+      }
+
+      if (t1.getMethods().size() != t2.getMethods().size())
+      {
+         return false;
+      }
+      Map<Method, AnnotatedMethod<?>> methods = new HashMap<Method, AnnotatedMethod<?>>();
+      for (AnnotatedMethod<?> f : t2.getMethods())
+      {
+         methods.put(f.getJavaMember(), f);
+      }
+      for (AnnotatedMethod<?> f : t1.getMethods())
+      {
+         if (methods.containsKey(f.getJavaMember()))
+         {
+            if (!compareAnnotatedCallable(f, methods.get(f.getJavaMember())))
+            {
+               return false;
+            }
+         }
+         else
+         {
+            return false;
+         }
+      }
+      if (t1.getConstructors().size() != t2.getConstructors().size())
+      {
+         return false;
+      }
+      Map<Constructor<?>, AnnotatedConstructor<?>> constructors = new HashMap<Constructor<?>, AnnotatedConstructor<?>>();
+      for (AnnotatedConstructor<?> f : t2.getConstructors())
+      {
+         constructors.put(f.getJavaMember(), f);
+      }
+      for (AnnotatedConstructor<?> f : t1.getConstructors())
+      {
+         if (constructors.containsKey(f.getJavaMember()))
+         {
+            if (!compareAnnotatedCallable(f, constructors.get(f.getJavaMember())))
+            {
+               return false;
+            }
+         }
+         else
+         {
+            return false;
+         }
+      }
+      return true;
+
+   }
+
+
+   private AnnotatedTypeUtils()
+   {
+   }
+
+}

Modified: extensions/trunk/genericbeans/src/main/java/org/jboss/weld/extensions/genericbeans/GenericExtension.java
===================================================================
--- extensions/trunk/genericbeans/src/main/java/org/jboss/weld/extensions/genericbeans/GenericExtension.java	2010-03-05 12:17:06 UTC (rev 6005)
+++ extensions/trunk/genericbeans/src/main/java/org/jboss/weld/extensions/genericbeans/GenericExtension.java	2010-03-05 12:18:51 UTC (rev 6006)
@@ -29,10 +29,10 @@
 import javax.inject.Inject;
 
 import org.jboss.weld.extensions.util.AnnotationInstanceProvider;
-import org.jboss.weld.extensions.util.BeanImpl;
 import org.jboss.weld.extensions.util.reannotated.ReannotatedField;
 import org.jboss.weld.extensions.util.reannotated.ReannotatedParameter;
 import org.jboss.weld.extensions.util.reannotated.ReannotatedType;
+import org.jboss.weld.extensions.beans.CustomBeanBuilder;
 
 public class GenericExtension implements Extension
 {
@@ -221,8 +221,8 @@
                   InjectionTarget<?> it = beanManager.createInjectionTarget(rt);
 
                   it = new GenericBeanInjectionTargetWrapper(rt, it, conc);
-                  BeanImpl<?> bean = new BeanImpl(it, rt);
-                  event.addBean(bean);
+                  CustomBeanBuilder<?> builder = new CustomBeanBuilder(rt,beanManager,it);
+                  event.addBean(builder.build());
 
                }
             }



More information about the weld-commits mailing list