[weld-commits] Weld SVN: r5450 - in core/trunk: impl/src/main/java/org/jboss/weld/bean and 11 other directories.

Author: pete.muir(a)jboss.org Date: 2010-01-13 08:55:53 -0500 (Wed, 13 Jan 2010) New Revision: 5450 Added: core/trunk/impl/src/main/java/org/jboss/weld/injection/CurrentInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/injection/DummyInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/QualifierModel.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/ForwardingInterceptorResolvable.java Removed: core/trunk/impl/src/main/java/org/jboss/weld/manager/DummyInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/BindingTypeModel.java Modified: core/trunk/impl/src/main/java/org/jboss/weld/Container.java core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InjectionPointBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyMethodHandler.java core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/Validator.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java core/trunk/impl/src/main/java/org/jboss/weld/manager/BeanManagerImpl.java core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/MetaAnnotationStore.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/NameBasedResolver.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/Resolvable.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableFactory.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableTransformer.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableWeldClass.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDecoratorResolver.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDisposerResolver.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeInterceptorResolver.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeObserverResolver.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeResolver.java core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java core/trunk/impl/src/main/java/org/jboss/weld/util/Names.java core/trunk/tests/src/main/java/org/jboss/weld/mock/cluster/AbstractClusterTest.java core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/NaiveClusterTest.java core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/SwitchableContainerTest.java Log: WELD-262 Modified: core/trunk/impl/src/main/java/org/jboss/weld/Container.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/Container.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/Container.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -41,7 +41,7 @@ public class Container { - private final static Singleton<Container> instance; + private static Singleton<Container> instance; static { @@ -95,6 +95,7 @@ this.managers.put(deploymentManager.getId(), deploymentManager); this.beanDeploymentArchives = new ConcurrentHashMap<BeanDeploymentArchive, BeanManagerImpl>(); this.deploymentServices = deploymentServices; + } /** @@ -105,13 +106,11 @@ { // TODO We should probably cleanup the bean managers for activities? managers.clear(); - for (BeanManagerImpl beanManager : beanDeploymentArchives.values()) { beanManager.cleanup(); } beanDeploymentArchives.clear(); - deploymentServices.cleanup(); deploymentManager.cleanup(); LoggerFactory.cleanup(); Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -58,9 +58,10 @@ import org.jboss.weld.exceptions.DefinitionException; import org.jboss.weld.exceptions.IllegalProductException; import org.jboss.weld.exceptions.WeldException; +import org.jboss.weld.injection.CurrentInjectionPoint; +import org.jboss.weld.injection.DummyInjectionPoint; import org.jboss.weld.introspector.WeldMember; import org.jboss.weld.manager.BeanManagerImpl; -import org.jboss.weld.manager.DummyInjectionPoint; import org.jboss.weld.metadata.cache.MetaAnnotationStore; import org.jboss.weld.util.Beans; import org.jboss.weld.util.reflection.Reflections; @@ -254,7 +255,7 @@ { throw new IllegalProductException(NON_SERIALIZABLE_PRODUCT_ERROR, getProducer()); } - InjectionPoint injectionPoint = beanManager.getCurrentInjectionPoint(); + InjectionPoint injectionPoint = Container.instance().services().get(CurrentInjectionPoint.class).peek(); if (injectionPoint == null || injectionPoint.equals(DummyInjectionPoint.INSTANCE)) { return; Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -52,6 +52,7 @@ import org.jboss.weld.exceptions.DefinitionException; import org.jboss.weld.exceptions.DeploymentException; import org.jboss.weld.exceptions.ForbiddenStateException; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.injection.InjectionContextImpl; import org.jboss.weld.injection.WeldInjectionPoint; import org.jboss.weld.introspector.WeldClass; @@ -144,7 +145,18 @@ { throw new ForbiddenStateException(DELEGATE_INJECTION_POINT_NOT_FOUND, decorator); } - return getBeanManager().replaceOrPushCurrentInjectionPoint(outerDelegateInjectionPoint); + CurrentInjectionPoint currentInjectionPoint = Container.instance().services().get(CurrentInjectionPoint.class); + if (currentInjectionPoint.peek() != null) + { + InjectionPoint originalInjectionPoint = currentInjectionPoint.pop(); + currentInjectionPoint.push(outerDelegateInjectionPoint); + return originalInjectionPoint; + } + else + { + currentInjectionPoint.push(outerDelegateInjectionPoint); + return null; + } } /** Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -23,6 +23,8 @@ import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.inject.spi.InjectionPoint; +import org.jboss.weld.Container; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.manager.BeanManagerImpl; import org.slf4j.cal10n.LocLogger; @@ -38,7 +40,7 @@ public T create(CreationalContext<T> creationalContext) { - InjectionPoint injectionPoint = this.getBeanManager().getCurrentInjectionPoint(); + InjectionPoint injectionPoint = Container.instance().services().get(CurrentInjectionPoint.class).peek(); if (injectionPoint != null) { return newInstance(injectionPoint); Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InjectionPointBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InjectionPointBean.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InjectionPointBean.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -22,6 +22,8 @@ import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.inject.spi.InjectionPoint; +import org.jboss.weld.Container; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.util.collections.Arrays2; @@ -52,7 +54,7 @@ public InjectionPoint create(CreationalContext<InjectionPoint> creationalContext) { - return getBeanManager().getCurrentInjectionPoint(); + return Container.instance().services().get(CurrentInjectionPoint.class).peek(); } public void destroy(InjectionPoint instance, CreationalContext<InjectionPoint> creationalContext) Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -34,7 +34,9 @@ import javax.enterprise.inject.spi.InjectionPoint; import javax.enterprise.util.TypeLiteral; +import org.jboss.weld.Container; import org.jboss.weld.exceptions.InvalidObjectException; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.resolution.ResolvableWeldClass; import org.jboss.weld.util.Beans; @@ -68,14 +70,14 @@ // Push in an empty CC to ensure that we don't get the CC of whatever is injecting the bean containing the Instance injection point try { - getBeanManager().pushDummyInjectionPoint(); + Container.instance().services().get(CurrentInjectionPoint.class).pushDummy(); @SuppressWarnings("unchecked") T instance = (T) getBeanManager().getReference(bean, getType(), getBeanManager().createCreationalContext(bean)); return instance; } finally { - getBeanManager().popDummyInjectionPoint(); + Container.instance().services().get(CurrentInjectionPoint.class).popDummy(); } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyMethodHandler.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyMethodHandler.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyMethodHandler.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -30,10 +30,10 @@ import javax.enterprise.inject.spi.Bean; import org.jboss.weld.Container; +import org.jboss.weld.context.CreationalContextImpl; import org.jboss.weld.context.WeldCreationalContext; -import org.jboss.weld.manager.BeanManagerImpl; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.serialization.spi.ContextualStore; -import org.jboss.weld.util.reflection.Reflections; import org.jboss.weld.util.reflection.SecureReflections; import org.slf4j.cal10n.LocLogger; @@ -57,8 +57,6 @@ // The bean index in the manager private final String id; - private final BeanManagerImpl manager; - private static final ThreadLocal<WeldCreationalContext<?>> currentCreationalContext = new ThreadLocal<WeldCreationalContext<?>>(); /** @@ -67,11 +65,10 @@ * @param bean The bean to proxy * @param beanIndex The index to the bean in the manager bean list */ - public ClientProxyMethodHandler(Bean<?> bean, BeanManagerImpl manager, String id) + public ClientProxyMethodHandler(Bean<?> bean, String id) { this.bean = bean; this.id = id; - this.manager = manager; log.trace("Created method handler for bean " + bean + " identified as " + id); } @@ -128,7 +125,7 @@ boolean outer; if (currentCreationalContext.get() == null) { - creationalContext = manager.createCreationalContext(bean); + creationalContext = new CreationalContextImpl<T>(bean); currentCreationalContext.set(creationalContext); outer = true; } @@ -139,14 +136,14 @@ } try { - Context context = manager.getContext(bean.getScope()); + Context context = Container.instance().deploymentManager().getContext(bean.getScope()); // Ensure that there is no injection point associated - manager.pushDummyInjectionPoint(); + Container.instance().services().get(CurrentInjectionPoint.class).pushDummy(); return context.get(bean, creationalContext); } finally { - manager.popDummyInjectionPoint(); + Container.instance().services().get(CurrentInjectionPoint.class).popDummy(); if (outer) { currentCreationalContext.remove(); Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -21,20 +21,20 @@ import static org.jboss.weld.logging.messages.BeanMessage.PROXY_INSTANTIATION_FAILED; import java.io.Serializable; -import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentMap; import javax.enterprise.inject.spi.Bean; import org.jboss.weld.Container; import org.jboss.weld.exceptions.DefinitionException; import org.jboss.weld.exceptions.WeldException; -import org.jboss.weld.logging.messages.BeanMessage; -import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.serialization.spi.ContextualStore; import org.jboss.weld.util.Proxies; import org.jboss.weld.util.Proxies.TypeInfo; -import org.jboss.weld.util.collections.ConcurrentCache; +import com.google.common.base.Function; +import com.google.common.collect.MapMaker; + /** * A proxy pool for holding scope adaptors (client proxies) * @@ -44,21 +44,34 @@ */ public class ClientProxyProvider { - private static final long serialVersionUID = 9029999149357529341L; + + private static final Function<Bean<Object>, Object> CREATE_CLIENT_PROXY = new Function<Bean<Object>, Object> () + { + public Object apply(Bean<Object> from) + { + String id = Container.instance().services().get(ContextualStore.class).putIfAbsent(from); + if (id == null) + { + throw new DefinitionException(BEAN_ID_CREATION_FAILED, from); + } + return createClientProxy(from, id); + } + }; + /** * A container/cache for previously created proxies * * @author Nicklas Karlsson */ - private final ConcurrentCache<Bean<? extends Object>, Object> pool; + private final ConcurrentMap<Bean<Object>, Object> pool; /** * Constructor */ public ClientProxyProvider() { - this.pool = new ConcurrentCache<Bean<? extends Object>, Object>(); + this.pool = new MapMaker().makeComputingMap(CREATE_CLIENT_PROXY); } /** @@ -74,11 +87,11 @@ * @throws InstantiationException When the proxy couldn't be created * @throws IllegalAccessException When the proxy couldn't be created */ - private static <T> T createClientProxy(Bean<T> bean, BeanManagerImpl manager, String id) throws RuntimeException + private static <T> T createClientProxy(Bean<T> bean, String id) throws RuntimeException { try { - return Proxies.<T>createProxy(new ClientProxyMethodHandler(bean, manager, id), TypeInfo.of(bean.getTypes()).add(Serializable.class)); + return Proxies.<T>createProxy(new ClientProxyMethodHandler(bean, id), TypeInfo.of(bean.getTypes()).add(Serializable.class)); } catch (InstantiationException e) { @@ -99,23 +112,9 @@ * @param bean The bean to get a proxy to * @return the client proxy for the bean */ - public <T> T getClientProxy(final BeanManagerImpl manager, final Bean<T> bean) + public <T> T getClientProxy(final Bean<T> bean) { - T instance = pool.putIfAbsent(bean, new Callable<T>() - { - - public T call() throws Exception - { - String id = Container.instance().services().get(ContextualStore.class).putIfAbsent(bean); - if (id == null) - { - throw new DefinitionException(BEAN_ID_CREATION_FAILED, bean); - } - return createClientProxy(bean, manager, id); - } - - }); - return instance; + return (T) pool.get(bean); } /** Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/Validator.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/Validator.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/Validator.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -94,8 +94,8 @@ import org.jboss.weld.util.reflection.Reflections; import com.google.common.base.Supplier; -import com.google.common.collect.Multimap; import com.google.common.collect.Multimaps; +import com.google.common.collect.SetMultimap; /** * Checks a list of beans for DeploymentExceptions and their subclasses @@ -322,7 +322,7 @@ public void validateBeanNames(BeanManagerImpl beanManager) { - Multimap<String, Bean<?>> namedAccessibleBeans = Multimaps.newSetMultimap(new HashMap<String, Collection<Bean<?>>>(), new Supplier<Set<Bean<?>>>() + SetMultimap<String, Bean<?>> namedAccessibleBeans = Multimaps.newSetMultimap(new HashMap<String, Collection<Bean<?>>>(), new Supplier<Set<Bean<?>>>() { public Set<Bean<?>> get() Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -71,6 +71,7 @@ import org.jboss.weld.ejb.spi.EjbDescriptor; import org.jboss.weld.exceptions.ForbiddenArgumentException; import org.jboss.weld.exceptions.ForbiddenStateException; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.jsf.JsfApiAbstraction; import org.jboss.weld.logging.messages.VersionMessage; import org.jboss.weld.manager.BeanManagerImpl; @@ -319,6 +320,7 @@ services.add(ContextualStore.class, new ContextualStoreImpl()); services.add(ServiceLoaderFactory.class, new DefaultServiceLoaderFactory()); services.add(JavassistCleaner.class, new JavassistCleaner()); + services.add(CurrentInjectionPoint.class, new CurrentInjectionPoint()); return services; } Added: core/trunk/impl/src/main/java/org/jboss/weld/injection/CurrentInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/CurrentInjectionPoint.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/CurrentInjectionPoint.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -0,0 +1,79 @@ +package org.jboss.weld.injection; + +import java.util.Stack; + +import javax.enterprise.inject.spi.InjectionPoint; + +import org.jboss.weld.bootstrap.api.Service; + +public class CurrentInjectionPoint implements Service +{ + + private final ThreadLocal<Stack<InjectionPoint>> currentInjectionPoint; + + public CurrentInjectionPoint() + { + this.currentInjectionPoint = new ThreadLocal<Stack<InjectionPoint>>() + { + @Override + protected Stack<InjectionPoint> initialValue() + { + return new Stack<InjectionPoint>(); + } + }; + } + + /** + * Replaces (or adds) the current injection point. If a current injection + * point exists, it will be replaced. If no current injection point exists, + * one will be added. + * + * @param injectionPoint the injection point to use + * @return the injection point added, or null if previous existed did not exist + */ + public void push(InjectionPoint injectionPoint) + { + currentInjectionPoint.get().push(injectionPoint); + } + + public InjectionPoint pop() + { + return currentInjectionPoint.get().pop(); + } + + /** + * The injection point being operated on for this thread + * + * @return the current injection point + */ + public InjectionPoint peek() + { + if (!currentInjectionPoint.get().empty()) + { + return currentInjectionPoint.get().peek(); + } + else + { + return null; + } + } + + public void pushDummy() + { + currentInjectionPoint.get().push(DummyInjectionPoint.INSTANCE); + } + + public void popDummy() + { + if (!currentInjectionPoint.get().isEmpty() && DummyInjectionPoint.INSTANCE.equals(currentInjectionPoint.get().peek())) + { + currentInjectionPoint.get().pop(); + } + } + + public void cleanup() + { + this.currentInjectionPoint.remove(); + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/injection/CurrentInjectionPoint.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Copied: core/trunk/impl/src/main/java/org/jboss/weld/injection/DummyInjectionPoint.java (from rev 5441, core/trunk/impl/src/main/java/org/jboss/weld/manager/DummyInjectionPoint.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/DummyInjectionPoint.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/DummyInjectionPoint.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -0,0 +1,56 @@ +/** + * + */ +package org.jboss.weld.injection; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Member; +import java.lang.reflect.Type; +import java.util.Collections; +import java.util.Set; + +import javax.enterprise.inject.spi.Annotated; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.InjectionPoint; + +public class DummyInjectionPoint implements InjectionPoint +{ + + public static final DummyInjectionPoint INSTANCE = new DummyInjectionPoint(); + + public boolean isTransient() + { + return true; + } + + public boolean isDelegate() + { + return false; + } + + public Type getType() + { + return InjectionPoint.class; + } + + public Set<Annotation> getQualifiers() + { + return Collections.emptySet(); + } + + public Member getMember() + { + return null; + } + + public Bean<?> getBean() + { + return null; + } + + public Annotated getAnnotated() + { + return null; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/injection/DummyInjectionPoint.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -28,7 +28,6 @@ import org.jboss.weld.introspector.WeldAnnotation; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.resources.ClassTransformer; -import org.jboss.weld.util.Names; import org.jboss.weld.util.collections.HashSetSupplier; import org.jboss.weld.util.reflection.HierarchyDiscovery; import org.jboss.weld.util.reflection.SecureReflections; @@ -129,7 +128,7 @@ @Override public String toString() { - return new StringBuilder().append("class ").append(Names.classToString(getDelegate())).toString(); + return getJavaClass().toString(); } @Override Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -517,7 +517,7 @@ @Override public String toString() { - return new StringBuilder().append("class ").append(Names.classToString(getJavaClass())).toString(); + return Names.toString(getJavaClass(), getAnnotations(), getActualTypeArguments()); } public String getSimpleName() Modified: core/trunk/impl/src/main/java/org/jboss/weld/manager/BeanManagerImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/manager/BeanManagerImpl.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/manager/BeanManagerImpl.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -48,7 +48,6 @@ import java.util.List; import java.util.Map; import java.util.Set; -import java.util.Stack; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CopyOnWriteArraySet; @@ -96,11 +95,13 @@ import org.jboss.weld.exceptions.InjectionException; import org.jboss.weld.exceptions.UnproxyableResolutionException; import org.jboss.weld.exceptions.UnsatisfiedResolutionException; +import org.jboss.weld.injection.CurrentInjectionPoint; import org.jboss.weld.introspector.WeldAnnotated; import org.jboss.weld.literal.AnyLiteral; import org.jboss.weld.manager.api.WeldManager; import org.jboss.weld.metadata.cache.MetaAnnotationStore; import org.jboss.weld.metadata.cache.ScopeModel; +import org.jboss.weld.resolution.InterceptorResolvable; import org.jboss.weld.resolution.NameBasedResolver; import org.jboss.weld.resolution.Resolvable; import org.jboss.weld.resolution.ResolvableFactory; @@ -188,9 +189,9 @@ * archives */ private transient final TypeSafeBeanResolver<Bean<?>> beanResolver; - private transient final TypeSafeResolver<? extends Resolvable, Decorator<?>> decoratorResolver; - private transient final TypeSafeResolver<? extends Resolvable, Interceptor<?>> interceptorResolver; - private transient final TypeSafeResolver<? extends Resolvable, ObserverMethod<?>> observerResolver; + private transient final TypeSafeResolver<Resolvable, Decorator<?>> decoratorResolver; + private transient final TypeSafeResolver<InterceptorResolvable, Interceptor<?>> interceptorResolver; + private transient final TypeSafeResolver<Resolvable, ObserverMethod<?>> observerResolver; private transient final NameBasedResolver nameBasedResolver; private transient final ELResolver weldELResolver; private transient Namespace rootNamespace; @@ -225,12 +226,6 @@ private final AtomicInteger childIds; private final String id; - - /* - * Runtime data transfer - * ********************* - */ - private transient final ThreadLocal<Stack<InjectionPoint>> currentInjectionPoint; /** * Interception model @@ -396,15 +391,6 @@ this.nameBasedResolver = new NameBasedResolver(this, createDynamicAccessibleIterable(beanTransform)); this.weldELResolver = new WeldELResolver(this); this.childActivities = new CopyOnWriteArraySet<BeanManagerImpl>(); - - this.currentInjectionPoint = new ThreadLocal<Stack<InjectionPoint>>() - { - @Override - protected Stack<InjectionPoint> initialValue() - { - return new Stack<InjectionPoint>(); - } - }; } private <T> Set<Iterable<T>> buildAccessibleClosure(Collection<BeanManagerImpl> hierarchy, Transform<T> transform) @@ -628,14 +614,14 @@ { if (registerInjectionPoint) { - currentInjectionPoint.get().push(injectionPoint); + Container.instance().services().get(CurrentInjectionPoint.class).push(injectionPoint); } // TODO Do this properly Set<Bean<?>> beans = getBeans(ResolvableWeldClass.of(injectionPoint.getType(), injectionPoint.getQualifiers().toArray(new Annotation[0]), this)); Set<Bean<?>> injectableBeans = new HashSet<Bean<?>>(); for (Bean<?> bean : beans) { - if (!(bean instanceof Decorator || bean instanceof Interceptor)) + if (!(bean instanceof Decorator<?> || bean instanceof Interceptor<?>)) { injectableBeans.add(bean); } @@ -646,7 +632,7 @@ { if (registerInjectionPoint) { - currentInjectionPoint.get().pop(); + Container.instance().services().get(CurrentInjectionPoint.class).pop(); } } } @@ -790,7 +776,7 @@ { if (creationalContext != null || getContext(bean.getScope()).get(bean) != null) { - return clientProxyProvider.getClientProxy(this, bean); + return clientProxyProvider.getClientProxy(bean); } else { @@ -845,7 +831,7 @@ { if (registerInjectionPoint) { - currentInjectionPoint.get().push(injectionPoint); + Container.instance().services().get(CurrentInjectionPoint.class).push(injectionPoint); } if (getServices().get(MetaAnnotationStore.class).getScopeModel(resolvedBean.getScope()).isNormal() && !Proxies.isTypeProxyable(injectionPoint.getType())) { @@ -873,7 +859,7 @@ { if (registerInjectionPoint) { - currentInjectionPoint.get().pop(); + Container.instance().services().get(CurrentInjectionPoint.class).pop(); } } } @@ -1084,56 +1070,7 @@ } /** - * The injection point being operated on for this thread * - * @return the current injection point - */ - public InjectionPoint getCurrentInjectionPoint() - { - if (!currentInjectionPoint.get().empty()) - { - return currentInjectionPoint.get().peek(); - } - else - { - return null; - } - } - - /** - * Replaces (or adds) the current injection point. If a current injection - * point exists, it will be replaced. If no current injection point exists, - * one will be added. - * - * @param injectionPoint the injection point to use - * @return the injection point added, or null if non previous existed - */ - public InjectionPoint replaceOrPushCurrentInjectionPoint(InjectionPoint injectionPoint) - { - InjectionPoint originalInjectionPoint = null; - if (!currentInjectionPoint.get().empty()) - { - originalInjectionPoint = currentInjectionPoint.get().pop(); - } - currentInjectionPoint.get().push(injectionPoint); - return originalInjectionPoint; - } - - public void pushDummyInjectionPoint() - { - currentInjectionPoint.get().push(DummyInjectionPoint.INSTANCE); - } - - public void popDummyInjectionPoint() - { - if (!currentInjectionPoint.get().isEmpty() && DummyInjectionPoint.INSTANCE.equals(currentInjectionPoint.get().peek())) - { - currentInjectionPoint.get().pop(); - } - } - - /** - * * @return */ public Map<Contextual<?>, Contextual<?>> getSpecializedBeans() @@ -1350,7 +1287,6 @@ public void cleanup() { services.cleanup(); - this.currentInjectionPoint.remove(); this.accessibleManagers.clear(); this.beanResolver.clear(); this.beans.clear(); Deleted: core/trunk/impl/src/main/java/org/jboss/weld/manager/DummyInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/manager/DummyInjectionPoint.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/manager/DummyInjectionPoint.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -1,56 +0,0 @@ -/** - * - */ -package org.jboss.weld.manager; - -import java.lang.annotation.Annotation; -import java.lang.reflect.Member; -import java.lang.reflect.Type; -import java.util.Collections; -import java.util.Set; - -import javax.enterprise.inject.spi.Annotated; -import javax.enterprise.inject.spi.Bean; -import javax.enterprise.inject.spi.InjectionPoint; - -public class DummyInjectionPoint implements InjectionPoint -{ - - public static final DummyInjectionPoint INSTANCE = new DummyInjectionPoint(); - - public boolean isTransient() - { - return true; - } - - public boolean isDelegate() - { - return false; - } - - public Type getType() - { - return InjectionPoint.class; - } - - public Set<Annotation> getQualifiers() - { - return Collections.emptySet(); - } - - public Member getMember() - { - return null; - } - - public Bean<?> getBean() - { - return null; - } - - public Annotated getAnnotated() - { - return null; - } - -} Deleted: core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/BindingTypeModel.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/BindingTypeModel.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/BindingTypeModel.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -1,186 +0,0 @@ -/* - * JBoss, Home of Professional Open Source - * Copyright 2008, Red Hat Middleware LLC, 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.metadata.cache; - -import static org.jboss.weld.logging.Category.REFLECTION; -import static org.jboss.weld.logging.LoggerFactory.loggerFactory; -import static org.jboss.weld.logging.messages.MetadataMessage.NON_BINDING_MEMBER_TYPE; - -import java.lang.annotation.Annotation; -import java.lang.reflect.InvocationTargetException; -import java.util.Set; - -import javax.enterprise.util.Nonbinding; -import javax.inject.Qualifier; - -import org.jboss.weld.exceptions.WeldException; -import org.jboss.weld.introspector.WeldMethod; -import org.jboss.weld.resources.ClassTransformer; -import org.jboss.weld.util.collections.Arrays2; -import org.jboss.weld.util.reflection.Reflections; -import org.slf4j.cal10n.LocLogger; - -/** - * - * Model of a binding type - * - * @author Pete Muir - * - */ -public class BindingTypeModel<T extends Annotation> extends AnnotationModel<T> -{ - private static final LocLogger log = loggerFactory().getLogger(REFLECTION); - - private static final Set<Class<? extends Annotation>> META_ANNOTATIONS = Arrays2.<Class<? extends Annotation>>asSet(Qualifier.class); - - // The non-binding types - private Set<WeldMethod<?, ?>> nonBindingTypes; - - - /** - * Constructor - * - * @param type The type - */ - public BindingTypeModel(Class<T> type, ClassTransformer transformer) - { - super(type, transformer); - } - - /** - * Initializes the non-binding types and validates the members - */ - @Override - protected void init() - { - super.init(); - initNonBindingTypes(); - checkArrayAndAnnotationValuedMembers(); - } - - /** - * Validates the members - */ - private void checkArrayAndAnnotationValuedMembers() - { - for (WeldMethod<?, ?> annotatedMethod : getAnnotatedAnnotation().getMembers()) - { - if ((Reflections.isArrayType(annotatedMethod.getJavaClass()) || Annotation.class.isAssignableFrom(annotatedMethod.getJavaClass())) && !nonBindingTypes.contains(annotatedMethod)) - { - super.valid = false; - log.debug(NON_BINDING_MEMBER_TYPE, annotatedMethod); - } - } - - } - - /** - * Gets the meta-annotation type - * - * @return The BindingType class - */ - @Override - protected Set<Class<? extends Annotation>> getMetaAnnotationTypes() - { - return META_ANNOTATIONS; - } - - /** - * Indicates if there are non-binding types present - * - * @return True if present, false otherwise - */ - public boolean hasNonBindingTypes() - { - return nonBindingTypes.size() > 0; - } - - /** - * Gets the non-binding types - * - * @return A set of non-binding types, or an empty set if there are none - * present - */ - public Set<WeldMethod<?, ?>> getNonBindingTypes() - { - return nonBindingTypes; - } - - /** - * Initializes the non-binding types - */ - protected void initNonBindingTypes() - { - nonBindingTypes = getAnnotatedAnnotation().getMembers(Nonbinding.class); - } - - /** - * Comparator for checking equality - * - * @param instance The instance to check against - * @param other The other binding type - * @return True if equal, false otherwise - */ - public boolean isEqual(Annotation instance, Annotation other) - { - if (instance.annotationType().equals(getRawType()) && other.annotationType().equals(getRawType())) - { - for (WeldMethod<?, ?> annotatedMethod : getAnnotatedAnnotation().getMembers()) - { - if (!nonBindingTypes.contains(annotatedMethod)) - { - try - { - Object thisValue = annotatedMethod.invoke(instance); - Object thatValue = annotatedMethod.invoke(other); - if (!thisValue.equals(thatValue)) - { - return false; - } - } - catch (IllegalArgumentException e) - { - throw new WeldException(e); - } - catch (IllegalAccessException e) - { - throw new WeldException(e); - } - catch (InvocationTargetException e) - { - throw new WeldException(e); - } - - } - } - return true; - } - return false; - } - - /** - * Gets a string representation of the binding type model - * - * @return The string representation - */ - @Override - public String toString() - { - return (isValid() ? "Valid" : "Invalid") + " binding type model for " + getRawType() + " with non-binding types " + getNonBindingTypes(); - } - -} Modified: core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/MetaAnnotationStore.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/MetaAnnotationStore.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/MetaAnnotationStore.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -17,12 +17,14 @@ package org.jboss.weld.metadata.cache; import java.lang.annotation.Annotation; -import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentMap; import org.jboss.weld.bootstrap.api.Service; import org.jboss.weld.resources.ClassTransformer; -import org.jboss.weld.util.collections.ConcurrentCache; +import com.google.common.base.Function; +import com.google.common.collect.MapMaker; + /** * Metadata singleton for holding EJB metadata, scope models etc. * @@ -31,21 +33,103 @@ */ public class MetaAnnotationStore implements Service { + + private static abstract class AbstractMetaAnnotationFunction<M extends AnnotationModel<Annotation>> implements Function<Class<Annotation>, M> + { + + private final ClassTransformer classTransformer; + private AbstractMetaAnnotationFunction(ClassTransformer classTransformer) + { + this.classTransformer = classTransformer; + } + + public ClassTransformer getClassTransformer() + { + return classTransformer; + } + + } + + private static class StereotypeFunction extends AbstractMetaAnnotationFunction<StereotypeModel<Annotation>> + { + + public StereotypeFunction(ClassTransformer classTransformer) + { + super(classTransformer); + } + + public StereotypeModel<Annotation> apply(Class<Annotation> from) + { + return new StereotypeModel<Annotation>(from, getClassTransformer()); + } + + } + + private static class ScopeFunction extends AbstractMetaAnnotationFunction<ScopeModel<Annotation>> + { + + public ScopeFunction(ClassTransformer classTransformer) + { + super(classTransformer); + } + + public ScopeModel<Annotation> apply(Class<Annotation> from) + { + return new ScopeModel<Annotation>(from, getClassTransformer()); + } + + } + + private static class QualifierFunction extends AbstractMetaAnnotationFunction<QualifierModel<Annotation>> + { + + public QualifierFunction(ClassTransformer classTransformer) + { + super(classTransformer); + } + + public QualifierModel<Annotation> apply(Class<Annotation> from) + { + return new QualifierModel<Annotation>(from, getClassTransformer()); + } + + } + + private static class InterceptorBindingFunction extends AbstractMetaAnnotationFunction<InterceptorBindingModel<Annotation>> + { + + public InterceptorBindingFunction(ClassTransformer classTransformer) + { + super(classTransformer); + } + + public InterceptorBindingModel<Annotation> apply(Class<Annotation> from) + { + return new InterceptorBindingModel<Annotation>(from, getClassTransformer()); + } + + } + // The stereotype models - private ConcurrentCache<Class<? extends Annotation>, StereotypeModel<?>> stereotypes = new ConcurrentCache<Class<? extends Annotation>, StereotypeModel<?>>(); + private ConcurrentMap<Class<Annotation>, StereotypeModel<Annotation>> stereotypes; // The scope models - private ConcurrentCache<Class<? extends Annotation>, ScopeModel<?>> scopes = new ConcurrentCache<Class<? extends Annotation>, ScopeModel<?>>(); + private ConcurrentMap<Class<Annotation>, ScopeModel<Annotation>> scopes; // The binding type models - private ConcurrentCache<Class<? extends Annotation>, BindingTypeModel<?>> bindingTypes = new ConcurrentCache<Class<? extends Annotation>, BindingTypeModel<?>>(); + private ConcurrentMap<Class<Annotation>, QualifierModel<Annotation>> qualifiers; // the interceptor bindings - private ConcurrentCache<Class<? extends Annotation>, InterceptorBindingModel<?>> interceptorBindings = new ConcurrentCache<Class<? extends Annotation>, InterceptorBindingModel<?>>(); + private ConcurrentMap<Class<Annotation>, InterceptorBindingModel<Annotation>> interceptorBindings; private final ClassTransformer classTransformer; public MetaAnnotationStore(ClassTransformer classTransformer) { + MapMaker mapMaker = new MapMaker(); this.classTransformer = classTransformer; + this.stereotypes = mapMaker.makeComputingMap(new StereotypeFunction(classTransformer)); + this.scopes = mapMaker.makeComputingMap(new ScopeFunction(classTransformer)); + this.qualifiers = mapMaker.makeComputingMap(new QualifierFunction(classTransformer)); + this.interceptorBindings = mapMaker.makeComputingMap(new InterceptorBindingFunction(classTransformer)); } /** @@ -59,14 +143,7 @@ */ public <T extends Annotation> StereotypeModel<T> getStereotype(final Class<T> stereotype) { - return stereotypes.putIfAbsent(stereotype, new Callable<StereotypeModel<T>>() - { - - public StereotypeModel<T> call() throws Exception - { - return new StereotypeModel<T>(stereotype, classTransformer); - } - }); + return (StereotypeModel<T>) stereotypes.get(stereotype); } /** @@ -75,20 +152,12 @@ * Adds the model if it is not present. * * @param <T> The type - * @param scopeType The scope type + * @param scope The scope type * @return The scope type model */ - public <T extends Annotation> ScopeModel<T> getScopeModel(final Class<T> scopeType) + public <T extends Annotation> ScopeModel<T> getScopeModel(final Class<T> scope) { - return scopes.putIfAbsent(scopeType, new Callable<ScopeModel<T>>() - { - - public ScopeModel<T> call() throws Exception - { - return new ScopeModel<T>(scopeType, classTransformer); - } - - }); + return (ScopeModel<T>) scopes.get(scope); } /** @@ -100,17 +169,10 @@ * @param bindingType The binding type * @return The binding type model */ - public <T extends Annotation> BindingTypeModel<T> getBindingTypeModel(final Class<T> bindingType) + @SuppressWarnings("unchecked") + public <T extends Annotation> QualifierModel<T> getBindingTypeModel(final Class<T> bindingType) { - return bindingTypes.putIfAbsent(bindingType, new Callable<BindingTypeModel<T>>() - { - - public BindingTypeModel<T> call() throws Exception - { - return new BindingTypeModel<T>(bindingType, classTransformer); - } - - }); + return (QualifierModel<T>) qualifiers.get(bindingType); } /** @@ -123,31 +185,23 @@ { StringBuilder buffer = new StringBuilder(); buffer.append("Metadata cache\n"); - buffer.append("Registered binding type models: " + bindingTypes.size() + "\n"); - buffer.append("Registered scope type models: " + scopes.size() + "\n"); - buffer.append("Registered stereotype models: " + stereotypes.size() + "\n"); - buffer.append("Registered interceptor binding models: " + interceptorBindings.size() + "\n"); + buffer.append("Registered binding type models: ").append(qualifiers.size()).append("\n"); + buffer.append("Registered scope type models: ").append(scopes.size()).append("\n"); + buffer.append("Registered stereotype models: ").append(stereotypes.size()).append("\n"); + buffer.append("Registered interceptor binding models: ").append(interceptorBindings.size()).append("\n"); return buffer.toString(); } public void cleanup() { - this.bindingTypes.clear(); + this.qualifiers.clear(); this.scopes.clear(); this.stereotypes.clear(); this.interceptorBindings.clear(); } - public <T extends Annotation> InterceptorBindingModel getInterceptorBindingModel(final Class<T> interceptorBinding) + public <T extends Annotation> InterceptorBindingModel<T> getInterceptorBindingModel(final Class<T> interceptorBinding) { - return interceptorBindings.putIfAbsent(interceptorBinding, new Callable<InterceptorBindingModel<T>>() - { - - public InterceptorBindingModel<T> call() throws Exception - { - return new InterceptorBindingModel<T>(interceptorBinding, classTransformer); - } - - }); + return (InterceptorBindingModel<T>) interceptorBindings.get(interceptorBinding); } } Copied: core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/QualifierModel.java (from rev 5441, core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/BindingTypeModel.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/QualifierModel.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/QualifierModel.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -0,0 +1,186 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, 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.metadata.cache; + +import static org.jboss.weld.logging.Category.REFLECTION; +import static org.jboss.weld.logging.LoggerFactory.loggerFactory; +import static org.jboss.weld.logging.messages.MetadataMessage.NON_BINDING_MEMBER_TYPE; + +import java.lang.annotation.Annotation; +import java.lang.reflect.InvocationTargetException; +import java.util.Collections; +import java.util.Set; + +import javax.enterprise.util.Nonbinding; +import javax.inject.Qualifier; + +import org.jboss.weld.exceptions.WeldException; +import org.jboss.weld.introspector.WeldMethod; +import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.reflection.Reflections; +import org.slf4j.cal10n.LocLogger; + +/** + * + * Model of a binding type + * + * @author Pete Muir + * + */ +public class QualifierModel<T extends Annotation> extends AnnotationModel<T> +{ + private static final LocLogger log = loggerFactory().getLogger(REFLECTION); + + private static final Set<Class<? extends Annotation>> META_ANNOTATIONS = Collections.<Class<? extends Annotation>>singleton(Qualifier.class); + + // The non-binding types + private Set<WeldMethod<?, ?>> nonBindingMembers; + + + /** + * Constructor + * + * @param type The type + */ + public QualifierModel(Class<T> type, ClassTransformer transformer) + { + super(type, transformer); + } + + /** + * Initializes the non-binding types and validates the members + */ + @Override + protected void init() + { + super.init(); + initNonBindingMembers(); + checkArrayAndAnnotationValuedMembers(); + } + + /** + * Validates the members + */ + private void checkArrayAndAnnotationValuedMembers() + { + for (WeldMethod<?, ?> annotatedMethod : getAnnotatedAnnotation().getMembers()) + { + if ((Reflections.isArrayType(annotatedMethod.getJavaClass()) || Annotation.class.isAssignableFrom(annotatedMethod.getJavaClass())) && !nonBindingMembers.contains(annotatedMethod)) + { + super.valid = false; + log.debug(NON_BINDING_MEMBER_TYPE, annotatedMethod); + } + } + + } + + /** + * Gets the meta-annotation type + * + * @return The BindingType class + */ + @Override + protected Set<Class<? extends Annotation>> getMetaAnnotationTypes() + { + return META_ANNOTATIONS; + } + + /** + * Indicates if there are non-binding types present + * + * @return True if present, false otherwise + */ + public boolean hasNonBindingMembers() + { + return nonBindingMembers.size() > 0; + } + + /** + * Gets the non-binding types + * + * @return A set of non-binding types, or an empty set if there are none + * present + */ + public Set<WeldMethod<?, ?>> getNonBindingMembers() + { + return nonBindingMembers; + } + + /** + * Initializes the non-binding types + */ + protected void initNonBindingMembers() + { + nonBindingMembers = getAnnotatedAnnotation().getMembers(Nonbinding.class); + } + + /** + * Comparator for checking equality + * + * @param instance The instance to check against + * @param other The other binding type + * @return True if equal, false otherwise + */ + public boolean isEqual(Annotation instance, Annotation other) + { + if (instance.annotationType().equals(getRawType()) && other.annotationType().equals(getRawType())) + { + for (WeldMethod<?, ?> annotatedMethod : getAnnotatedAnnotation().getMembers()) + { + if (!nonBindingMembers.contains(annotatedMethod)) + { + try + { + Object thisValue = annotatedMethod.invoke(instance); + Object thatValue = annotatedMethod.invoke(other); + if (!thisValue.equals(thatValue)) + { + return false; + } + } + catch (IllegalArgumentException e) + { + throw new WeldException(e); + } + catch (IllegalAccessException e) + { + throw new WeldException(e); + } + catch (InvocationTargetException e) + { + throw new WeldException(e); + } + + } + } + return true; + } + return false; + } + + /** + * Gets a string representation of the qualifier model + * + * @return The string representation + */ + @Override + public String toString() + { + return (isValid() ? "Valid" : "Invalid") + " qualifer model for " + getRawType() + " with non-binding members " + getNonBindingMembers(); + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/metadata/cache/QualifierModel.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/impl/src/main/java/org/jboss/weld/resolution/ForwardingInterceptorResolvable.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/ForwardingInterceptorResolvable.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/ForwardingInterceptorResolvable.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -0,0 +1,62 @@ +package org.jboss.weld.resolution; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.Set; + +import javax.enterprise.inject.spi.InterceptionType; + +import org.jboss.weld.bean.AbstractClassBean; + +public class ForwardingInterceptorResolvable implements InterceptorResolvable +{ + + public InterceptionType getInterceptionType() + { + // TODO Auto-generated method stub + return null; + } + + public <A extends Annotation> A getAnnotation(Class<A> annotationType) + { + // TODO Auto-generated method stub + return null; + } + + public AbstractClassBean<?> getDeclaringBean() + { + // TODO Auto-generated method stub + return null; + } + + public Class<?> getJavaClass() + { + // TODO Auto-generated method stub + return null; + } + + public Set<Annotation> getQualifiers() + { + // TODO Auto-generated method stub + return null; + } + + public Set<Type> getTypeClosure() + { + // TODO Auto-generated method stub + return null; + } + + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + // TODO Auto-generated method stub + return false; + } + + public boolean isAssignableTo(Class<?> clazz) + { + // TODO Auto-generated method stub + return false; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/resolution/ForwardingInterceptorResolvable.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/NameBasedResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/NameBasedResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/NameBasedResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -18,14 +18,16 @@ import java.util.HashSet; import java.util.Set; -import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentMap; import javax.enterprise.inject.spi.Bean; import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.util.Beans; -import org.jboss.weld.util.collections.ConcurrentCache; +import com.google.common.base.Function; +import com.google.common.collect.MapMaker; + /** * Implementation of name based bean resolution * @@ -33,14 +35,36 @@ */ public class NameBasedResolver { - // The resolved names - private ConcurrentCache<String, Set<Bean<?>>> resolvedNames; - // The beans to search - private final Iterable<? extends Bean<?>> allBeans; + private static class NameToBeanSet implements Function<String, Set<Bean<?>>> + { + + private final BeanManagerImpl beanManager; + private final Iterable<? extends Bean<?>> allBeans; + + private NameToBeanSet(BeanManagerImpl beanManager, Iterable<? extends Bean<?>> allBeans) + { + this.beanManager = beanManager; + this.allBeans = allBeans; + } + + public Set<Bean<?>> apply(String from) + { + Set<Bean<?>> matchedBeans = new HashSet<Bean<?>>(); + for (Bean<?> bean : allBeans) + { + if ((bean.getName() == null && from == null) || (bean.getName() != null && bean.getName().equals(from))) + { + matchedBeans.add(bean); + } + } + return Beans.retainEnabledAlternatives(matchedBeans, beanManager.getEnabledAlternativeClasses(), beanManager.getEnabledAlternativeStereotypes()); + } + + } - // The Bean manager - private final BeanManagerImpl manager; + // The resolved names + private ConcurrentMap<String, Set<Bean<?>>> resolvedNames; /** * Constructor @@ -48,9 +72,7 @@ */ public NameBasedResolver(BeanManagerImpl manager, Iterable<? extends Bean<?>> allBeans) { - this.manager = manager; - this.allBeans = allBeans; - this.resolvedNames = new ConcurrentCache<String, Set<Bean<?>>>(); + this.resolvedNames = new MapMaker().makeComputingMap(new NameToBeanSet(manager, allBeans)); } /** @@ -59,7 +81,7 @@ */ public void clear() { - this.resolvedNames = new ConcurrentCache<String, Set<Bean<?>>>(); + this.resolvedNames.clear(); } /** @@ -70,23 +92,7 @@ */ public Set<Bean<?>> resolve(final String name) { - return resolvedNames.putIfAbsent(name, new Callable<Set<Bean<?>>>() - { - - public Set<Bean<? extends Object>> call() throws Exception - { - Set<Bean<?>> matchedBeans = new HashSet<Bean<?>>(); - for (Bean<?> bean : allBeans) - { - if ((bean.getName() == null && name == null) || (bean.getName() != null && bean.getName().equals(name))) - { - matchedBeans.add(bean); - } - } - return Beans.retainEnabledAlternatives(matchedBeans, manager.getEnabledAlternativeClasses(), manager.getEnabledAlternativeStereotypes()); - } - - }); + return resolvedNames.get(name); } /** @@ -103,9 +109,4 @@ return buffer.toString(); } - protected BeanManagerImpl getManager() - { - return manager; - } - } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/Resolvable.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/Resolvable.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/Resolvable.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -33,7 +33,7 @@ { /** - * Get the bindings to use for resolution. @Current will be returned if no + * Get the bindings to use for resolution. @Default will be returned if no * bindings were specified * * @return the bindings Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableFactory.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableFactory.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableFactory.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -19,19 +19,19 @@ import java.lang.annotation.Annotation; import java.lang.reflect.Type; import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; -import java.util.Collections; +import javax.enterprise.inject.spi.InterceptionType; + import org.jboss.weld.bean.AbstractClassBean; import org.jboss.weld.introspector.WeldAnnotated; import org.jboss.weld.literal.DefaultLiteral; import org.jboss.weld.util.reflection.Reflections; -import javax.enterprise.inject.spi.InterceptionType; - public class ResolvableFactory { @@ -59,7 +59,7 @@ return new ResolvableImpl(new HashSet<Annotation>(Arrays.asList(bindings)), typeClosure, declaringBean); } - public static Resolvable of(InterceptionType interceptionType, Annotation... bindings) + public static InterceptorResolvable of(InterceptionType interceptionType, Annotation... bindings) { return new InterceptorResolvableImpl(new HashSet<Annotation>(Arrays.asList(bindings)), interceptionType ); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableTransformer.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableTransformer.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableTransformer.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -16,9 +16,9 @@ */ package org.jboss.weld.resolution; -public interface ResolvableTransformer +public interface ResolvableTransformer<R extends Resolvable> { - public Resolvable transform(Resolvable element); + public R transform(R element); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableWeldClass.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableWeldClass.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/ResolvableWeldClass.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -27,7 +27,6 @@ import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; -import java.util.Arrays; import java.util.HashSet; import java.util.Map; import java.util.Set; @@ -52,8 +51,6 @@ private final Set<Type> typeClosure; private final Type[] actualTypeArguments; - private final String _string; - public static <T> WeldAnnotated<T, Class<T>> of(TypeLiteral<T> typeLiteral, Annotation[] annotations, BeanManagerImpl manager) { return new ResolvableWeldClass<T>(typeLiteral.getType(), annotations, manager); @@ -101,7 +98,7 @@ if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; - if (parameterizedType.getRawType() instanceof Class) + if (parameterizedType.getRawType() instanceof Class<?>) { this.rawType = (Class<T>) parameterizedType.getRawType(); } @@ -110,13 +107,11 @@ throw new ForbiddenArgumentException(CANNOT_EXTRACT_RAW_TYPE, type); } this.actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments(); - this._string = rawType.toString() + "<" + Arrays.asList(actualTypeArguments).toString() + ">; binding types = " + Names.annotationsToString(getQualifiers()); } - else if (type instanceof Class) + else if (type instanceof Class<?>) { this.rawType = (Class<T>) type; this.actualTypeArguments = new Type[0]; - this._string = rawType.toString() +"; binding types = " + Names.annotationsToString(getQualifiers()); } else { @@ -139,7 +134,7 @@ @Override public String toString() { - return _string; + return Names.toString(getJavaClass(), getAnnotations(), getActualTypeArguments()); } @Override Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -16,10 +16,9 @@ */ package org.jboss.weld.resolution; -import java.util.Collection; import java.util.HashSet; import java.util.Set; -import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentMap; import javax.enterprise.event.Event; import javax.enterprise.inject.Instance; @@ -30,9 +29,11 @@ import org.jboss.weld.bean.builtin.FacadeBeanResolvableTransformer; import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.util.Beans; -import org.jboss.weld.util.collections.ConcurrentCache; import org.jboss.weld.util.reflection.Reflections; +import com.google.common.base.Function; +import com.google.common.collect.MapMaker; + /** * @author pmuir * @@ -44,16 +45,50 @@ private static final Class<Provider<?>> PROVIDER_TYPE = new TypeLiteral<Provider<?>>() {}.getRawType(); private static final Class<Event<?>> EVENT_TYPE = new TypeLiteral<Event<?>>() {}.getRawType(); - private final Set<ResolvableTransformer> transformers; - private final BeanManagerImpl manager; - private final ConcurrentCache<Set<?>, Set<Bean<?>>> disambiguatedBeans; + private final Set<ResolvableTransformer<Resolvable>> transformers; + private final BeanManagerImpl beanManager; + private final ConcurrentMap<Set<Bean<?>>, Set<Bean<?>>> disambiguatedBeans; + + public static class BeanDisambiguation implements Function<Set<Bean<?>>, Set<Bean<?>>> + { + + private final BeanManagerImpl beanManager; - public TypeSafeBeanResolver(BeanManagerImpl manager, Iterable<T> beans) + private BeanDisambiguation(BeanManagerImpl beanManager) + { + this.beanManager = beanManager; + } + + public Set<Bean<?>> apply(Set<Bean<?>> from) + { + if (from.size() > 1) + { + boolean alternativePresent = Beans.isAlternativePresent(from); + Set<Bean<?>> disambiguatedBeans = new HashSet<Bean<?>>(); + + for (Bean<?> bean : from) + { + if (alternativePresent ? bean.isAlternative() : true && !Beans.isSpecialized(bean, from, beanManager.getSpecializedBeans())) + { + disambiguatedBeans.add(bean); + } + } + return disambiguatedBeans; + } + else + { + return from; + } + } + + } + + public TypeSafeBeanResolver(BeanManagerImpl beanManager, Iterable<T> beans) { super(beans); - this.manager = manager; - this.disambiguatedBeans = new ConcurrentCache<Set<?>, Set<Bean<?>>>(); - transformers = new HashSet<ResolvableTransformer>(); + this.beanManager = beanManager; + this.disambiguatedBeans = new MapMaker().makeComputingMap(new BeanDisambiguation(beanManager)); + transformers = new HashSet<ResolvableTransformer<Resolvable>>(); transformers.add(new FacadeBeanResolvableTransformer(EVENT_TYPE)); transformers.add(new FacadeBeanResolvableTransformer(INSTANCE_TYPE)); transformers.add(new FacadeBeanResolvableTransformer(PROVIDER_TYPE)); @@ -63,25 +98,25 @@ @Override protected boolean matches(Resolvable resolvable, T bean) { - return Reflections.matches(resolvable.getTypeClosure(), bean.getTypes()) && Beans.containsAllBindings(resolvable.getQualifiers(), bean.getQualifiers(), manager); + return Reflections.matches(resolvable.getTypeClosure(), bean.getTypes()) && Beans.containsAllBindings(resolvable.getQualifiers(), bean.getQualifiers(), beanManager); } /** * @return the manager */ - public BeanManagerImpl getManager() + protected BeanManagerImpl getBeanManager() { - return manager; + return beanManager; } @Override protected Set<T> filterResult(Set<T> matched) { - return Beans.retainEnabledAlternatives(matched, manager.getEnabledAlternativeClasses(), manager.getEnabledAlternativeStereotypes()); + return Beans.retainEnabledAlternatives(matched, beanManager.getEnabledAlternativeClasses(), beanManager.getEnabledAlternativeStereotypes()); } @Override - protected Iterable<ResolvableTransformer> getTransformers() + protected Iterable<ResolvableTransformer<Resolvable>> getTransformers() { return transformers; } @@ -92,38 +127,19 @@ return matched; } + + @SuppressWarnings("unchecked") public <X> Set<Bean<? extends X>> resolve(final Set<Bean<? extends X>> beans) { - return disambiguatedBeans.<Set<Bean<? extends X>>>putIfAbsent(beans, new Callable<Set<Bean<? extends X>>>() - { - - public Set<Bean<? extends X>> call() throws Exception - { - Set<Bean<? extends X>> disambiguatedBeans = beans; - if (disambiguatedBeans.size() > 1) - { - boolean alternativePresent = Beans.isAlternativePresent(disambiguatedBeans); - disambiguatedBeans = new HashSet<Bean<? extends X>>(); - - for (Bean<? extends X> bean : beans) - { - if (alternativePresent ? bean.isAlternative() : true && !Beans.isSpecialized(bean, beans, manager.getSpecializedBeans())) - { - disambiguatedBeans.add(bean); - } - } - - } - return disambiguatedBeans; - } - - }); + return (Set) disambiguatedBeans.get(beans); } - public <X> Set<Bean<? extends X>> resolve(final Collection<Bean<? extends X>> beans) + @Override + public void clear() { - return resolve(new HashSet<Bean<? extends X>>(beans)); + super.clear(); + //this.disambiguatedBeans.clear(); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDecoratorResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDecoratorResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDecoratorResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -16,15 +16,14 @@ */ package org.jboss.weld.resolution; +import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Set; import java.util.TreeSet; -import java.util.Collections; import javax.enterprise.inject.spi.Decorator; -import org.jboss.weld.bean.DecoratorImpl; import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.util.Beans; import org.jboss.weld.util.reflection.Reflections; @@ -35,7 +34,7 @@ */ public class TypeSafeDecoratorResolver extends TypeSafeBeanResolver<Decorator<?>> { - + public TypeSafeDecoratorResolver(BeanManagerImpl manager, Iterable<Decorator<?>> decorators) { super(manager, decorators); @@ -44,7 +43,7 @@ @Override protected boolean matches(Resolvable resolvable, Decorator<?> bean) { - return Reflections.matches(Collections.singleton(bean.getDelegateType()), resolvable.getTypeClosure()) && Beans.containsAllBindings(bean.getDelegateQualifiers(), resolvable.getQualifiers(), getManager()) && getManager().getEnabledDecoratorClasses().contains(bean.getBeanClass()); + return Reflections.matches(Collections.singleton(bean.getDelegateType()), resolvable.getTypeClosure()) && Beans.containsAllBindings(bean.getDelegateQualifiers(), resolvable.getQualifiers(), getBeanManager()) && getBeanManager().getEnabledDecoratorClasses().contains(bean.getBeanClass()); } @Override @@ -55,7 +54,7 @@ public int compare(Decorator<?> o1, Decorator<?> o2) { - List<Class<?>> enabledDecorators = getManager().getEnabledDecoratorClasses(); + List<Class<?>> enabledDecorators = getBeanManager().getEnabledDecoratorClasses(); int p1 = enabledDecorators.indexOf(((Decorator<?>) o1).getBeanClass()); int p2 = enabledDecorators.indexOf(((Decorator<?>) o2).getBeanClass()); return p1 - p2; Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDisposerResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDisposerResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeDisposerResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -60,7 +60,7 @@ } @Override - protected Iterable<ResolvableTransformer> getTransformers() + protected Iterable<ResolvableTransformer<Resolvable>> getTransformers() { return Collections.emptySet(); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeInterceptorResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeInterceptorResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeInterceptorResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -32,10 +32,10 @@ /** * @author <a href="mailto:mariusb@redhat.com">Marius Bogoevici</a> */ -public class TypeSafeInterceptorResolver extends TypeSafeResolver<InterceptorResolvable,Interceptor<?>> +public class TypeSafeInterceptorResolver extends TypeSafeResolver<InterceptorResolvable, Interceptor<?>> { - private BeanManagerImpl manager; + private final BeanManagerImpl manager; public TypeSafeInterceptorResolver(BeanManagerImpl manager, Iterable<Interceptor<?>> interceptors) { @@ -46,13 +46,9 @@ @Override protected boolean matches(InterceptorResolvable resolvable, Interceptor<?> bean) { - return bean.intercepts(resolvable.getInterceptionType()) - && bean.getInterceptorBindings().size() > 0 - && Beans.containsAllInterceptionBindings(bean.getInterceptorBindings(), resolvable.getQualifiers(), getManager()) - && getManager().getEnabledInterceptorClasses().contains(bean.getBeanClass()); + return bean.intercepts(resolvable.getInterceptionType()) && bean.getInterceptorBindings().size() > 0 && Beans.containsAllInterceptionBindings(bean.getInterceptorBindings(), resolvable.getQualifiers(), getManager()) && getManager().getEnabledInterceptorClasses().contains(bean.getBeanClass()); } - @Override protected Set<Interceptor<?>> sortResult(Set<Interceptor<?>> matchedInterceptors) { @@ -79,7 +75,7 @@ } @Override - protected Iterable<ResolvableTransformer> getTransformers() + protected Iterable<ResolvableTransformer<InterceptorResolvable>> getTransformers() { return Collections.emptySet(); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeObserverResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeObserverResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeObserverResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -61,7 +61,7 @@ } @Override - protected Iterable<ResolvableTransformer> getTransformers() + protected Iterable<ResolvableTransformer<Resolvable>> getTransformers() { return Collections.emptySet(); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeResolver.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeResolver.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -19,9 +19,10 @@ import java.util.Collections; import java.util.HashSet; import java.util.Set; -import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentMap; -import org.jboss.weld.util.collections.ConcurrentCache; +import com.google.common.base.Function; +import com.google.common.collect.MapMaker; /** * Implementation of type safe bean resolution @@ -29,34 +30,31 @@ * @author Pete Muir * @author Marius Bogoevici */ -public abstract class TypeSafeResolver<R extends Resolvable,T> -{ - private static final long serialVersionUID = 1L; +public abstract class TypeSafeResolver<R extends Resolvable, T> +{ - private static abstract class MatchingResolvable extends ForwardingResolvable + private static class Key<R extends Resolvable> { - public static MatchingResolvable of(final Resolvable resolvable) + private final R resolvable; + + private Key(R resolvable) { - return new MatchingResolvable() - { - - @Override - protected Resolvable delegate() - { - return resolvable; - } - - }; + this.resolvable = resolvable; } + public R getResolvable() + { + return resolvable; + } + @Override public boolean equals(Object obj) { if (obj instanceof Resolvable) { Resolvable that = (Resolvable) obj; - return this.getTypeClosure().equals(that.getTypeClosure()) && this.getQualifiers().equals(that.getQualifiers()); + return this.getResolvable().getTypeClosure().equals(that.getTypeClosure()) && this.getResolvable().getQualifiers().equals(that.getQualifiers()); } else { @@ -64,13 +62,47 @@ } } + @Override + public int hashCode() + { + int result = 17; + result = 31 * result + this.getResolvable().getTypeClosure().hashCode(); + result = 31 * result + this.getResolvable().getQualifiers().hashCode(); + return result; + } + + @Override + public String toString() + { + return getResolvable().toString(); + } + } + private static class ResolvableToBeanSet<R extends Resolvable, T> implements Function<Key<R>, Set<T>> + { + + + private final TypeSafeResolver<R, T> resolver; + + private ResolvableToBeanSet(TypeSafeResolver<R, T> resolver) + { + this.resolver = resolver; + } + + public Set<T> apply(Key<R> from) + { + return resolver.sortResult(resolver.filterResult(resolver.findMatching(from.getResolvable()))); + } + + } + // The resolved injection points - private ConcurrentCache<MatchingResolvable, Set<T>> resolved; + private final ConcurrentMap<Key<R>, Set<T>> resolved; + // The beans to search + private final Iterable<? extends T> allBeans; - // The beans to search - private final Iterable<? extends T> iterable; + /** * Constructor @@ -78,9 +110,8 @@ */ public TypeSafeResolver(Iterable<? extends T> allBeans) { - this.iterable = allBeans; - this.resolved = new ConcurrentCache<MatchingResolvable, Set<T>>(); - + this.resolved = new MapMaker().makeComputingMap(new ResolvableToBeanSet<R, T>(this)); + this.allBeans = allBeans; } /** @@ -88,46 +119,20 @@ */ public void clear() { - this.resolved = new ConcurrentCache<MatchingResolvable, Set<T>>(); + this.resolved.clear(); } /** * Get the possible beans for the given element * - * @param key The resolving criteria + * @param resolvable The resolving criteria * @return An unmodifiable set of matching beans */ - public Set<T> resolve(Resolvable key) + public Set<T> resolve(R resolvable) { - final MatchingResolvable resolvable = MatchingResolvable.of(transform(key)); - - Callable<Set<T>> callable = new Callable<Set<T>>() - { - public Set<T> call() throws Exception - { - return sortResult(filterResult(findMatching(resolvable))); - } - - }; - Set<T> beans = resolved.putIfAbsent(resolvable, callable); - return Collections.unmodifiableSet(beans); + return Collections.unmodifiableSet(resolved.get(new Key<R>(transform(resolvable)))); } - protected Resolvable transform(Resolvable resolvable) - { - for (ResolvableTransformer transformer : getTransformers()) - { - resolvable = transformer.transform(resolvable); - } - return resolvable; - } - - protected abstract Iterable<ResolvableTransformer> getTransformers(); - - protected abstract Set<T> filterResult(Set<T> matched); - - protected abstract Set<T> sortResult(Set<T> matched); - /** * Gets the matching beans for binding criteria from a list of beans * @@ -136,19 +141,34 @@ * @param beans The beans to filter * @return A set of filtered beans */ - private Set<T> findMatching(MatchingResolvable resolvable) + private Set<T> findMatching(R resolvable) { Set<T> result = new HashSet<T>(); - for (T bean : iterable) + for (T bean : allBeans) { - if (matches((R)resolvable.delegate(), bean)) + if (matches(resolvable, bean)) { result.add(bean); } } return result; } + + protected R transform(R resolvable) + { + for (ResolvableTransformer<R> transformer : getTransformers()) + { + resolvable = transformer.transform(resolvable); + } + return resolvable; + } + + protected abstract Iterable<ResolvableTransformer<R>> getTransformers(); + + protected abstract Set<T> filterResult(Set<T> matched); + protected abstract Set<T> sortResult(Set<T> matched); + protected abstract boolean matches(R resolvable, T t); /** Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -90,10 +90,10 @@ import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.introspector.WeldParameter; import org.jboss.weld.manager.BeanManagerImpl; -import org.jboss.weld.metadata.cache.BindingTypeModel; import org.jboss.weld.metadata.cache.InterceptorBindingModel; import org.jboss.weld.metadata.cache.MergedStereotypes; import org.jboss.weld.metadata.cache.MetaAnnotationStore; +import org.jboss.weld.metadata.cache.QualifierModel; import org.jboss.weld.persistence.PersistenceApiAbstraction; import org.jboss.weld.util.reflection.Reflections; import org.slf4j.cal10n.LocLogger; @@ -495,7 +495,7 @@ { for (Annotation binding : bindings1) { - BindingTypeModel<?> bindingType = manager.getServices().get(MetaAnnotationStore.class).getBindingTypeModel(binding.annotationType()); + QualifierModel<?> bindingType = manager.getServices().get(MetaAnnotationStore.class).getBindingTypeModel(binding.annotationType()); boolean matchFound = false; // TODO Something wrong with annotation proxy hashcode in JDK/AnnotationLiteral hashcode, so always do a full check, don't use contains for (Annotation otherBinding : bindings2) @@ -619,7 +619,7 @@ * @param beans * @return */ - public static <X> boolean isAlternativePresent(Set<Bean<? extends X>> beans) + public static boolean isAlternativePresent(Set<Bean<?>> beans) { for (Bean<?> bean : beans) { @@ -651,7 +651,7 @@ * @param specializedBeans * @return */ - public static <X> boolean isSpecialized(Bean<? extends X> bean, Set<Bean<? extends X>> beans, Map<Contextual<?>, Contextual<?>> specializedBeans) + public static boolean isSpecialized(Bean<?> bean, Set<Bean<?>> beans, Map<Contextual<?>, Contextual<?>> specializedBeans) { if (specializedBeans.containsKey(bean)) { Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/Names.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/Names.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/Names.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -17,9 +17,6 @@ package org.jboss.weld.util; import java.lang.annotation.Annotation; -import java.lang.reflect.Constructor; -import java.lang.reflect.Field; -import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.lang.reflect.Type; import java.util.ArrayList; @@ -30,8 +27,6 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.jboss.weld.util.reflection.SecureReflections; - /** * Utility class to produce friendly names e.g. for debugging * @@ -70,6 +65,18 @@ } return result.toString(); } + + public static String toString(Class<?> rawType, Set<Annotation> annotations, Type[] actualTypeArguments) + { + if (actualTypeArguments.length > 0) + { + return new StringBuilder().append(Names.annotationsToString(annotations)).append(" ").append(rawType.getName()).append("<").append(Arrays.asList(actualTypeArguments)).append(">").toString(); + } + else + { + return new StringBuilder().append(Names.annotationsToString(annotations)).append(" ").append(rawType.getName()).toString(); + } + } /** * Counts item in an iteratble @@ -88,24 +95,6 @@ } /** - * Converts a list of strings to a String with given delimeter - * - * @param list The list - * @param delimiter The delimeter - * @return The string representation - */ - private static String listToString(List<String> list, String delimiter) - { - StringBuilder buffer = new StringBuilder(); - for (String item : list) - { - buffer.append(item); - buffer.append(delimiter); - } - return buffer.toString(); - } - - /** * Parses a reflection modifier to a list of string * * @param modifier The modifier to parse @@ -164,111 +153,6 @@ } return modifiers; } - - - - /** - * Gets a string representation from a field - * - * @param field The field - * @return The string representation - */ - public static String fieldToString(Field field) - { - return " Field " + annotationsToString(field.getAnnotations()) + listToString(parseModifiers(field.getModifiers()), " ") + field.getName(); - } - - /** - * Gets the string representation from a method - * - * @param method The method - * @return The string representation - */ - public static String methodToString(Method method) - { - return " Method " + method.getReturnType().getSimpleName() + " " + annotationsToString(method.getAnnotations()) + listToString(parseModifiers(method.getModifiers()), " ") + method.getName() + "(" + parametersToString(method.getParameterTypes(), method.getParameterAnnotations(), false) + ");\n"; - } - - /** - * Gets a string representation from an annotation - * - * @param annotation The annotation - * @return The string representation - */ - public static String annotationToString(Annotation annotation) - { - return "Annotation " + annotationsToString(annotation.annotationType().getAnnotations()) + annotation.annotationType().getSimpleName(); - } - - /** - * Gets a string representation from a method - * - * @param constructor The method - * @return The string representation - */ - public static String constructorToString(Constructor<?> constructor) - { - return " Constructor " + annotationsToString(constructor.getAnnotations()) + listToString(parseModifiers(constructor.getModifiers()), " ") + constructor.getDeclaringClass().getSimpleName() + "(" + parametersToString(constructor.getParameterTypes(), constructor.getParameterAnnotations(), true) + ");\n"; - } - - /** - * Gets a string representation from a list of parameters and their - * annotations - * - * @param parameterTypes The parameters - * @param annotations The annotation map - * @return The string representation - */ - private static String parametersToString(Class<?>[] parameterTypes, Annotation[][] annotations, boolean constructor) - { - StringBuilder buffer = new StringBuilder(); - int start = constructor ? 1 : 0; - for (int i = start; i < parameterTypes.length; i++) - { - if (i > start) - { - buffer.append(", "); - } - buffer.append(annotationsToString(annotations[i]) + typeToString(parameterTypes[i])); - } - return buffer.toString(); - } - - /** - * Gets a string representation from a type - * - * @param clazz The type - * @return The string representation - */ - private static String typeToString(Class<?> clazz) - { - return annotationsToString(clazz.getAnnotations()) + clazz.getSimpleName(); - } - - /** - * Gets a string representation from a class - * - * @param clazz The class - * @return The string representation - */ - public static String classToString(Class<?> clazz) - { - StringBuilder buffer = new StringBuilder(); - buffer.append("Class " + typeToString(clazz) + "\n"); - for (Field field : SecureReflections.getFields(clazz)) - { - buffer.append(fieldToString(field)); - } - for (Constructor<?> constructor : SecureReflections.getConstructors(clazz)) - { - buffer.append(constructorToString(constructor)); - } - for (Method method : SecureReflections.getMethods(clazz)) - { - buffer.append(methodToString(method)); - } - return buffer.toString(); - } public static String typesToString(Set<? extends Type> types) { @@ -299,17 +183,15 @@ { StringBuilder builder = new StringBuilder(); int i = 0; - builder.append("["); for (Annotation annotation : annotations) { if (i > 0) { - builder.append(", "); + builder.append(" "); } builder.append(&quot;(a)&quot;).append(annotation.annotationType().getSimpleName()); i++; } - builder.append("]"); return builder.toString(); } Modified: core/trunk/tests/src/main/java/org/jboss/weld/mock/cluster/AbstractClusterTest.java =================================================================== --- core/trunk/tests/src/main/java/org/jboss/weld/mock/cluster/AbstractClusterTest.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/tests/src/main/java/org/jboss/weld/mock/cluster/AbstractClusterTest.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -5,9 +5,11 @@ import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; +import java.lang.reflect.Field; import java.util.Collection; -import org.jboss.weld.bootstrap.api.SingletonProvider; +import org.jboss.weld.Container; +import org.jboss.weld.bootstrap.api.Singleton; import org.jboss.weld.context.ContextLifecycle; import org.jboss.weld.context.api.BeanStore; import org.jboss.weld.manager.BeanManagerImpl; @@ -19,17 +21,26 @@ public class AbstractClusterTest { + private Singleton<Container> singleton; + @BeforeClass - public void beforeClass() + public void beforeClass() throws Exception { - SingletonProvider.reset(); - SingletonProvider.initialize(new SwitchableSingletonProvider()); + singleton = (Singleton) getInstanceField().get(null); + getInstanceField().set(null, new SwitchableSingletonProvider().create(Container.class)); } + private static Field getInstanceField() throws Exception + { + Field field = Container.class.getDeclaredField("instance"); + field.setAccessible(true); + return field; + } + @AfterClass - public void afterClass() + public void afterClass() throws Exception { - SingletonProvider.reset(); + getInstanceField().set(null, singleton); } protected TestContainer bootstrapContainer(int id, Collection<Class<?>> classes) Modified: core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/NaiveClusterTest.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/NaiveClusterTest.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/NaiveClusterTest.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -35,6 +35,10 @@ use(2); Foo foo2 = (Foo) beanManager2.getReference(fooBean2, Foo.class, beanManager2.createCreationalContext(fooBean2)); assert foo2.getName().equals("container 1"); + use(2); + container2.stopContainer(); + use(1); + container1.stopContainer(); } @Test @@ -76,6 +80,10 @@ use(1); assert stable1.getFodder().getAmount() == 11; + use(1); + container1.stopContainer(); + use(2); + container2.stopContainer(); } @Test @@ -105,6 +113,10 @@ Stable stable2 = (Stable) beanManager2.getReference(stableBean2, Stable.class, beanManager2.createCreationalContext(stableBean2)); assert stable2.getFodder().getAmount() == stable1.getFodder().getAmount(); assert stable2.getHorse().getName() == null; + use(1); + container1.stopContainer(); + use(2); + container2.stopContainer(); } } Modified: core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/SwitchableContainerTest.java =================================================================== --- core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/SwitchableContainerTest.java 2010-01-13 13:53:14 UTC (rev 5449) +++ core/trunk/tests/src/test/java/org/jboss/weld/tests/unit/cluster/SwitchableContainerTest.java 2010-01-13 13:55:53 UTC (rev 5450) @@ -8,17 +8,16 @@ import org.jboss.weld.bootstrap.api.SingletonProvider; import org.jboss.weld.mock.MockEELifecycle; import org.jboss.weld.mock.TestContainer; +import org.jboss.weld.mock.cluster.AbstractClusterTest; import org.jboss.weld.mock.cluster.SwitchableSingletonProvider; import org.testng.annotations.Test; -public class SwitchableContainerTest +public class SwitchableContainerTest extends AbstractClusterTest { @Test public void test() { - SingletonProvider.reset(); - SingletonProvider.initialize(new SwitchableSingletonProvider()); // Bootstrap container 1 SwitchableSingletonProvider.use(1); @@ -54,6 +53,9 @@ foo2 = (Foo) beanManager2.getReference(fooBean2, Foo.class, beanManager2.createCreationalContext(fooBean2)); assert foo2.getName().equals("container 2"); SingletonProvider.reset(); + container1.stopContainer(); + container2.stopContainer(); + SingletonProvider.reset(); } }