public InvalidationManager() 
{
 super();
}

 public  void batchInvalidate(BatchInvalidation[] invalidations) 
{
      this.batchInvalidate (invalidations, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
}

 public  void batchInvalidate(BatchInvalidation[] invalidations,
    boolean asynchronous) 
{
      if (log.isTraceEnabled ())
         log.trace ("Batch cache invalidation. Caches concerned: " + invalidations.length);
      this.crossDomainBatchInvalidate (null, invalidations, asynchronous);
}

 protected  void bridgeGroupInvalidateAllEvent(BridgeInvalidationSubscriptionImpl source,
    String groupName) 
{
      doBridgedOnlyInvalidateAll (source, groupName);
      doLocalOnlyInvalidateAll (groupName, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
}

 protected  void bridgeGroupInvalidationEvent(BridgeInvalidationSubscriptionImpl source,
    String groupName,
    Serializable key) 
{
      doBridgedOnlyInvalidation (source, groupName, key);      
      doLocalOnlyInvalidation (groupName, key, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
}

 protected  void bridgeGroupInvalidationEvent(BridgeInvalidationSubscriptionImpl source,
    String groupName,
    Serializable[] keys) 
{
      doBridgedOnlyInvalidation (source, groupName, keys);      
      doLocalOnlyInvalidation (groupName, keys, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
}

 protected InvalidationGroup createGroup(String groupName) 
{
      InvalidationGroup group = new org.jboss.cache.invalidation.InvalidationManager.InvalidationGroupImpl (groupName);
      this.groups.put (groupName, group);
      // register the group with JMX so it can be easyly remotly
      // reached (and thus cache can be invalidated)
      //
      try
      {
         log.debug ("Creating and registering a new InvalidationGroup: " + groupName);
         javax.management.ObjectName groupObjectName = new javax.management.ObjectName (DEFAULT_INVALIDERS_JMX_NAME + ",GroupName="+groupName);
         this.getServer ().registerMBean (group, groupObjectName);      
      }
      catch (Exception e)
      {
         log.debug ("Problem while trying to register a new invalidation group in JMX", e);
      }
      // warn bridges
      //
      log.debug ("Informing bridges about new group creation ...");
      for (int i=0; i< bridgeSubscribers.size (); i++)
         ((BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i))).groupCreated (groupName);
      return group;
}

 protected  void crossDomainBatchInvalidate(BridgeInvalidationSubscriptionImpl source,
    BatchInvalidation[] invalidations,
    boolean asynchronous) 
{
      if (invalidations == null)
         return;
      // local invalidation first
      //
      for (int i=0; i< invalidations.length; i++)
      {
         BatchInvalidation currInvalid = invalidations[i];
         doLocalOnlyInvalidations (currInvalid.getInvalidationGroupName (),
                                  currInvalid.getIds (), 
                                  asynchronous);
      }
      // bridged invalidation next
      //
      for (int i=0; i< bridgeSubscribers.size (); i++)
      {
         BridgeInvalidationSubscriptionImpl bridge = (BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i));
         if (bridge != source)
            bridge.bridgedBatchInvalidations  (invalidations, asynchronous);
      }
}

 protected  void crossDomainInvalidateAll(BridgeInvalidationSubscriptionImpl source,
    String groupName,
    boolean asynchronous) 
{
      // local invalidation first
      //
      doLocalOnlyInvalidateAll(groupName, asynchronous);
      // bridged invalidation next
      //
      for (int i=0; i< bridgeSubscribers.size (); i++)
      {
         BridgeInvalidationSubscriptionImpl bridge = (BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i));
         if (bridge != source)
            bridge.bridgedInvalidateAll(groupName, asynchronous);
      }
}

 protected  void doBridgedOnlyInvalidateAll(BridgeInvalidationSubscriptionImpl exceptSource,
    String groupName) 
{
      for (int i=0; i< bridgeSubscribers.size (); i++)
      {
         BridgeInvalidationSubscriptionImpl bridge = (BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i));
         if (bridge != exceptSource)
            bridge.bridgedInvalidateAll (groupName, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
      }
}

 protected  void doBridgedOnlyInvalidation(BridgeInvalidationSubscriptionImpl exceptSource,
    String groupName,
    Serializable key) 
{
      for (int i=0; i< bridgeSubscribers.size (); i++)
      {
         BridgeInvalidationSubscriptionImpl bridge = (BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i));
         if (bridge != exceptSource)
            bridge.bridgedInvalidate (groupName, key, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
      }
}

 protected  void doBridgedOnlyInvalidation(BridgeInvalidationSubscriptionImpl exceptSource,
    String groupName,
    Serializable[] keys) 
{
      for (int i=0; i< bridgeSubscribers.size (); i++)
      {
         BridgeInvalidationSubscriptionImpl bridge = (BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i));
         if (bridge != exceptSource)
            bridge.bridgedInvalidate (groupName, keys, this.DEFAULT_TO_ASYNCHRONOUS_MODE);
      }
}

 protected  void doLocalOnlyInvalidateAll(String groupName,
    boolean asynchronous) 
{
      InvalidationGroupImpl group = (InvalidationGroupImpl)this.groups.get (groupName);
      if (group != null)
         group.localOnlyInvalidateAll();
}

 protected  void doLocalOnlyInvalidation(String groupName,
    Serializable key,
    boolean asynchronous) 
{
      InvalidationGroupImpl group = (InvalidationGroupImpl)this.groups.get (groupName);
      if (group != null)
         group.localOnlyInvalidate (key, asynchronous);
}

 protected  void doLocalOnlyInvalidations(String groupName,
    Serializable[] keys,
    boolean asynchronous) 
{
      InvalidationGroupImpl group = (InvalidationGroupImpl)this.groups.get (groupName);
      if (group != null)
         group.localOnlyInvalidate (keys, asynchronous);
}

 public InvalidationGroup getInvalidationGroup(String groupName) 
{
      synchronized (this.groups)
      {
         InvalidationGroup group = (InvalidationGroup)this.groups.get (groupName);
         if (group == null)
         {
            group = createGroup (groupName);
         }
         group.addReference ();
         return group;
      }
}

 public Collection getInvalidationGroups() 
{
      return this.groups.values ();
}

 public boolean getIsAsynchByDefault() 
{
      return DEFAULT_TO_ASYNCHRONOUS_MODE;
}

 public int hashCode() 
{
      return hashcode;
}

 public  void invalidateAll(String groupName) 
{
      invalidateAll(groupName, DEFAULT_TO_ASYNCHRONOUS_MODE);
}

 public  void invalidateAll(String groupName,
    boolean async) 
{
      if (log.isTraceEnabled ())
         log.trace ("Invalidate all for group: " + groupName);
      crossDomainInvalidateAll(null, groupName, async);
}

 protected  void localGroupInvalidateAllEvent(String groupName,
    boolean asynchronous) 
{
      for (int i=0; i< bridgeSubscribers.size (); i++)
         ((BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i))).bridgedInvalidateAll (groupName, asynchronous);
}

 protected  void localGroupInvalidationEvent(String groupName,
    Serializable key,
    boolean asynchronous) 
{
      for (int i=0; i< bridgeSubscribers.size (); i++)
         ((BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i))).bridgedInvalidate (groupName, key, asynchronous);
}

 protected  void localGroupInvalidationsEvent(String groupName,
    Serializable[] keys,
    boolean asynchronous) 
{
      for (int i=0; i< bridgeSubscribers.size (); i++)
         ((BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i))).bridgedInvalidate (groupName, keys, asynchronous);
}

 public synchronized BridgeInvalidationSubscription registerBridgeListener(InvalidationBridgeListener listener) 
{
      log.debug ("Subscribing a new cache-invalidation bridge");
      BridgeInvalidationSubscription subs = new BridgeInvalidationSubscriptionImpl(listener);
      java.util.Vector newVector = new java.util.Vector (this.bridgeSubscribers);
      newVector.add (subs);
      this.bridgeSubscribers = newVector;      
      return subs;
}

 protected  void removeGroup(String groupName) 
{
      synchronized (this.groups)
      {
         this.groups.remove (groupName);
         // Remove group from JMX
         //
         try
         {
            log.debug ("Removing and JMX-unregistering an InvalidationGroup: " + groupName);
            javax.management.ObjectName groupObjectName = new javax.management.ObjectName (DEFAULT_INVALIDERS_JMX_NAME + ",GroupName="+groupName);
            this.getServer ().unregisterMBean (groupObjectName);      
         }
         catch (Exception e)
         {
            log.debug ("Problem while trying to un-register a new invalidation group in JMX", e);
         }
         // warn bridges
         //
         for (int i=0; i< bridgeSubscribers.size (); i++)
            ((BridgeInvalidationSubscriptionImpl)(bridgeSubscribers.elementAt (i))).groupDropped (groupName);
      }
}

 public  void setIsAsynchByDefault(boolean flag) 
{
      this.DEFAULT_TO_ASYNCHRONOUS_MODE = flag;
}

 public  void startService() throws Exception 
{
      // bind us in system registry
      //
      log.debug ("Starting Invalidation Manager " + this.getServiceName ().toString ());
      org.jboss.system.Registry.bind (this.getServiceName ().toString (), this);
      this.hashcode = this.getServiceName ().hashCode ();
}

 public  void stopService() 
{
      log.debug ("Stoping Invalidation Manager " + this.getServiceName ().toString ());
      org.jboss.system.Registry.unbind (this.getServiceName ().toString ());
}

 protected synchronized  void unregisterBridgeListener(BridgeInvalidationSubscription bridgeSubscriber) 
{
      // safe remove to avoid problems with iterators
      //
      log.debug ("Unsubscription of a cache-invalidation bridge");
      java.util.Vector newVector = new java.util.Vector (this.bridgeSubscribers);
      newVector.remove (bridgeSubscriber);
      this.bridgeSubscribers = newVector;
}