Somewhat complicated nested generics question

Question

I have a slightly complicated generics question. I have some parameterized code that looks something like:
public <T extends MyBaseObject> Map<String,T> loadObjectCache (Class<T> clazz) {
    // load objects of type T from somewhere (file, database, etc.)
    List<T> objs = loadObjects(clazz);
    // create map to store objects keyed by name
    Map<String,T> map = new HashMap<String,T>();
    for (T obj : objs) {
        map.put(obj.name(), obj);
    return map;
public static void main (String[] args) {
    // load objects of type Foo (a subclass of MyBaseClass)
    Map<String,Foo> map = loadObjectCache(Foo.class);
    // retrieve a Foo by name
    Foo foo = map.get("bling");
}This all works great, and the parameterization helps me avoid some annoying casts. Now let's suppose I want build these maps for multiple classes, and I want to create a second-order cache of objects: a Map which is keyed by Class and contains elements each of which is a Map as above (keyed by name, containing objects of the given class). So, I'd like to declare something like:
Map<Class,Map<String,Object>> metaMap = new HashMap<Class,Map<String,Object>>();However, this doesn't quite work. The compiler complains about the following code added just before the return in loadObjectCache() because a Map<String,Foo> is not a subclass of a Map<String,Object>:
    metaMap.put(clazz, map);So, What I'd like is some way to make the above declaration of metaMap such that the objects in a given inner Map are checked to be of the same type as the Class used to store that Map in the meta-map, something like:
Map<Class<T>,Map<String,T>> metaMap = new HashMap<Class<T>,Map<String,T>>();But this isn't quite right either. I don't want a Map that uses a particular Class as its key. Rather, I want a Map that uses multiple Class objects as keys, and the element stored for each is itself a Map containing objects of that type. I've tried a variety of uses of Object, wildcards, etc., and I'm stumped. I currently have the meta-map defined as:
Map<Class,Map<String,?>> metaMap = new HashMap<Class,Map<String,?>>();Then in my new getObjectByName() method, I have to use an ugly cast which gives me a type safety warning:
public <T> T getObjectByName (Class<T> clazz, String name) {
    Map<String,T> map = (Map<String,T>)metaMap.get(clazz);
    return map.get(name);
}If anyone know how I should declare the meta-map or whether it's even possible to accomplish all this without casts or warnings, I would much appreciate it!
Dustin

Answer 1

Map<Class<?>,Map<String,?>> metaMap = new
new HashMap<Class<?>,Map<String,?>>();
public <T> T getObjectByName (Class<T> clazz,
azz, String name) {
     Map<String,?> map = metaMap.get(clazz);
     return clazz.cast(map.get(name));
}Cute. Of course, that's really only hiding the warning, isn't it?
Also it doesn't generalize because there's no way to crete a type token for a parameterized class. So you can't use a paramterized class as a key, nor can you nest 3 Maps.
    public static <U> void main(String[] args) {
        MetaMap mm = new MetaMap();
        Appendable a = mm.getObjectByName(Appendable.class, "MyAppendable");
        Comparable<U> u = mm.getObjectByName(Comparable.class, "MyComparable"); //unchecked converstion :(
    }Hey, not to sound ungrateful though. The solution posed is very useful for a certain class of problem.