1. 包列表
  2. 类列表
  3. org.bukkit.plugin.RegisteredListener

Java 类org.bukkit.plugin.RegisteredListener 实例源码

项目：EscapeLag    文件：EventExecutorInjector.java    
/**
 * 
 * @author jiongjionger,Vlvxingze
 */

// 将监听器原本的EventExecutor替换成带性能统计的版本
public static void inject(Plugin plg) {
    if (plg != null) {
        for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) {
            try {
                FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class);
                EventExecutor fieldEventExecutor = field.get(listener);
                field.set(listener, new EventExecutorInjector(plg, fieldEventExecutor));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
项目：DiscordSRV    文件：CancellationDetector.java    
private RegisteredListener injectRegisteredListener(final RegisteredListener listener) {
    return new DelegatedRegisteredListener(listener) {
        @SuppressWarnings("unchecked")
        @Override
        public void callEvent(Event event) throws EventException {
            if (event instanceof Cancellable) {
                boolean prior = getCancelState(event);

                listener.callEvent(event);

                // See if this plugin cancelled the event
                if (!prior && getCancelState(event)) {
                    invokeCancelled(getPlugin(), (TEvent) event);
                }
            } else {
                listener.callEvent(event);
            }
        }
    };
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：AnnihilationPro    文件：ItemMenuListener.java    
/**
 * Checks if the {@link ninja.amp.ampmenus.MenuListener} is registered to a
 * plugin.
 *
 * @param plugin
 *            The plugin.
 * @return True if the {@link ninja.amp.ampmenus.MenuListener} is registered
 *         to the plugin, else false.
 */
public boolean isRegistered(JavaPlugin plugin)
{
    if (plugin.equals(this.plugin))
    {
        for (RegisteredListener listener : HandlerList
                .getRegisteredListeners(plugin))
        {
            if (listener.getListener().equals(INSTANCE))
            {
                return true;
            }
        }
    }
    return false;
}
项目：ExilePearl    文件：TestPluginManager.java    
@Override
public void registerEvent(Class<? extends Event> event, Listener listener, EventPriority priority, EventExecutor executor, Plugin plugin, boolean ignoreCancelled) {
       Validate.notNull(listener, "Listener cannot be null");
       Validate.notNull(priority, "Priority cannot be null");
       Validate.notNull(executor, "Executor cannot be null");
       Validate.notNull(plugin, "Plugin cannot be null");

       if (!plugin.isEnabled()) {
           throw new IllegalPluginAccessException("Plugin attempted to register " + event + " while not enabled");
       }

       if (useTimings) {
           getEventListeners(event).register(new TimedRegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
       } else {
           getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
       }
}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：NerdLag    文件：NerdLag.java    
/**
 * Configure event handling for the specified plugins to monitor event
 * handler durations, including the maximum duration of any callback.
 *
 * @param plugins the set of plugins to instrument.
 * @param report if true, plugin event handler durations that exceed the
 *        threshold will be reported.
 * @param reportThresholdNanos the threshold duration in nanoseconds, above
 *        which an event handler execution is reportable.
 */
protected void watchPlugins(Set<Plugin> plugins, boolean report, long reportThresholdNanos) {
    for (HandlerList handlerList : HandlerList.getHandlerLists()) {
        RegisteredListener[] listeners = handlerList.getRegisteredListeners();
        for (RegisteredListener oldListener : listeners) {
            if (plugins.contains(oldListener.getPlugin())) {
                MaxTimedRegisteredListener newListener;
                try {
                    newListener = new MaxTimedRegisteredListener(oldListener, report, reportThresholdNanos, this);
                    handlerList.unregister(oldListener);
                    handlerList.register(newListener);
                } catch (Exception ex) {
                    getLogger().warning("watchPlugins(): " + ex.getClass().getName());
                }
            }
        }
        handlerList.bake();
    }
}
项目：Cauldron    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：Cauldron    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：Cauldron    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：Almura-API    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：Bukkit-Connect    文件：HandlerListInjector.java    
@Override
public synchronized void bake() {
    super.bake();
    RegisteredListener[] handlers = super.getRegisteredListeners();
    // TODO we can speed this up greatly using arrays. It's not really necessary though, as this isn't a hot function
    for(RegisteredListener handler : handlers) {
        if(handler.getPlugin().equals(plugin)) {
            if(handler.getPriority().equals(EventPriority.LOWEST)) {
                this.startListeners.add(handler);
                continue;
            } else if(handler.getPriority().equals(EventPriority.MONITOR)) {
                this.endListeners.add(handler);
                continue;
            }
        }
        this.middleListeners.add(handler);
    }
    List<RegisteredListener> handlerList = new ArrayList<RegisteredListener>(handlers.length);
    handlerList.addAll(this.startListeners);
    handlerList.addAll(this.middleListeners);
    handlerList.addAll(this.endListeners);
    handlerList.toArray(handlers);
}
项目：Spigot-API    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：Bukkit-JavaDoc    文件：HandlerList.java    
/**
 * Get a specific plugin's registered listeners associated with this
 * handler list
 *
 * @param plugin the plugin to get the listeners of
 * @return the list of registered listeners
 */
public static ArrayList<RegisteredListener> getRegisteredListeners(Plugin plugin) {
    ArrayList<RegisteredListener> listeners = new ArrayList<RegisteredListener>();
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    for (RegisteredListener listener : list) {
                        if (listener.getPlugin().equals(plugin)) {
                            listeners.add(listener);
                        }
                    }
                }
            }
        }
    }
    return listeners;
}
项目：EscapeLag    文件：MonitorUtils.java    
public static Map<String, MonitorRecord> getEventTimingsByPlugin(Plugin plg) {
    Map<String, MonitorRecord> record = new HashMap<>();
    if (plg == null) {
        return record;
    }
    for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) {
        try {
            FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor",
                    EventExecutor.class);
            EventExecutor executor = field.get(listener);
            if (executor instanceof EventExecutorInjector) {
                EventExecutorInjector eventExecutorInjector = (EventExecutorInjector) executor;
                String eventName = eventExecutorInjector.getEventName();
                if (eventName != null) {
                    MonitorRecord monitorRecord = getMonitorRecord(eventName, eventExecutorInjector.getTotalTime(),
                            eventExecutorInjector.getTotalCount(), eventExecutorInjector.getMaxExecuteTime());
                    if (record.containsKey(eventName)) {
                        MonitorRecord otherMonitorRecord = record.get(eventName);
                        record.put(eventName, otherMonitorRecord.merge(monitorRecord));
                    } else {
                        record.put(eventName, monitorRecord);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return record;
}
项目：EscapeLag    文件：EventExecutorInjector.java    
public static void uninject(Plugin plg) {
    if (plg != null) {
        for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) {
            try {
                FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class);
                EventExecutor executor = field.get(listener);
                if (executor instanceof EventExecutorInjector) {
                    field.set(listener, ((EventExecutorInjector) executor).getEventExecutor());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
项目：NeverLag    文件：MonitorUtils.java    
public static Map<String, MonitorRecord> getEventTimingsByPlugin(Plugin plg) {
    Map<String, MonitorRecord> record = new HashMap<>();
    if (plg == null) {
        return record;
    }
    for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) {
        try {
            FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class);
            EventExecutor executor = field.get(listener);
            if (executor instanceof EventExecutorInjector) {
                EventExecutorInjector eventExecutorInjector = (EventExecutorInjector) executor;
                String eventName = eventExecutorInjector.getEventName();
                if (eventName != null) {
                    MonitorRecord monitorRecord = getMonitorRecord(eventName, eventExecutorInjector.getTotalTime(), eventExecutorInjector.getTotalCount(),
                        eventExecutorInjector.getMaxExecuteTime());
                    if (record.containsKey(eventName)) {
                        MonitorRecord otherMonitorRecord = record.get(eventName);
                        record.put(eventName, otherMonitorRecord.merge(monitorRecord));
                    } else {
                        record.put(eventName, monitorRecord);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return record;
}
项目：NeverLag    文件：EventExecutorInjector.java    
public static void inject(Plugin plg) {
    if (plg != null) {
        for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) {
            try {
                FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class);
                EventExecutor fieldEventExecutor = field.get(listener);
                field.set(listener, new EventExecutorInjector(plg, fieldEventExecutor));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
项目：NeverLag    文件：EventExecutorInjector.java    
public static void uninject(Plugin plg) {
    if (plg != null) {
        for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) {
            try {
                FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class);
                EventExecutor executor = field.get(listener);
                if (executor instanceof EventExecutorInjector) {
                    field.set(listener, ((EventExecutorInjector) executor).getEventExecutor());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
项目：MassiveCoreForgeFixes    文件：FactionsFixes.java    
@Override
public void disable() {
    HandlerList.unregisterAll(FactionsEvents.get());

    // Add back the previous factions registered listeners 
    for (RegisteredListener registeredListener: removedRegisteredListeners) PlayerMoveEvent.getHandlerList().register(registeredListener);
}
项目：DiscordSRV    文件：CancellationDetector.java    
@SuppressWarnings("unchecked")
private EnumMap<EventPriority, ArrayList<RegisteredListener>> getSlots(HandlerList list) {
    try {
        return (EnumMap<EventPriority, ArrayList<RegisteredListener>>) getSlotsField(list).get(list);
    } catch (Exception e) {
        throw new RuntimeException("Unable to retrieve slots.", e);
    }
}
项目：DiscordSRV    文件：CancellationDetector.java    
private void injectProxy() {
    HandlerList list = getHandlerList(eventClazz);
    EnumMap<EventPriority, ArrayList<RegisteredListener>> slots = getSlots(list);

    // Keep a copy of this map
    backup = slots.clone();

    synchronized (list) {
        for (EventPriority p : slots.keySet().toArray(new EventPriority[0])) {
            final EventPriority priority = p;
            final ArrayList<RegisteredListener> proxyList = new ArrayList<RegisteredListener>() {
                private static final long serialVersionUID = 7869505892922082581L;

                @Override
                public boolean add(RegisteredListener e) {
                    super.add(injectRegisteredListener(e));
                    return backup.get(priority).add(e);
                }

                @Override
                public boolean remove(Object listener) {
                    // Remove this listener
                    for (Iterator<RegisteredListener> it = iterator(); it.hasNext(); ) {
                        DelegatedRegisteredListener delegated = (DelegatedRegisteredListener) it.next();
                        if (delegated.delegate == listener) {
                            it.remove();
                            break;
                        }
                    }
                    return backup.get(priority).remove(listener);
                }
            };
            slots.put(priority, proxyList);

            proxyList.addAll(backup.get(priority));
        }
    }
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Unregister all listeners from all handler lists.
 */
public static void unregisterAll() {
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    list.clear();
                }
                h.handlers = null;
            }
        }
    }
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Create a new handler list and initialize using EventPriority.
 * <p>
 * The HandlerList is then added to meta-list for use in bakeAll()
 */
public HandlerList() {
    handlerslots = new EnumMap<EventPriority, ArrayList<RegisteredListener>>(EventPriority.class);
    for (EventPriority o : EventPriority.values()) {
        handlerslots.put(o, new ArrayList<RegisteredListener>());
    }
    synchronized (allLists) {
        allLists.add(this);
    }
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Register a new listener in this handler list
 *
 * @param listener listener to register
 */
public synchronized void register(RegisteredListener listener) {
    if (handlerslots.get(listener.getPriority()).contains(listener))
        throw new IllegalStateException("This listener is already registered to priority " + listener.getPriority().toString());
    handlers = null;
    handlerslots.get(listener.getPriority()).add(listener);
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Remove a specific plugin's listeners from this handler
 *
 * @param plugin plugin to remove
 */
public synchronized void unregister(Plugin plugin) {
    boolean changed = false;
    for (List<RegisteredListener> list : handlerslots.values()) {
        for (ListIterator<RegisteredListener> i = list.listIterator(); i.hasNext();) {
            if (i.next().getPlugin().equals(plugin)) {
                i.remove();
                changed = true;
            }
        }
    }
    if (changed) handlers = null;
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Remove a specific listener from this handler
 *
 * @param listener listener to remove
 */
public synchronized void unregister(Listener listener) {
    boolean changed = false;
    for (List<RegisteredListener> list : handlerslots.values()) {
        for (ListIterator<RegisteredListener> i = list.listIterator(); i.hasNext();) {
            if (i.next().getListener().equals(listener)) {
                i.remove();
                changed = true;
            }
        }
    }
    if (changed) handlers = null;
}
项目：Thermos-Bukkit    文件：HandlerList.java    
/**
 * Bake HashMap and ArrayLists to 2d array - does nothing if not necessary
 */
public synchronized void bake() {
    if (handlers != null) return; // don't re-bake when still valid
    List<RegisteredListener> entries = new ArrayList<RegisteredListener>();
    for (Entry<EventPriority, ArrayList<RegisteredListener>> entry : handlerslots.entrySet()) {
        entries.addAll(entry.getValue());
    }
    handlers = entries.toArray(new RegisteredListener[entries.size()]);
}
项目：LagMonitor    文件：ListenerInjector.java    
public static void inject(Plugin plugin) {
    List<RegisteredListener> listeners = HandlerList.getRegisteredListeners(plugin);
    for (RegisteredListener listener : listeners) {
        HandlerList.unregisterAll(listener.getListener());
        FieldAccessor<EventExecutor> executorField = Reflection
                .getField(RegisteredListener.class, "executor", EventExecutor.class);

        EventExecutor originalExecutor = executorField.get(listener);
        ListenerInjector listenerInjector = new ListenerInjector(originalExecutor);

        executorField.set(listener, listenerInjector);
    }
}
项目：LagMonitor    文件：ListenerInjector.java    
public static void uninject(Plugin plugin) {
    List<RegisteredListener> listeners = HandlerList.getRegisteredListeners(plugin);
    for (RegisteredListener listener : listeners) {
        HandlerList.unregisterAll(listener.getListener());
        FieldAccessor<EventExecutor> executorField = Reflection
                .getField(RegisteredListener.class, "executor", EventExecutor.class);

        EventExecutor executor = executorField.get(listener);
        if (executor instanceof ListenerInjector) {
            executorField.set(listener, ((ListenerInjector) executor).originalExecutor);
        }
    }
}
项目：Pokkit    文件：BukkitEventManager.java    
public void registerEvents(Listener listener, Plugin plugin) {
    if (!plugin.isEnabled()) {
        throw new IllegalPluginAccessException("Plugin attempted to register " + listener + " while not enabled");
    }

    for (Map.Entry<Class<? extends Event>, Set<RegisteredListener>> entry : plugin.getPluginLoader()
            .createRegisteredListeners(listener, plugin).entrySet()) {
        getEventListeners(getRegistrationClass(entry.getKey())).registerAll(entry.getValue());
    }

}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Unregister all listeners from all handler lists.
 */
public static void unregisterAll() {
    synchronized (allLists) {
        for (HandlerList h : allLists) {
            synchronized (h) {
                for (List<RegisteredListener> list : h.handlerslots.values()) {
                    list.clear();
                }
                h.handlers = null;
            }
        }
    }
}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Create a new handler list and initialize using EventPriority.
 * <p>
 * The HandlerList is then added to meta-list for use in bakeAll()
 */
public HandlerList() {
    handlerslots = new EnumMap<EventPriority, ArrayList<RegisteredListener>>(EventPriority.class);
    for (EventPriority o : EventPriority.values()) {
        handlerslots.put(o, new ArrayList<RegisteredListener>());
    }
    synchronized (allLists) {
        allLists.add(this);
    }
}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Register a new listener in this handler list
 *
 * @param listener listener to register
 */
public synchronized void register(RegisteredListener listener) {
    if (handlerslots.get(listener.getPriority()).contains(listener))
        throw new IllegalStateException("This listener is already registered to priority " + listener.getPriority().toString());
    handlers = null;
    handlerslots.get(listener.getPriority()).add(listener);
}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Remove a specific plugin's listeners from this handler
 *
 * @param plugin plugin to remove
 */
public synchronized void unregister(Plugin plugin) {
    boolean changed = false;
    for (List<RegisteredListener> list : handlerslots.values()) {
        for (ListIterator<RegisteredListener> i = list.listIterator(); i.hasNext();) {
            if (i.next().getPlugin().equals(plugin)) {
                i.remove();
                changed = true;
            }
        }
    }
    if (changed) handlers = null;
}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Remove a specific listener from this handler
 *
 * @param listener listener to remove
 */
public synchronized void unregister(Listener listener) {
    boolean changed = false;
    for (List<RegisteredListener> list : handlerslots.values()) {
        for (ListIterator<RegisteredListener> i = list.listIterator(); i.hasNext();) {
            if (i.next().getListener().equals(listener)) {
                i.remove();
                changed = true;
            }
        }
    }
    if (changed) handlers = null;
}
项目：CauldronGit    文件：HandlerList.java    
/**
 * Bake HashMap and ArrayLists to 2d array - does nothing if not necessary
 */
public synchronized void bake() {
    if (handlers != null) return; // don't re-bake when still valid
    List<RegisteredListener> entries = new ArrayList<RegisteredListener>();
    for (Entry<EventPriority, ArrayList<RegisteredListener>> entry : handlerslots.entrySet()) {
        entries.addAll(entry.getValue());
    }
    handlers = entries.toArray(new RegisteredListener[entries.size()]);
}
项目：MyiuLib    文件：MGUtil.java    
/**
 * Calls an event, but sends it only to the appropriate plugin.
 * <strong>Please do not call this from your pluginv unless you are aware of
 * the implications.</strong>
 *
 * @param event the event to call
 * @since 0.3.0
 */
public static void callEvent(MyiuLibEvent event) {
    HandlerList hl = event.getHandlers();
    for (RegisteredListener rl : hl.getRegisteredListeners()) {
        if (rl.getPlugin().getName().equals(event.getPlugin()) || rl.getPlugin().getName().equals("MyiuLib")) {
            try {
                rl.callEvent(event);
            }
            catch (EventException ex) {
                ex.printStackTrace();
            }
        }
    }
}
项目：SteakGUI    文件：MenuListener.java    
/**
 * Checks if the {@link ninja.amp.ampmenus.MenuListener} is registered to a plugin.
 *
 * @param plugin The plugin.
 * @return True if the {@link ninja.amp.ampmenus.MenuListener} is registered to the plugin, else false.
 */
public boolean isRegistered(JavaPlugin plugin) {
    if (plugin.equals(this.plugin)) {
        for (RegisteredListener listener : HandlerList.getRegisteredListeners(plugin)) {
            if (listener.getListener().equals(INSTANCE)) {
                return true;
            }
        }
    }
    return false;
}
项目：LagMonitor    文件：ListenerInjector.java    
public static void inject(Plugin plugin) {
    List<RegisteredListener> listeners = HandlerList.getRegisteredListeners(plugin);
    for (RegisteredListener listener : listeners) {
        HandlerList.unregisterAll(listener.getListener());
        FieldAccessor<EventExecutor> executorField = Reflection
                .getField(RegisteredListener.class, "executor", EventExecutor.class);

        EventExecutor originalExecutor = executorField.get(listener);
        ListenerInjector listenerInjector = new ListenerInjector(originalExecutor);

        executorField.set(listener, listenerInjector);
    }
}