Re: Generics

I've tried filling in the gaps, and ended up with:
===
public class EventDispatcherImpl implements EventDispatcher {
[...]
    public <T> void dispatchEvent(T event) {
        for (EventListener<? super T> listener :
myListeners.get(event.getClass())) {
            listener.eventRaised(event);
        }
    }

    /**
     * Utility class to map events to listeners
     */
    private static class EventMap {
        /**
         * Stores the event type -> listners mapping.
         */
        private final Map<Class<?>, Set<EventListener<?>>> myListenersByType
= new HashMap<Class<?>, Set<EventListener<?>>>();

        /**
         * Gets all listeners that can handle the specified event class.
         * @param <T> the event type
         * @param eventClass the event class
         * @return the listeners that can handles the event class
         */
        <T> Set<EventListener<? super T>> get(Class<? extends T> eventClass)
{
            Set<EventListener<? super T>> listeners = new
HashSet<EventListener<? super T>>();
            synchronized (myListenersByType) {
                for (Map.Entry<Class<?>, Set<EventListener<?>>> entry :
myListenersByType.entrySet()) {
                    if (entry.getKey().isAssignableFrom(eventClass)) {
                        for (EventListener<?> listener : entry.getValue()) {
/* warning here:
Type safety: The cast from EventListener<capture-of ?> to
EventListener<? super T> is actually checking against the erased type
EventListener
*/
                            listeners.add((EventListener<? super T>) listener);
                        }
                    }
                }
            }
            return listeners;
        }
[...]
===

Now at least there's no need for an Event superclass/interface: I can
dispatch any object (that is, I can maintain multiple, unrelated event
hierarchies, and use a single dispatcher).
Is there a way (aside from @SuppressWarning) to eliminate the warning?