feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/javax/management/NotificationBroadcasterSupport.java

@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package javax.management;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executor;
+
+import com.sun.jmx.remote.util.ClassLogger;
+
+/**
+ * <p>Provides an implementation of {@link
+ * javax.management.NotificationEmitter NotificationEmitter}
+ * interface.  This can be used as the super class of an MBean that
+ * sends notifications.</p>
+ *
+ * <p>By default, the notification dispatch model is synchronous.
+ * That is, when a thread calls sendNotification, the
+ * <code>NotificationListener.handleNotification</code> method of each listener
+ * is called within that thread. You can override this default
+ * by overriding <code>handleNotification</code> in a subclass, or by passing an
+ * Executor to the constructor.</p>
+ *
+ * <p>If the method call of a filter or listener throws an {@link Exception},
+ * then that exception does not prevent other listeners from being invoked.  However,
+ * if the method call of a filter or of {@code Executor.execute} or of
+ * {@code handleNotification} (when no {@code Excecutor} is specified) throws an
+ * {@link Error}, then that {@code Error} is propagated to the caller of
+ * {@link #sendNotification sendNotification}.</p>
+ *
+ * <p>Remote listeners added using the JMX Remote API (see JMXConnector) are not
+ * usually called synchronously.  That is, when sendNotification returns, it is
+ * not guaranteed that any remote listeners have yet received the notification.</p>
+ *
+ * @since 1.5
+ */
+public class NotificationBroadcasterSupport implements NotificationEmitter {
+    /**
+     * Constructs a NotificationBroadcasterSupport where each listener is invoked by the
+     * thread sending the notification. This constructor is equivalent to
+     * {@link NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor,
+     * MBeanNotificationInfo[] info) NotificationBroadcasterSupport(null, null)}.
+     */
+    public NotificationBroadcasterSupport() {
+        this(null, (MBeanNotificationInfo[]) null);
+    }
+
+    /**
+     * Constructs a NotificationBroadcasterSupport where each listener is invoked using
+     * the given {@link java.util.concurrent.Executor}. When {@link #sendNotification
+     * sendNotification} is called, a listener is selected if it was added with a null
+     * {@link NotificationFilter}, or if {@link NotificationFilter#isNotificationEnabled
+     * isNotificationEnabled} returns true for the notification being sent. The call to
+     * <code>NotificationFilter.isNotificationEnabled</code> takes place in the thread
+     * that called <code>sendNotification</code>. Then, for each selected listener,
+     * {@link Executor#execute executor.execute} is called with a command
+     * that calls the <code>handleNotification</code> method.
+     * This constructor is equivalent to
+     * {@link NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor,
+     * MBeanNotificationInfo[] info) NotificationBroadcasterSupport(executor, null)}.
+     * @param executor an executor used by the method <code>sendNotification</code> to
+     * send each notification. If it is null, the thread calling <code>sendNotification</code>
+     * will invoke the <code>handleNotification</code> method itself.
+     * @since 1.6
+     */
+    public NotificationBroadcasterSupport(Executor executor) {
+        this(executor, (MBeanNotificationInfo[]) null);
+    }
+
+    /**
+     * <p>Constructs a NotificationBroadcasterSupport with information
+     * about the notifications that may be sent.  Each listener is
+     * invoked by the thread sending the notification.  This
+     * constructor is equivalent to {@link
+     * NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor,
+     * MBeanNotificationInfo[] info)
+     * NotificationBroadcasterSupport(null, info)}.</p>
+     *
+     * <p>If the <code>info</code> array is not empty, then it is
+     * cloned by the constructor as if by {@code info.clone()}, and
+     * each call to {@link #getNotificationInfo()} returns a new
+     * clone.</p>
+     *
+     * @param info an array indicating, for each notification this
+     * MBean may send, the name of the Java class of the notification
+     * and the notification type.  Can be null, which is equivalent to
+     * an empty array.
+     *
+     * @since 1.6
+     */
+    public NotificationBroadcasterSupport(MBeanNotificationInfo... info) {
+        this(null, info);
+    }
+
+    /**
+     * <p>Constructs a NotificationBroadcasterSupport with information about the notifications that may be sent,
+     * and where each listener is invoked using the given {@link java.util.concurrent.Executor}.</p>
+     *
+     * <p>When {@link #sendNotification sendNotification} is called, a
+     * listener is selected if it was added with a null {@link
+     * NotificationFilter}, or if {@link
+     * NotificationFilter#isNotificationEnabled isNotificationEnabled}
+     * returns true for the notification being sent. The call to
+     * <code>NotificationFilter.isNotificationEnabled</code> takes
+     * place in the thread that called
+     * <code>sendNotification</code>. Then, for each selected
+     * listener, {@link Executor#execute executor.execute} is called
+     * with a command that calls the <code>handleNotification</code>
+     * method.</p>
+     *
+     * <p>If the <code>info</code> array is not empty, then it is
+     * cloned by the constructor as if by {@code info.clone()}, and
+     * each call to {@link #getNotificationInfo()} returns a new
+     * clone.</p>
+     *
+     * @param executor an executor used by the method
+     * <code>sendNotification</code> to send each notification. If it
+     * is null, the thread calling <code>sendNotification</code> will
+     * invoke the <code>handleNotification</code> method itself.
+     *
+     * @param info an array indicating, for each notification this
+     * MBean may send, the name of the Java class of the notification
+     * and the notification type.  Can be null, which is equivalent to
+     * an empty array.
+     *
+     * @since 1.6
+     */
+    public NotificationBroadcasterSupport(Executor executor,
+                                          MBeanNotificationInfo... info) {
+        this.executor = (executor != null) ? executor : defaultExecutor;
+
+        notifInfo = info == null ? NO_NOTIFICATION_INFO : info.clone();
+    }
+
+    /**
+     * Adds a listener.
+     *
+     * @param listener The listener to receive notifications.
+     * @param filter The filter object. If filter is null, no
+     * filtering will be performed before handling notifications.
+     * @param handback An opaque object to be sent back to the
+     * listener when a notification is emitted. This object cannot be
+     * used by the Notification broadcaster object. It should be
+     * resent unchanged with the notification to the listener.
+     *
+     * @exception IllegalArgumentException thrown if the listener is null.
+     *
+     * @see #removeNotificationListener
+     */
+    public void addNotificationListener(NotificationListener listener,
+                                        NotificationFilter filter,
+                                        Object handback) {
+
+        if (listener == null) {
+            throw new IllegalArgumentException ("Listener can't be null") ;
+        }
+
+        listenerList.add(new ListenerInfo(listener, filter, handback));
+    }
+
+    public void removeNotificationListener(NotificationListener listener)
+            throws ListenerNotFoundException {
+
+        ListenerInfo wildcard = new WildcardListenerInfo(listener);
+        boolean removed =
+            listenerList.removeAll(Collections.singleton(wildcard));
+        if (!removed)
+            throw new ListenerNotFoundException("Listener not registered");
+    }
+
+    public void removeNotificationListener(NotificationListener listener,
+                                           NotificationFilter filter,
+                                           Object handback)
+            throws ListenerNotFoundException {
+
+        ListenerInfo li = new ListenerInfo(listener, filter, handback);
+        boolean removed = listenerList.remove(li);
+        if (!removed) {
+            throw new ListenerNotFoundException("Listener not registered " +
+                                                "(with this filter and " +
+                                                "handback)");
+            // or perhaps not registered at all
+        }
+    }
+
+    public MBeanNotificationInfo[] getNotificationInfo() {
+        if (notifInfo.length == 0)
+            return notifInfo;
+        else
+            return notifInfo.clone();
+    }
+
+
+    /**
+     * Sends a notification.
+     *
+     * If an {@code Executor} was specified in the constructor, it will be given one
+     * task per selected listener to deliver the notification to that listener.
+     *
+     * @param notification The notification to send.
+     */
+    public void sendNotification(Notification notification) {
+
+        if (notification == null) {
+            return;
+        }
+
+        boolean enabled;
+
+        for (ListenerInfo li : listenerList) {
+            try {
+                enabled = li.filter == null ||
+                    li.filter.isNotificationEnabled(notification);
+            } catch (Exception e) {
+                if (logger.debugOn()) {
+                    logger.debug("sendNotification", e);
+                }
+
+                continue;
+            }
+
+            if (enabled) {
+                executor.execute(new SendNotifJob(notification, li));
+            }
+        }
+    }
+
+    /**
+     * <p>This method is called by {@link #sendNotification
+     * sendNotification} for each listener in order to send the
+     * notification to that listener.  It can be overridden in
+     * subclasses to change the behavior of notification delivery,
+     * for instance to deliver the notification in a separate
+     * thread.</p>
+     *
+     * <p>The default implementation of this method is equivalent to
+     * <pre>
+     * listener.handleNotification(notif, handback);
+     * </pre>
+     *
+     * @param listener the listener to which the notification is being
+     * delivered.
+     * @param notif the notification being delivered to the listener.
+     * @param handback the handback object that was supplied when the
+     * listener was added.
+     *
+     */
+    protected void handleNotification(NotificationListener listener,
+                                      Notification notif, Object handback) {
+        listener.handleNotification(notif, handback);
+    }
+
+    // private stuff
+    private static class ListenerInfo {
+        NotificationListener listener;
+        NotificationFilter filter;
+        Object handback;
+
+        ListenerInfo(NotificationListener listener,
+                     NotificationFilter filter,
+                     Object handback) {
+            this.listener = listener;
+            this.filter = filter;
+            this.handback = handback;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof ListenerInfo))
+                return false;
+            ListenerInfo li = (ListenerInfo) o;
+            if (li instanceof WildcardListenerInfo)
+                return (li.listener == listener);
+            else
+                return (li.listener == listener && li.filter == filter
+                        && li.handback == handback);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hashCode(listener);
+        }
+    }
+
+    private static class WildcardListenerInfo extends ListenerInfo {
+        WildcardListenerInfo(NotificationListener listener) {
+            super(listener, null, null);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            assert (!(o instanceof WildcardListenerInfo));
+            return o.equals(this);
+        }
+
+        @Override
+        public int hashCode() {
+            return super.hashCode();
+        }
+    }
+
+    private List<ListenerInfo> listenerList =
+        new CopyOnWriteArrayList<ListenerInfo>();
+
+    // since 1.6
+    private final Executor executor;
+    private final MBeanNotificationInfo[] notifInfo;
+
+    private final static Executor defaultExecutor = new Executor() {
+            // DirectExecutor using caller thread
+            public void execute(Runnable r) {
+                r.run();
+            }
+        };
+
+    private static final MBeanNotificationInfo[] NO_NOTIFICATION_INFO =
+        new MBeanNotificationInfo[0];
+
+    private class SendNotifJob implements Runnable {
+        public SendNotifJob(Notification notif, ListenerInfo listenerInfo) {
+            this.notif = notif;
+            this.listenerInfo = listenerInfo;
+        }
+
+        public void run() {
+            try {
+                handleNotification(listenerInfo.listener,
+                                   notif, listenerInfo.handback);
+            } catch (Exception e) {
+                if (logger.debugOn()) {
+                    logger.debug("SendNotifJob-run", e);
+                }
+            }
+        }
+
+        private final Notification notif;
+        private final ListenerInfo listenerInfo;
+    }
+
+    private static final ClassLogger logger =
+        new ClassLogger("javax.management", "NotificationBroadcasterSupport");
+}