Question

I am porting some Java-code to Dart and it heavily uses these kinds of maps:

Map<Class<? extends SomeClass>, SomeOtherClass> map = new HashMap<>();

At the moment this seems to be impossible in dart. I am aware that there is a proposal to introduce first level types: http://news.dartlang.org/2012/06/proposal-for-first-class-types-in-dart.html which would introduce

class Type {
    @native String toString();
    String descriptor(){...} // return the simple name of the type
}

So until this proposal gets implemented I have created following class:

class Type {
    final String classname;
    const Type(this.classname);
    String descriptor() => classname;
}

and the classes where I need it have a simple get-method

abstract Type get type();

That way I can use my Type just like I would use the real Type and to switch later I’d just have to delete my workaround.

My question: Is there some dart-way of doing this kind of mapping (which I am not seeing) or is the way I do it a reasonable workaround until the real Type class gets introduced?

Update for Dart 1.0

It can be done this way:

var map = new Map<Type, SomeOtherClass>();
// either
map[SomeOtherClass] = new SomeOtherClass();
// or
var instance = new SomeOtherClass();
map[instance.runtimeType] = instance;

Answer 1

Update: this construction is not currently doable in Dart

Map<Class<? extends SomeClass>, SomeOtherClass>

you will have to wait for .type/.class to arrive for an elegant solution to this (lots of us Dartisans are hoping that this will arrive sooner rather than later). However for the simpler case

Map<? extends SomeClass, SomeOtherClass>

You can just do

 Map<SomeClass, SomeOtherClass> aMap;

as in Dart any class that extends SomeClass is also going to be a valid SomeClass. For example if you run the following code in checked mode:

main() {
  Map<Test, String> aMap = new HashMap<Test, String>();
  var test = new Test("hello");
  var someTest = new SomeTest("world");
  var notATest = new NotATest(); 

  aMap[test] = test.msg;
  aMap[someTest] = someTest.msg;
  aMap[notATest] = "this fails";
}

class Test implements Hashable {
  Test(this.msg);

  int hashCode() => msg.hashCode();

  final String msg;
}

class SomeTest extends Test {
  SomeTest(String message): super(message);
}

class NotATest implements Hashable {
  int hashCode() => 1;
}

then you you will get the error:

type 'NotATest' is not a subtype of type 'Test' of 'key'.