On 2012-03-18 20:26, Walter Bright wrote:
Something like Jacob's proposal for compile time attributes would be
useful here. My failure to understand is about runtime attributes.
If we'll get user defined attributes that is accessible via runtime
reflection I'm sure people will find uses cases for it that are not
possible with compile time reflection. But currently I don't see any use
cases for attributes per instance.
If I'm thinking correctly this can be used for serializing. Say that you
want to serialize an object through a base class reference. Currently
you will need to register the subclass using some mechanism due to the
limited runtime reflection in D. But if it would be possible to
enumerate all fields in a class and also set and get the values of the
fields using runtime reflection it wouldn't be necessary to register the
subclass.
Ok, now to the user defined attribute:
@attribute class NonSerialized {} // This is what's called a "marker" in
Java. It doesn't contain any information, the information is the type
itself.
@attribute class SerializeAs
{
string value;
}
class Base
{
int x;
@SerializeAs(foo) int y;
@NonSerialized int c;
}
@NonSerialized class Sub : Base
{
int z;
}
Base sub = new Sub;
serialize(sub);
In this example the user defined attribute "NonSerialized" indicates
that the class shouldn't be serialized. When the serializer is
serializing "sub" the compile time type will be "Base" therefore it
would need to use runtime reflection to also serialize the fields added
in the subclass "Sub". To check if the object should be serialized the
serializer need to be able to access user defined attributes using
runtime reflection. Something like:
auto classInfo = sub.classinfo;
writeln(classInfo); // Sub
if (classInfo.hasAttribute("NonSerialized"))
// skip serialization
else
{
foreach (field ; classInfo.fields)
if (!field.hasAttribute("NonSerialized"))
{
auto value = filed.value;
string name;
if (attribute = filed.attributes["SerializeAs"])
name = attribute.value;
else
name = filed.name;
// serialize the field
}
}
We do all this during runtime because we want to serialize through base
class references. If the runtime type is the same as the compile time
type we can do this at compile time.
--
/Jacob Carlborg
