# HG changeset patch # User Jacob Carlborg # Date 1275320663 -7200 # Node ID ea37a9470e3ef25b0df6ef6f6615b097b3250876 # Parent 11a31bd929f93c1d1dcdf93ba882bb299c196f66 Fixed multiple NonSerialized diff -r 11a31bd929f9 -r ea37a9470e3e dsss.conf --- a/dsss.conf Mon May 31 16:06:36 2010 +0200 +++ b/dsss.conf Mon May 31 17:44:23 2010 +0200 @@ -1,1 +1,1 @@ -[orange] \ No newline at end of file +[main.d] \ No newline at end of file diff -r 11a31bd929f9 -r ea37a9470e3e orange/serialization/Serializer.d --- a/orange/serialization/Serializer.d Mon May 31 16:06:36 2010 +0200 +++ b/orange/serialization/Serializer.d Mon May 31 17:44:23 2010 +0200 @@ -115,26 +115,26 @@ else static if (isPointer!(T)) { static if (isFunctionPointer!(T)) - static assert(false, format!(`The type "`, T, `" cannot be serialized.`)); + goto error; else serializePointer(value, key); - } - + } else static if (isEnum!(T)) serializeEnum(value, key); else - static assert(false, format!(`The type "`, T, `" cannot be serialized.`)); + { + error: + throw new SerializationException(format!(`The type "`, T, `" cannot be serialized.`), __FILE__, __LINE__); + } return archive.data; } private void serializeObject (T) (T value, DataType key) - { - auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value); - + { triggerEvents(serializing, value, { archive.archive(value, key, { auto runtimeType = value.classinfo.name; @@ -153,7 +153,7 @@ if (isBaseClass(value)) throw new SerializationException(`The object of the static type "` ~ T.stringof ~ `" have a different runtime type (` ~ runtimeType ~ `) and therefore needs to register a serializer for its type "` ~ runtimeType ~ `".`, __FILE__, __LINE__); - objectStructSerializeHelper(value, nonSerializedFields); + objectStructSerializeHelper(value); } }); }); @@ -161,8 +161,6 @@ private void serializeStruct (T) (T value, DataType key) { - auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value); - triggerEvents(serializing, value, { archive.archive(value, key, { auto type = toDataType(T.stringof); @@ -179,7 +177,7 @@ value.toData(this, key); else - objectStructSerializeHelper(value, nonSerializedFields); + objectStructSerializeHelper(value); } }); }); @@ -285,20 +283,26 @@ return deserializePrimitive!(T)(key); else static if (isPointer!(T)) + { + static if (isFunctionPointer!(T)) + goto error; + return deserializePointer!(T)(key); + } else static if (isEnum!(T)) return deserializeEnum!(T)(key); else - static assert(false, format!(`The type "`, T, `" cannot be deserialized.`)); + { + error: + throw new SerializationException(format!(`The type "`, T, `" cannot be deserialized.`), __FILE__, __LINE__); + } } private T deserializeObject (T) (DataType key) { - T value = archive.unarchive!(T)(key, (T value) { - auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value); - + T value = archive.unarchive!(T)(key, (T value) { triggerEvents(deserializing, value, { auto runtimeType = value.classinfo.name; @@ -316,7 +320,7 @@ if (isBaseClass(value)) throw new SerializationException(`The object of the static type "` ~ T.stringof ~ `" have a different runtime type (` ~ runtimeType ~ `) and therefore needs to register a deserializer for its type "` ~ runtimeType ~ `".`, __FILE__, __LINE__); - objectStructDeserializeHelper(value, nonSerializedFields); + objectStructDeserializeHelper(value); } }); @@ -329,8 +333,6 @@ private T deserializeStruct (T) (DataType key) { return archive.unarchive!(T)(key, (T value) { - auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value); - triggerEvents(deserializing, value, { auto type = toDataType(T.stringof); @@ -346,7 +348,7 @@ value.fromData(this, key); else - objectStructDeserializeHelper(value, nonSerializedFields); + objectStructDeserializeHelper(value); } }); @@ -421,64 +423,65 @@ }); } - private void objectStructSerializeHelper (T) (T value, string[] nonSerializedFields) + private void objectStructSerializeHelper (T) (T value) { + const nonSerializedFields = collectAnnotations!(nonSerializedField)(value); + foreach (i, dummy ; typeof(T.tupleof)) { const field = nameOfFieldAt!(T, i); - if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) + static if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) { - alias typeof(T.tupleof[i]) Type; - + alias typeof(T.tupleof[i]) Type; Type v = value.tupleof[i]; - - //Type v = getValueOfField!(T, Type, field)(value); serialize(v, toDataType(field)); } } static if (is(T : Object) && !is(T == Object)) - serializeBaseTypes(value, nonSerializedFields); + serializeBaseTypes(value); } - private void objectStructDeserializeHelper (T) (T value, string[] nonSerializedFields) + private void objectStructDeserializeHelper (T) (T value) { + const nonSerializedFields = collectAnnotations!(nonSerializedField)(value); + foreach (i, dummy ; typeof(T.tupleof)) { const field = nameOfFieldAt!(T, i); - if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) - { + static if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) + { alias TypeOfField!(T, field) Type; - auto fieldValue = deserializeInternal!(Type)(toDataType(field)); - setValueOfField!(T, Type, field)(value, fieldValue); + auto fieldValue = deserializeInternal!(Type)(toDataType(field)); + value.tupleof[i] = fieldValue; } } static if (is(T : Object) && !is(T == Object)) - deserializeBaseTypes(value, nonSerializedFields); + deserializeBaseTypes(value); } - private void serializeBaseTypes (T : Object) (T value, string[] nonSerializedFields) + private void serializeBaseTypes (T : Object) (T value) { alias BaseTypeTupleOf!(T)[0] Base; static if (!is(Base == Object)) { archive.archiveBaseClass!(Base)(nextKey); - objectStructSerializeHelper!(Base)(value, nonSerializedFields); + objectStructSerializeHelper!(Base)(value); } } - private void deserializeBaseTypes (T : Object) (T value, string[] nonSerializedFields) + private void deserializeBaseTypes (T : Object) (T value) { alias BaseTypeTupleOf!(T)[0] Base; static if (!is(Base == Object)) { archive.unarchiveBaseClass!(Base)(nextKey); - objectStructDeserializeHelper!(Base)(value, nonSerializedFields); + objectStructDeserializeHelper!(Base)(value); } } @@ -583,7 +586,7 @@ triggerEvent!(onDeserializedField)(value); } - private string[] collectAnnotations (string name, T) (T value) + private static string[] collectAnnotations (string name, T) (T value) { static assert (is(T == class) || is(T == struct), format!(`The given value of the type "`, T, `" is not a valid type, the only valid types for this method are classes and structs.`)); @@ -595,8 +598,7 @@ static if (field == name) { - alias TypeOfField!(T, field) Type; - auto f = getValueOfField!(T, Type, field)(value); + typeof(value.tupleof[i]) f; annotations ~= f.field; } } diff -r 11a31bd929f9 -r ea37a9470e3e orange/util/CTFE.d --- a/orange/util/CTFE.d Mon May 31 16:06:36 2010 +0200 +++ b/orange/util/CTFE.d Mon May 31 17:44:23 2010 +0200 @@ -20,11 +20,7 @@ const format = ARGS[0] ~ format!(ARGS[1 .. $]); else - { - pragma(msg, typeof(ARGS[0].stringof)); const format = toString_!(ARGS[0]) ~ format!(ARGS[1 .. $]); - } - } }