Chances of D getting proper runtime reflection?

[Jacob Carlborg]

On 2011-08-22 21:08, Andrei Alexandrescu wrote:
> On 8/21/11 6:03 PM, dsimcha wrote:
>> On 8/21/2011 6:35 PM, Andrei Alexandrescu wrote:
>>> On 8/21/11 1:19 PM, Jacob Carlborg wrote:
>>>> On 2011-08-21 17:30, Robert Clipsham wrote:
>>>>> On 21/08/2011 16:05, Jacob Carlborg wrote:
>>>>>> This is for a serialization library where third party types need
>>>>>> to be
>>>>>> serializable. I don't like the idea of annotate everything that
>>>>>> should
>>>>>> be serializable.
>>>>>
>>>>> You don't need to annotate it:
>>>>>
>>>>> void serialize(T)(T something);
>>>>>
>>>>> You have access to all the CT reflection stuff, and can generate the
>>>>> necessary runtime reflection with that.
>>>>
>>>> I already have a fully working serialization library. I'm hoping to
>>>> make
>>>> it better. The problem is when (de)serializing through a base class
>>>> reference. Currently you need to register the subclass with the
>>>> serializer. If T is Base and the actually runtime type is Sub it won't
>>>> work.
>>>
>>> If we get to the point where adding one line of code inside or
>>> (preferably) outside a type to make it serializable, that would be
>>> great.
>>>
>>> Andrei
>>
>> I've been playing with Jacob's code and we're already at that point.
>> Example (requires Jacob's Orange library to be installed):
>>
>> import std.stdio, orange.serialization._,
>> orange.serialization.archives._,
>> std.exception;
>>
>> class Base {
>> string baseString;
>> }
>>
>> class Derived : Base {
>> string derivedString;
>> }
>>
>> void main() {
>> auto archiver = new XMLArchive!char();
>> auto serializer = new Serializer(archiver);
>> serializer.register!Derived();
>>
>> auto derived = new Derived;
>> derived.baseString = "Base";
>> derived.derivedString = "Derived";
>>
>> Base baseRef = derived;
>> auto serialized = serializer.serialize(baseRef);
>> auto baseRef2 = serializer.deserialize!(Base)(serialized);
>>
>> enforce(baseRef2.classinfo is Derived.classinfo);
>> auto derived2 = cast(Derived) baseRef;
>> writeln(derived2.baseString, ' ', derived2.derivedString);
>> }
>>
>>
>> The registration is not even necessary if you're serializing a class
>> with a compile time type identical to its runtime type. Of course the
>> situation gets a little more complicated when classes have references to
>> other classes (you need to register everything that could be
>> transitively reachable) but it's still pretty good.
>
> That's not how it should work. The line of code needs to be declarative,
> not imperative. "I want this class to be serializable" as opposed to "I
> want to serialize this class with this particular archiver".
>
> Andrei

You mean you want something like this:

class Derived : Base
{
     mixin serializable;
}

Instead of:

serializer.register!Derived();

The only way I can think of how this could work is to store a global 
list of the serializable classes. Any other suggestion how this would 
work? Note that all this wouldn't be necessary if my original post was 
implemented.

-- 
/Jacob Carlborg