code: protected void registerMethod(
  			Object o, Method m, int priority, boolean vetoable) {
  		// check the parameter types, and attempt to resolve the event
  		// type
  		if (m.getParameterTypes().length != 1) {
  			log.warn("Skipping invalid event handler definition: " + m);
  			return;
  		}
  
  		// make sure the parameter is an Event
  		// this additional/technically unneeded check should cut down on the
  		// time required to process the loop over the definitions for methods
  		// that don't match
  		Class<?> param = m.getParameterTypes()[0];
  		if (!Event.class.isAssignableFrom(param)) {
  			log.warn("Skipping event handler without an Event parameter: " + m);
  			return;
  		}
  	
  		// add the method to all assignable definitions.
  		// this may result in the method being added to multiple queues,
  		// that is, the queues for each superclass.
  		// (this is intended and is fundamentally what makes subclassed events
  		// work as expected)
  		for (EventQueueDefinition d : definitions) {
  			if (param.isAssignableFrom(d.getEventType())) {
  				d.add(new EventQueueEntry(o, m, priority, vetoable));
  				log.debug("Added {} to queue {}", m, d.getEventType());
  			}
  		}
  	}
docs: Registers the given method to the event bus. The object is assumed to be
  of the class that contains the given method.
  <p>The method parameters are
  checked and added to the event queue corresponding to the {@link Event}
  used as the first method parameter. In other words, if passed a reference
  to the following method:</p>
  <p><code>
  public void xyzHandler(XYZEvent event) { ... }
  </code></p>
  <p>... <code>xyzHandler</code> will be added to the event queue for
  {@code XYZEvent} assuming that {@code XYZEvent} extends {@link Event} and
  an event queue has been created for that event type.</p>
  @param o an instance of the class containing the method <code>m</code>
  @param m the method to register
  @param priority the event priority
  @param vetoable vetoable flag