PC Professionell 2004 December/PCpro_2004_12.ISO/files/webserver/xampp/xampp-tomcat-addon-1.4.9-installer.exe/jmx.jar/javax/management/NotificationBroadcasterSupport.class

Java Class File | 2002-10-28 | 6.6 KB | 200 lines

package javax.management;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import mx4j.log.Log;
import mx4j.log.Logger;

public class NotificationBroadcasterSupport implements NotificationBroadcaster {
   private static final NotificationFilter NULL_FILTER = new 1();
   private static final Object NULL_HANDBACK = new 2();
   private HashMap m_listeners = new HashMap();

   private Logger getLogger() {
      return Log.getLogger(this.getClass().getName());
   }

   public void addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) {
      Logger logger = this.getLogger();
      if (logger.isEnabledFor(20)) {
         logger.info("Adding notification listener: " + listener + ", filter: " + filter + ", handback: " + handback);
      }

      if (listener == null) {
         throw new RuntimeOperationsException(new IllegalArgumentException("Notification listener cannot be null"));
      } else {
         if (filter == null) {
            filter = NULL_FILTER;
         }

         if (handback == null) {
            handback = NULL_HANDBACK;
         }

         FilterHandbackPair pair = new FilterHandbackPair(filter, handback);
         synchronized(this) {
            ArrayList pairs = (ArrayList)this.m_listeners.get(listener);
            if (pairs == null) {
               pairs = new ArrayList();
               pairs.add(pair);
               this.m_listeners.put(listener, pairs);
            } else {
               for(int i = 0; i < pairs.size(); ++i) {
                  FilterHandbackPair other = (FilterHandbackPair)pairs.get(i);
                  if (pair.getNotificationFilter().equals(other.getNotificationFilter()) && pair.getHandback().equals(other.getHandback())) {
                     throw new RuntimeOperationsException(new IllegalArgumentException("Notification listener is already registered"));
                  }
               }

               pairs.add(pair);
            }

            if (logger.isEnabledFor(10)) {
               logger.debug("Filters - Handbacks for this listener: " + pairs);
            }
         }

         if (logger.isEnabledFor(20)) {
            logger.info("Notification listener added successfully");
         }

      }
   }

   public void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException {
      Logger logger = this.getLogger();
      if (logger.isEnabledFor(20)) {
         logger.info("Removing notification listener: " + listener);
      }

      int removed = this.removeNotificationListenerImpl(listener, (NotificationFilter)null, (Object)null);
      if (logger.isEnabledFor(20)) {
         logger.info(removed + "notification listener(s) removed successfully");
      }

   }

   private int removeNotificationListenerImpl(NotificationListener listener, NotificationFilter filter, Object handback) throws ListenerNotFoundException {
      synchronized(this) {
         ArrayList pairs = (ArrayList)this.m_listeners.get(listener);
         if (pairs == null) {
            throw new ListenerNotFoundException("Notification listener not found");
         } else if (filter == null) {
            if (handback == null) {
               ArrayList removed = (ArrayList)this.m_listeners.remove(listener);
               return removed.size();
            } else {
               int count = 0;

               for(int i = 0; i < pairs.size(); ++i) {
                  Object hand = ((FilterHandbackPair)pairs.get(i)).getHandback();
                  if (handback.equals(hand)) {
                     pairs.remove(i);
                     ++count;
                  }
               }

               if (pairs.isEmpty()) {
                  this.m_listeners.remove(listener);
               }

               return count;
            }
         } else if (handback == null) {
            int count = 0;

            for(int i = 0; i < pairs.size(); ++i) {
               Object filt = ((FilterHandbackPair)pairs.get(i)).getNotificationFilter();
               if (filter.equals(filt)) {
                  pairs.remove(i);
                  ++count;
               }
            }

            if (pairs.isEmpty()) {
               this.m_listeners.remove(listener);
            }

            return count;
         } else {
            int count = 0;

            for(int i = 0; i < pairs.size(); ++i) {
               FilterHandbackPair pair = (FilterHandbackPair)pairs.get(i);
               if (filter.equals(pair.getNotificationFilter()) && handback.equals(pair.getHandback())) {
                  pairs.remove(i);
                  ++count;
               }
            }

            if (pairs.isEmpty()) {
               this.m_listeners.remove(listener);
            }

            return count;
         }
      }
   }

   public MBeanNotificationInfo[] getNotificationInfo() {
      return new MBeanNotificationInfo[0];
   }

   private boolean hasListeners() {
      synchronized(this) {
         return this.m_listeners.size() > 0;
      }
   }

   public void sendNotification(Notification n) {
      Logger logger = this.getLogger();
      boolean debug = logger.isEnabledFor(10);
      boolean info = logger.isEnabledFor(20);
      HashMap listeners = null;
      synchronized(this) {
         listeners = (HashMap)this.m_listeners.clone();
      }

      Iterator i = listeners.keySet().iterator();
      if (i.hasNext() && info) {
         logger.info("Sending notifications...");
      }

      while(i.hasNext()) {
         NotificationListener listener = (NotificationListener)i.next();
         if (info) {
            logger.info("\tListener is: " + listener);
         }

         ArrayList pairs = null;
         synchronized(this) {
            pairs = (ArrayList)this.m_listeners.get(listener);
            pairs = (ArrayList)pairs.clone();
         }

         if (debug) {
            logger.debug("\tFilters - Handback for this listener: " + pairs);
         }

         for(int j = 0; j < pairs.size(); ++j) {
            FilterHandbackPair pair = (FilterHandbackPair)pairs.get(j);
            NotificationFilter filter = pair.getNotificationFilter();
            Object hb = pair.getHandback();
            if (hb == NULL_HANDBACK) {
               hb = null;
            }

            Runnable run = new 3(this, filter, n, info, logger, hb, listener);
            if (listener instanceof Serializable) {
               (new Thread(run, "NotificationBroadcasterSupport Thread")).start();
            } else {
               run.run();
            }
         }
      }

   }
}