Is there a way to use Object.factory with templated classes? Or some way to construct templated classes given RTTI of an instance?

[Chad Joan]

Hi all,

I'm implementing a deep-copy method for a tree of templated class 
instances.  As part of this, I need some way to copy each node.  
I want to avoid code that does things like casting objects into 
byte arrays and then copying raw bytes; I want all operations to 
be memory safe things that I can use at compile-time.  So I 
planned to make all of these have default constructors and use 
Object.factory to at least create the correct instance type at 
the destination.  The classes can implement auxiliary copy 
methods if they need to copy anything that isn't already handled 
by their deepCopy method.

But I ran into a problem: Object.factory doesn't seem to be 
compatible with templated classes.

Here is an example:

import std.stdio;

class Root(T)
{
	T x;
}

class Extended(T) : Root!T
{
	T y;
}

void main()
{
	Root!int foo = new Extended!int();

	auto name = foo.classinfo.name;
	writefln("foo's name is '%s'", name);
	// foo's name is 'main.Extended!int.Extended'

	Object   obj = Object.factory(name);
	writefln("Is obj null? %s", obj is null);

	Root!int bar = cast(Root!int)obj; // Still going to be null.
	writefln("Is bar null? %s", obj is null);

	//bar.x = 3; // crash!
}


I had a look at Object.factory.  It seems very simple.  Perhaps 
too simple.  I think this might be a dead end.  Have I missed 
something?  Can it actually handle templates somehow, but I just 
don't know how to calculate the correct string to hand it?

If Object.factory is incapable of this, is there some other 
CTFE-friendly way to copy templated class instances?

If I have to, I can probably make these things register 
themselves in some list of delegates that can be used to 
instantiate the correct class.  Or something like that.  But I am 
hoping that there is a better way that involves less boilerplate.

Thanks!
- Chad