How do I ensure a Map key maps to the correct data type?

Question

Hi,
I have a simple event processing interface, where an Action class processes an event, and optionally generates a response event. I want to store a map of all registered actions, and then select the one matching an incoming event at run time:
// the basic types
public abstract class Event {
  protected String type;
  protected String data;
  public String getType()  { return type; }
  @Override
  public String toString() { return data; }
// an action processes a request event and optionally returns a response event
public interface Action<ReqE extends Event, ResE extends Event> {
  public ResE process(ReqE request);
// two simple events
public class Event1 extends Event {
  public Event1(String data) { this.type = "ev1"; this.data = data; }
public class Event2 extends Event {
  public Event2(String data) { this.type = "ev2"; this.data = data; }
// simple test class
public class Test {
  Map<String, Action<? extends Event, ? extends Event>> actions
    = new HashMap<String, Action<? extends Event, ? extends Event>>();
  public void run() {
    // source event
    Event1 request = new Event1("hello");
    // register an action - takes an Event1 and returns an Event2
    actions.put(request.getType(), new Action<Event1, Event2>() {
      @Override
      public Event2 process(Event1 req) {
        return new Event2(req.data);
    // run it
    Action<Event, Event> action = getAction(request.getType());
    Event response = action == null ? null : action.process(request);
    System.out.println("Response=" + String.valueOf(response));
  public Action<Event, Event> getAction(String type) {
    return (Action<Event, Event>)actions.get(type);
  public static void main(String[] args) {
    new Test().run();
}This all works, but the problem is obviously the cast in the getAction() method. I can see what the problem is: there is nothing to stop me registering a handler with the wrong event types:
  // register an action - this will fail at runtime as request is an Event1
  actions.put(request.getType(), new Action<Event3, Event4>() {
    @Override
    public Event4 process(Event3 req) {
      return new Event4(req.data);
  });So that leads to the map declaration. What I think I need to do is change the key of the map from String to... well, I'm not sure what! Some kind of parameterised EventType class that ties in to the event types of the parameterised Action class, so when I call:
  Map<????, Action<? extends Event, ? extends Event>> actions = ...
  actions.put(????, new Action<Event1, Event2>() {...});the key type ties in to Event1/Event2 so that it ensures the eventual call to "process" will receive the correct types. But this is really getting beyond my knowledge of generics!
So if anybody has any useful pointers on where to go from here I'd be realy grateful.
Cheers,
Barney

Answer 1

The obvious choice for the key would be the type of the request event instead of a plain String.
Thus, declare the map like this:
Map<Class<? extends Event>, Action<?,?>>Below, I've modified your code so that it is typesafe, provided you use the public methods "registerAction" and "getAction".
import java.util.HashMap;
import java.util.Map;
abstract class Event {
       protected String type;
       protected String data;
       public String getType()  { return type; }
       @Override
       public String toString() { return data; }
     // an action processes a request event and optionally returns a response event
      interface Action<ReqE extends Event, ResE extends Event> {
       public ResE process(ReqE request);
     // two simple events
      class Event1 extends Event {
       public Event1(String data) { this.type = "ev1"; this.data = data; }
      class Event2 extends Event {
       public Event2(String data) { this.type = "ev2"; this.data = data; }
     // simple test class
     public class EventTest {
       Map<Class<? extends Event>, Action<?,?>> actions
         = new HashMap<Class<? extends Event>, Action<?,?>>();
       public void run() {
         // source event
         Event1 request = new Event1("hello");
         // register an action - takes an Event1 and returns an Event2
         registerAction(Event1.class, new Action<Event1, Event2>() {
           public Event2 process(Event1 req) {
             return new Event2(req.data);
         // run it
         Action<? super Event1,?> action = getAction(Event1.class);
         Event response = action == null ? null : action.process(request);
         System.out.println("Response=" + String.valueOf(response));
       @SuppressWarnings("unchecked")
     public <E extends Event> Action<? super E,?> getAction(Class<E> type) {
         return (Action<? super E,?>)actions.get(type);
       public <E extends Event> void registerAction(Class<E> type, Action<? super E,?> action) {
              actions.put(type, action);
       public static void main(String[] args) {
         new EventTest().run();
     }