Question

I’m trying to build an SDK using an adapter pattern. Here’s what I’ve got so far:

interface Adapter<T> {
  void doWork(WorkUnit<T> unit);
  Class<T> getT();
}

class WorkUnit<T> {
  public int getId() { ... }
  public T getExtras() { ... }
}

class OldWorkUnit {
  public <T> void setExtra(T data) { /* Store data in Map<Class, Object> */ }
  public <T> WorkUnit<T> toNewWorkUnit(Adapter<T> adapter) { /* Map.get(adapter.getT()) */ }
}

There’s a good amount of generics in there, but I can’t know T at compile time, and there may be multiple Adapters, all with different types of T. This is meant to be exposed to third parties, so I also need as little implementation as possible in the interface implementation, and it has to be an interface (no abstract class).

Now I want to take this and call doWork with a WorkUnit. My first pass at the code looks like this:

class FooAdapter implements Adapter<FooWorkUnit> {
  ...
}

OldWorkUnit w = new OldWorkUnit();
w.setExtra(new FooWorkUnit());

Adapter<?> a = new FooAdapter();
WorkUnit<?> unit = w.toNewWorkUnit(a);

a.doWork(unit);

Uh oh, that doesn’t compile:

The method doWork(WorkUnit<capture#2-of ?>) in the type Adapter<capture#2-of ?> 
is not applicable for the arguments (WorkUnit<capture#4-of ?>)

I know that the WorkUnit generic argument is the same type as the Adapter.doWork() generic argument, but without knowing the type I can’t cast it appropriately.

So is there a way to work my way through this?

Answer 1

Why do you wildcard the template class here?:

Adapter<?> a = new FooAdapter();
WorkUnit<?> unit = w.toNewWorkUnit(a);

If you do this:

Adapter<FooWorkUnit> a = new FooAdapter();
WorkUnit<FooWorkUnit> unit = w.toNewWorkUnit(a);

Doesn’t that preserve what you need?

Now the compiler knows that FooWorkUnit is the common denominator, so to speak.

Edit: OK point taken about the runtime variability. How about strongly-typing the method that does the work, so that the wildcards are eliminated, but still consistent:

@SuppressWarnings("unchecked")
public <X> void prepareArgsAndDoTheWork() {
    OldWorkUnit w = new OldWorkUnit();
    w.setExtra(new FooWorkUnit());

    Adapter<X> a = (Adapter<X>) ... ; // Obtain the Adapter by reflection etc 
    WorkUnit<X> unit = w.toNewWorkUnit(a);
    a.doWork(unit);
}