@Override
 public void removeEvent(String listenerName, Event event) {
   Map<String, RegisteredListener> listeners = getListenersByEvent().get(event.getClass());
   RegisteredListener listener = listeners.get(listenerName);
   if (listener != null) {
     listener.removeEvent(event);
   }
 }
Example #2
0
 public void callEvent(Event event) {
   EventList events = event.getEvents();
   RegisteredListener[] listeners = events.getRegisteredListeners();
   for (RegisteredListener listen : listeners) {
     try {
       listen.execute(event);
     } catch (Exception e) {
       server.Log("==!EVENT ERROR!==");
       server.logError(e);
     }
   }
 }
 @Override
 public void addEvent(String listenerName, Event event) {
   Map<String, RegisteredListener> listeners = getListenersByEvent().get(event.getClass());
   if (listeners == null) {
     listeners = new ConcurrentHashMap<String, RegisteredListener>();
     this.listenersByEvent.put(event.getClass(), listeners);
   }
   RegisteredListener listener = listeners.get(listenerName);
   if (listener != null) {
     listener.addEvent(event);
   } else {
     listeners.put(listenerName, new RegisteredListener(this.getListener(listenerName), event));
   }
 }
Example #4
0
 /**
  * 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;
   if (listener.getPriority() == EventPriority.EXECUTOR && allowExecutor == false) {
     throw new IllegalStateException("an executor is not allowed for this event");
   }
   if (listener.getPriority() == EventPriority.EXECUTOR
       && handlerslots.get(EventPriority.EXECUTOR).isEmpty() == false) {
     throw new IllegalStateException("an executor is already registered for this event");
   }
   handlerslots.get(listener.getPriority()).add(listener);
 }
Example #5
0
 /**
  * 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(EventPlugin 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;
 }
  /**
   * Registers all the events in the given listener class.
   *
   * @param listener - listener to register
   * @param plugin - plugin to register
   */
  public void registerEvents(Listener listener, Plugin plugin) {
    if (!plugin.isEnabled())
      throw new IllegalPluginAccessException(
          "Plugin attempted to register " + listener + " while not enabled");

    // Just in case Bukkit decides to validate the parameters in the future
    EventExecutor nullExecutor =
        (arg0, arg1) -> {
          throw new IllegalStateException("This method should never be called!");
        };

    for (Entry<Class<? extends Event>, Set<RegisteredListener>> entry :
        plugin.getPluginLoader().createRegisteredListeners(listener, plugin).entrySet()) {

      Collection<RegisteredListener> listeners = entry.getValue();
      Collection<RegisteredListener> modified = Lists.newArrayList();

      // Use our plugin specific logger instead
      for (final RegisteredListener delegate : listeners) {
        RegisteredListener customListener =
            new RegisteredListener(
                delegate.getListener(),
                nullExecutor,
                delegate.getPriority(),
                delegate.getPlugin(),
                delegate.isIgnoringCancelled()) {
              @Override
              public void callEvent(Event event) throws EventException {
                try {
                  delegate.callEvent(event);
                } catch (AuthorNagException e) {
                  // Let Bukkit handle that one
                  throw e;
                } catch (Throwable e) {
                  customHandler(event, e);
                }
              }
            };

        modified.add(customListener);
      }

      getEventListeners(getRegistrationClass(entry.getKey())).registerAll(modified);
    }
  }
  @Override
  public void addListener(EventListener eventListener) {
    // Register the listener by name. If already registered, override it.
    EventListener previousListener =
        getListenersByName().put(eventListener.getName(), eventListener);

    // If the passed event listener name is already registered, log a warning
    if (previousListener != null) {
      this.logger.warn(
          "The [{}] listener has overwritten a previously "
              + "registered listener [{}] since they both are registered under the same id [{}]. "
              + "In the future consider removing a Listener first if you really want to register it again.",
          new Object[] {
            eventListener.getClass().getName(),
            previousListener.getClass().getName(),
            eventListener.getName()
          });
    }

    // For each event defined for this listener, add it to the Event Map.
    for (Event event : eventListener.getEvents()) {
      // Check if this is a new Event type not already registered
      Map<String, RegisteredListener> eventListeners = this.listenersByEvent.get(event.getClass());
      if (eventListeners == null) {
        // No listener registered for this event yet. Create a map to store listeners for this
        // event.
        eventListeners = new ConcurrentHashMap<String, RegisteredListener>();
        this.listenersByEvent.put(event.getClass(), eventListeners);
        // There is no RegisteredListener yet, create one
        eventListeners.put(eventListener.getName(), new RegisteredListener(eventListener, event));
      } else {
        // Add an event to existing RegisteredListener object
        RegisteredListener registeredListener = eventListeners.get(eventListener.getName());
        if (registeredListener == null) {
          eventListeners.put(eventListener.getName(), new RegisteredListener(eventListener, event));
        } else {
          registeredListener.addEvent(event);
        }
      }
    }
  }
  private void fireEvent(Event event) {
    HandlerList handlers = event.getHandlers();
    RegisteredListener[] listeners = handlers.getRegisteredListeners();

    for (RegisteredListener registration : listeners) {
      if (!registration.getPlugin().isEnabled()) {
        continue;
      }

      try {
        registration.callEvent(event);
      } catch (AuthorNagException ex) {
        Plugin plugin = registration.getPlugin();

        if (plugin.isNaggable()) {
          plugin.setNaggable(false);

          server
              .getLogger()
              .log(
                  Level.SEVERE,
                  String.format(
                      "Nag author(s): '%s' of '%s' about the following: %s",
                      plugin.getDescription().getAuthors(),
                      plugin.getDescription().getFullName(),
                      ex.getMessage()));
        }
      } catch (Throwable ex) {
        server
            .getLogger()
            .log(
                Level.SEVERE,
                "Could not pass event "
                    + event.getEventName()
                    + " to "
                    + registration.getPlugin().getDescription().getFullName(),
                ex);
      }
    }
  }
Example #9
0
 public void onRegistered() {
   if (listener != null) listener.onRegister();
 }
Example #10
0
 /**
  * Remove a listener from a specific order slot
  *
  * @param listener listener to remove
  */
 public synchronized void unregister(RegisteredListener listener) {
   if (handlerslots.get(listener.getPriority()).remove(listener)) {
     handlers = null;
   }
 }