Add remaining event bridges

src/main/java/org/jboss/seam/infinispan/GenericCacheManager.java

@@ -1,11 +1,17 @@
 package org.jboss.seam.infinispan;
 
+import static org.jboss.weld.extensions.bean.Beans.getQualifiers;
+
 import javax.enterprise.inject.Instance;
 import javax.enterprise.inject.Produces;
+import javax.enterprise.inject.spi.AnnotatedMember;
+import javax.enterprise.inject.spi.BeanManager;
 import javax.inject.Inject;
 
 import org.infinispan.AdvancedCache;
 import org.infinispan.manager.CacheContainer;
+import org.jboss.seam.infinispan.event.cache.CacheEventBridge;
+import org.jboss.weld.extensions.bean.generic.ApplyScope;
 import org.jboss.weld.extensions.bean.generic.Generic;
 import org.jboss.weld.extensions.bean.generic.GenericConfiguration;
 
@@ -22,6 +28,12 @@ public class GenericCacheManager<K, V>
    @Inject @Generic
    private Infinispan infinispan;
 
+   @Inject @Generic
+   private AnnotatedMember<?> annotatedMember;
+
+   @Inject
+   private CacheEventBridge cacheEventBridge;
+
    private CacheContainer getCacheContainer()
    {
       if (cacheContainer.isUnsatisfied())
@@ -34,11 +46,12 @@ private CacheContainer getCacheContainer()
       }
    }
 
-   @Produces
-   public AdvancedCache<K, V> getAdvancedCache()
+   @Produces @ApplyScope
+   public AdvancedCache<K, V> getAdvancedCache(BeanManager beanManager)
    {
       String name = infinispan.value();
       AdvancedCache<K, V> cache = getCacheContainer().<K, V>getCache(name).getAdvancedCache();
+      cacheEventBridge.registerObservers(getQualifiers(beanManager, annotatedMember.getAnnotations()), cache);
       return cache;
    }
 

src/main/java/org/jboss/seam/infinispan/InfinispanExtension.java

@@ -1,28 +1,22 @@
 package org.jboss.seam.infinispan;
 
 import java.lang.annotation.Annotation;
-import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Map;
 import java.util.Set;
 
 import javax.enterprise.event.Observes;
-import javax.enterprise.inject.spi.Annotated;
 import javax.enterprise.inject.spi.AnnotatedMember;
 import javax.enterprise.inject.spi.AnnotatedType;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.BeforeBeanDiscovery;
 import javax.enterprise.inject.spi.Extension;
-import javax.enterprise.inject.spi.InjectionTarget;
-import javax.enterprise.inject.spi.ProcessInjectionTarget;
 import javax.enterprise.inject.spi.ProcessProducer;
 import javax.enterprise.inject.spi.Producer;
 
 import org.infinispan.config.Configuration;
 import org.infinispan.manager.CacheContainer;
-import org.infinispan.notifications.Listener;
+import org.jboss.weld.extensions.bean.Beans;
 import org.jboss.weld.extensions.literal.GenericTypeLiteral;
 import org.jboss.weld.extensions.reflection.annotated.AnnotatedTypeBuilder;
 
@@ -40,20 +34,7 @@ static class ConfigurationHolder
       {
          this.producer = producer;
          this.name = name;
-         this.qualifiers = extractQualifiers(annotatedMember, beanManager);
-      }
-
-      private Set<Annotation> extractQualifiers(Annotated annotated, BeanManager beanManager)
-      {
-         Set<Annotation> qualifiers = new HashSet<Annotation>();
-         for (Annotation annotation : annotated.getAnnotations())
-         {
-            if (beanManager.isQualifier(annotation.annotationType()))
-            {
-               qualifiers.add(annotation);
-            }
-         }
-         return qualifiers;
+         this.qualifiers = Beans.getQualifiers(beanManager, annotatedMember.getAnnotations());
       }
 
       Producer<Configuration> getProducer()
@@ -74,12 +55,10 @@ public Set<Annotation> getQualifiers()
    }
 
    private final Collection<ConfigurationHolder> configurations;
-   private final Map<String, Collection<InjectionTarget<Object>>> listeners;
-
+
    InfinispanExtension()
    {
       this.configurations = new HashSet<InfinispanExtension.ConfigurationHolder>();
-      this.listeners = new HashMap<String, Collection<InjectionTarget<Object>>>();
    }
 
    void registerConfiguration(@Observes BeforeBeanDiscovery event, BeanManager beanManager)
@@ -105,35 +84,9 @@ void observeConfigurationProducer(@Observes ProcessProducer<?, Configuration> ev
       }
    }
 
-   void observeListener(@Observes ProcessInjectionTarget<Object> event)
-   {
-      if (event.getAnnotatedType().isAnnotationPresent(Listener.class) && event.getAnnotatedType().isAnnotationPresent(Infinispan.class))
-      {
-         // This is generic listener, so auto-register it
-         String name = event.getAnnotatedType().getAnnotation(Infinispan.class).value();
-         addListener(name, event.getInjectionTarget());
-      }
-   }
-
-   private void addListener(String name, InjectionTarget<Object> injectionTarget)
-   {
-      Collection<InjectionTarget<Object>> injectionTargets = listeners.get(name);
-      if (injectionTargets == null)
-      {
-         injectionTargets = new ArrayList<InjectionTarget<Object>>();
-         listeners.put(name, injectionTargets);
-      }
-      injectionTargets.add(injectionTarget);
-   }
-
    Collection<ConfigurationHolder> getConfigurations()
    {
       return configurations;
    }
 
-   Map<String, Collection<InjectionTarget<Object>>> getListeners()
-   {
-      return listeners;
-   }
-
 }

src/main/java/org/jboss/seam/infinispan/event/cache/CacheEntryCreatedAdapter.java

@@ -0,0 +1,61 @@
+package org.jboss.seam.infinispan.event.cache;
+
+import javax.enterprise.event.Event;
+
+import org.infinispan.Cache;
+import org.infinispan.notifications.Listener;
+import org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated;
+import org.infinispan.notifications.cachelistener.event.CacheEntryCreatedEvent;
+import org.infinispan.transaction.xa.GlobalTransaction;
+
+@Listener
+public class CacheEntryCreatedAdapter extends AbstractAdapter<CacheEntryCreatedEvent>
+{
+
+   public static final CacheEntryCreatedEvent EMTPTY = new CacheEntryCreatedEvent()
+   {
+
+      public Type getType()
+      {
+         return null;
+      }
+
+      public Object getKey()
+      {
+         return null;
+      }
+
+      public GlobalTransaction getGlobalTransaction()
+      {
+         return null;
+      }
+
+      public boolean isOriginLocal()
+      {
+         // TODO Auto-generated method stub
+         return false;
+      }
+
+      public boolean isPre()
+      {
+         return false;
+      }
+
+      public Cache<?, ?> getCache()
+      {
+         return null;
+      }
+   };
+
+   public CacheEntryCreatedAdapter(Event<CacheEntryCreatedEvent> event)
+   {
+      super(event);
+   }
+
+   @CacheEntryCreated
+   public void fire(CacheEntryCreatedEvent payload)
+   {
+      super.fire(payload);
+   }
+
+}

src/main/java/org/jboss/seam/infinispan/event/cache/CacheEntryEvictedAdapter.java

@@ -0,0 +1,61 @@
+package org.jboss.seam.infinispan.event.cache;
+
+import javax.enterprise.event.Event;
+
+import org.infinispan.Cache;
+import org.infinispan.notifications.Listener;
+import org.infinispan.notifications.cachelistener.annotation.CacheEntryEvicted;
+import org.infinispan.notifications.cachelistener.event.CacheEntryEvictedEvent;
+import org.infinispan.transaction.xa.GlobalTransaction;
+
+@Listener
+public class CacheEntryEvictedAdapter extends AbstractAdapter<CacheEntryEvictedEvent>
+{
+
+   public static final CacheEntryEvictedEvent EMTPTY = new CacheEntryEvictedEvent()
+   {
+
+      public Type getType()
+      {
+         return null;
+      }
+
+      public Object getKey()
+      {
+         return null;
+      }
+
+      public GlobalTransaction getGlobalTransaction()
+      {
+         return null;
+      }
+
+      public boolean isOriginLocal()
+      {
+         // TODO Auto-generated method stub
+         return false;
+      }
+
+      public boolean isPre()
+      {
+         return false;
+      }
+
+      public Cache<?, ?> getCache()
+      {
+         return null;
+      }
+   };
+
+   public CacheEntryEvictedAdapter(Event<CacheEntryEvictedEvent> event)
+   {
+      super(event);
+   }
+
+   @CacheEntryEvicted
+   public void fire(CacheEntryEvictedEvent payload)
+   {
+      super.fire(payload);
+   }
+
+}

src/main/java/org/jboss/seam/infinispan/event/cache/CacheEntryInvalidatedAdapter.java

@@ -0,0 +1,61 @@
+package org.jboss.seam.infinispan.event.cache;
+
+import javax.enterprise.event.Event;
+
+import org.infinispan.Cache;
+import org.infinispan.notifications.Listener;
+import org.infinispan.notifications.cachelistener.annotation.CacheEntryInvalidated;
+import org.infinispan.notifications.cachelistener.event.CacheEntryInvalidatedEvent;
+import org.infinispan.transaction.xa.GlobalTransaction;
+
+@Listener
+public class CacheEntryInvalidatedAdapter extends AbstractAdapter<CacheEntryInvalidatedEvent>
+{
+
+   public static final CacheEntryInvalidatedEvent EMTPTY = new CacheEntryInvalidatedEvent()
+   {
+
+      public Type getType()
+      {
+         return null;
+      }
+
+      public Object getKey()
+      {
+         return null;
+      }
+
+      public GlobalTransaction getGlobalTransaction()
+      {
+         return null;
+      }
+
+      public boolean isOriginLocal()
+      {
+         // TODO Auto-generated method stub
+         return false;
+      }
+
+      public boolean isPre()
+      {
+         return false;
+      }
+
+      public Cache<?, ?> getCache()
+      {
+         return null;
+      }
+   };
+
+   public CacheEntryInvalidatedAdapter(Event<CacheEntryInvalidatedEvent> event)
+   {
+      super(event);
+   }
+
+   @CacheEntryInvalidated
+   public void fire(CacheEntryInvalidatedEvent payload)
+   {
+      super.fire(payload);
+   }
+
+}

src/main/java/org/jboss/seam/infinispan/event/cache/CacheEntryLoadedAdapter.java

@@ -0,0 +1,61 @@
+package org.jboss.seam.infinispan.event.cache;
+
+import javax.enterprise.event.Event;
+
+import org.infinispan.Cache;
+import org.infinispan.notifications.Listener;
+import org.infinispan.notifications.cachelistener.annotation.CacheEntryLoaded;
+import org.infinispan.notifications.cachelistener.event.CacheEntryLoadedEvent;
+import org.infinispan.transaction.xa.GlobalTransaction;
+
+@Listener
+public class CacheEntryLoadedAdapter extends AbstractAdapter<CacheEntryLoadedEvent>
+{
+
+   public static final CacheEntryLoadedEvent EMTPTY = new CacheEntryLoadedEvent()
+   {
+
+      public Type getType()
+      {
+         return null;
+      }
+
+      public Object getKey()
+      {
+         return null;
+      }
+
+      public GlobalTransaction getGlobalTransaction()
+      {
+         return null;
+      }
+
+      public boolean isOriginLocal()
+      {
+         // TODO Auto-generated method stub
+         return false;
+      }
+
+      public boolean isPre()
+      {
+         return false;
+      }
+
+      public Cache<?, ?> getCache()
+      {
+         return null;
+      }
+   };
+
+   public CacheEntryLoadedAdapter(Event<CacheEntryLoadedEvent> event)
+   {
+      super(event);
+   }
+
+   @CacheEntryLoaded
+   public void fire(CacheEntryLoadedEvent payload)
+   {
+      super.fire(payload);
+   }
+
+}