Re: Generics

Here's my final solution. It does not have the EventMap class, and has
the same one typecast warning:

public class EventDispatcherImpl implements EventDispatcher {
  /**
   * Stores the event type -> listners mapping.
   */
  private final Map<Class<?>, Set<EventListener<?>>> myListeners =
new HashMap<Class<?>, Set<EventListener<?>>>();

  /**
   * Creates an instance.
   */
  public EventDispatcherImpl() {
    super();
  }

  /**
     * @see EventDispatcher#addListener(EventListener,
java.lang.Class)
     */
  public <T> EventDispatcher addListener(EventListener<? super T>
listener, Class<T> eventClass) {
    synchronized (myListeners) {
      Set<EventListener<?>> listeners = myListeners.get(eventClass);
      if (null == listeners) {
        listeners = new HashSet<EventListener<?>>();
        myListeners.put(eventClass, listeners);
      }
      listeners.add(listener);
        }
    return this;
  }

  /**
     * @see EventDispatcher#removeListener(EventListener,
java.lang.Class)
     */
  public <T> EventDispatcher removeListener(EventListener<? super T>
listener, Class<T> eventClass) {
    synchronized (myListeners) {
      Set<EventListener<?>> listeners = myListeners.get(eventClass);
      if (null != listeners) {
        listeners.remove(listener);
      }
        }
    return this;
  }

  /**
   * @see EventDispatcher#dispatchEvent(java.lang.Object)
   */
  public <T> EventDispatcher dispatchEvent(T event) {
    Set<EventListener<? super T>> listenersToNotify = new
HashSet<EventListener<? super T>>();
    for (Map.Entry<Class<?>, Set<EventListener<?>>> entry :
myListeners.entrySet()) {
      if (entry.getKey().isInstance(event)) {
        Set<EventListener<?>> listeners = entry.getValue();
        for (EventListener<?> listener : listeners) {
          listenersToNotify.add((EventListener<? super T>) listener);
        }
      }
    }
    for (EventListener<? super T> listener : listenersToNotify) {
          listener.eventRaised(event);
        }
    return this;
  }
}

The nasty thing about it is the declaration of dispatchEvent. It uses
a type parameter T, but only once. The method has only one parameter
and a fixed return type, so it looks pretty much useless, at least in
the interface. Quoting Sun's Generics tutorial:
"The return type doesn't depend on the type parameter, nor does any
other argument to the method (in this case, there simply is only one
argument). This tells us that the type argument is being used for
polymorphism; its only effect is to allow a variety of actual argument
types to be used at different invocation sites. If that is the case,
one should use wildcards. Wildcards are designed to support flexible
subtyping, which is what we're trying to express here.
Generic methods allow type parameters to be used to express
dependencies among the types of one or more arguments to a method and/
or its return type. If there isn't such a dependency, a generic method
should not be used."
However, changing the declaration to:
public EventDispatcher dispatchEvent(Object event) {...} breaks the
code. If I replace the <? super T> with <?>, I get a compile error on
the line:
listener.eventRaised(event);
The method eventRaised(capture-of ?) in the type EventListener<capture-
of ?> is not applicable for the arguments (Object)

I'll leave it at that, I think.

Thanks for your help,
Kofa