Mercurial > projects > orange

comparison orange/serialization/Serializer.d @ 2:ea37a9470e3e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed multiple NonSerialized
author Jacob Carlborg <doob@me.com>
date Mon, 31 May 2010 17:44:23 +0200
parents f7b078e85f7f
children 3c155e4c3d56
comparison
equal deleted inserted replaced
1:11a31bd929f9 2:ea37a9470e3e
113 serializePrimitive(value, key); 113 serializePrimitive(value, key);
114 114
115 else static if (isPointer!(T)) 115 else static if (isPointer!(T))
116 { 116 {
117 static if (isFunctionPointer!(T)) 117 static if (isFunctionPointer!(T))
118 static assert(false, format!(`The type "`, T, `" cannot be serialized.`)); 118 goto error;
119 119
120 else 120 else
121 serializePointer(value, key); 121 serializePointer(value, key);
122 } 122 }
123
124 123
125 else static if (isEnum!(T)) 124 else static if (isEnum!(T))
126 serializeEnum(value, key); 125 serializeEnum(value, key);
127 126
128 else 127 else
129 static assert(false, format!(`The type "`, T, `" cannot be serialized.`)); 128 {
129 error:
130 throw new SerializationException(format!(`The type "`, T, `" cannot be serialized.`), __FILE__, __LINE__);
131 }
130 132
131 return archive.data; 133 return archive.data;
132 } 134 }
133 135
134 private void serializeObject (T) (T value, DataType key) 136 private void serializeObject (T) (T value, DataType key)
135 { 137 {
136 auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value);
137
138 triggerEvents(serializing, value, { 138 triggerEvents(serializing, value, {
139 archive.archive(value, key, { 139 archive.archive(value, key, {
140 auto runtimeType = value.classinfo.name; 140 auto runtimeType = value.classinfo.name;
141 141
142 if (runtimeType in serializers) 142 if (runtimeType in serializers)
151 else 151 else
152 { 152 {
153 if (isBaseClass(value)) 153 if (isBaseClass(value))
154 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__); 154 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__);
155 155
156 objectStructSerializeHelper(value, nonSerializedFields); 156 objectStructSerializeHelper(value);
157 } 157 }
158 }); 158 });
159 }); 159 });
160 } 160 }
161 161
162 private void serializeStruct (T) (T value, DataType key) 162 private void serializeStruct (T) (T value, DataType key)
163 { 163 {
164 auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value);
165
166 triggerEvents(serializing, value, { 164 triggerEvents(serializing, value, {
167 archive.archive(value, key, { 165 archive.archive(value, key, {
168 auto type = toDataType(T.stringof); 166 auto type = toDataType(T.stringof);
169 167
170 if (type in serializers) 168 if (type in serializers)
177 { 175 {
178 static if (isSerializable!(T, ArchiveType)) 176 static if (isSerializable!(T, ArchiveType))
179 value.toData(this, key); 177 value.toData(this, key);
180 178
181 else 179 else
182 objectStructSerializeHelper(value, nonSerializedFields); 180 objectStructSerializeHelper(value);
183 } 181 }
184 }); 182 });
185 }); 183 });
186 } 184 }
187 185
283 281
284 else static if (isPrimitive!(T)) 282 else static if (isPrimitive!(T))
285 return deserializePrimitive!(T)(key); 283 return deserializePrimitive!(T)(key);
286 284
287 else static if (isPointer!(T)) 285 else static if (isPointer!(T))
286 {
287 static if (isFunctionPointer!(T))
288 goto error;
289
288 return deserializePointer!(T)(key); 290 return deserializePointer!(T)(key);
291 }
289 292
290 else static if (isEnum!(T)) 293 else static if (isEnum!(T))
291 return deserializeEnum!(T)(key); 294 return deserializeEnum!(T)(key);
292 295
293 else 296 else
294 static assert(false, format!(`The type "`, T, `" cannot be deserialized.`)); 297 {
298 error:
299 throw new SerializationException(format!(`The type "`, T, `" cannot be deserialized.`), __FILE__, __LINE__);
300 }
295 } 301 }
296 302
297 private T deserializeObject (T) (DataType key) 303 private T deserializeObject (T) (DataType key)
298 { 304 {
299 T value = archive.unarchive!(T)(key, (T value) { 305 T value = archive.unarchive!(T)(key, (T value) {
300 auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value);
301
302 triggerEvents(deserializing, value, { 306 triggerEvents(deserializing, value, {
303 auto runtimeType = value.classinfo.name; 307 auto runtimeType = value.classinfo.name;
304 308
305 if (runtimeType in deserializers) 309 if (runtimeType in deserializers)
306 { 310 {
314 else 318 else
315 { 319 {
316 if (isBaseClass(value)) 320 if (isBaseClass(value))
317 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__); 321 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__);
318 322
319 objectStructDeserializeHelper(value, nonSerializedFields); 323 objectStructDeserializeHelper(value);
320 } 324 }
321 }); 325 });
322 326
323 return value; 327 return value;
324 }); 328 });
327 } 331 }
328 332
329 private T deserializeStruct (T) (DataType key) 333 private T deserializeStruct (T) (DataType key)
330 { 334 {
331 return archive.unarchive!(T)(key, (T value) { 335 return archive.unarchive!(T)(key, (T value) {
332 auto nonSerializedFields = collectAnnotations!(nonSerializedField)(value);
333
334 triggerEvents(deserializing, value, { 336 triggerEvents(deserializing, value, {
335 auto type = toDataType(T.stringof); 337 auto type = toDataType(T.stringof);
336 338
337 if (type in deserializers) 339 if (type in deserializers)
338 { 340 {
344 { 346 {
345 static if (isSerializable!(T, ArchiveType)) 347 static if (isSerializable!(T, ArchiveType))
346 value.fromData(this, key); 348 value.fromData(this, key);
347 349
348 else 350 else
349 objectStructDeserializeHelper(value, nonSerializedFields); 351 objectStructDeserializeHelper(value);
350 } 352 }
351 }); 353 });
352 354
353 return value; 355 return value;
354 }); 356 });
419 return archive.unarchive!(T)(key, (T value) { 421 return archive.unarchive!(T)(key, (T value) {
420 return deserializeInternal!(BaseTypeOfTypeDef!(T))(key); 422 return deserializeInternal!(BaseTypeOfTypeDef!(T))(key);
421 }); 423 });
422 } 424 }
423 425
424 private void objectStructSerializeHelper (T) (T value, string[] nonSerializedFields) 426 private void objectStructSerializeHelper (T) (T value)
425 { 427 {
428 const nonSerializedFields = collectAnnotations!(nonSerializedField)(value);
429
426 foreach (i, dummy ; typeof(T.tupleof)) 430 foreach (i, dummy ; typeof(T.tupleof))
427 { 431 {
428 const field = nameOfFieldAt!(T, i); 432 const field = nameOfFieldAt!(T, i);
429 433
430 if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) 434 static if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field))
431 { 435 {
432 alias typeof(T.tupleof[i]) Type; 436 alias typeof(T.tupleof[i]) Type;
433
434 Type v = value.tupleof[i]; 437 Type v = value.tupleof[i];
435
436 //Type v = getValueOfField!(T, Type, field)(value);
437 serialize(v, toDataType(field)); 438 serialize(v, toDataType(field));
438 } 439 }
439 } 440 }
440 441
441 static if (is(T : Object) && !is(T == Object)) 442 static if (is(T : Object) && !is(T == Object))
442 serializeBaseTypes(value, nonSerializedFields); 443 serializeBaseTypes(value);
443 } 444 }
444 445
445 private void objectStructDeserializeHelper (T) (T value, string[] nonSerializedFields) 446 private void objectStructDeserializeHelper (T) (T value)
446 { 447 {
448 const nonSerializedFields = collectAnnotations!(nonSerializedField)(value);
449
447 foreach (i, dummy ; typeof(T.tupleof)) 450 foreach (i, dummy ; typeof(T.tupleof))
448 { 451 {
449 const field = nameOfFieldAt!(T, i); 452 const field = nameOfFieldAt!(T, i);
450 453
451 if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) 454 static if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field))
452 { 455 {
453 alias TypeOfField!(T, field) Type; 456 alias TypeOfField!(T, field) Type;
454 auto fieldValue = deserializeInternal!(Type)(toDataType(field)); 457 auto fieldValue = deserializeInternal!(Type)(toDataType(field));
455 setValueOfField!(T, Type, field)(value, fieldValue); 458 value.tupleof[i] = fieldValue;
456 } 459 }
457 } 460 }
458 461
459 static if (is(T : Object) && !is(T == Object)) 462 static if (is(T : Object) && !is(T == Object))
460 deserializeBaseTypes(value, nonSerializedFields); 463 deserializeBaseTypes(value);
461 } 464 }
462 465
463 private void serializeBaseTypes (T : Object) (T value, string[] nonSerializedFields) 466 private void serializeBaseTypes (T : Object) (T value)
464 { 467 {
465 alias BaseTypeTupleOf!(T)[0] Base; 468 alias BaseTypeTupleOf!(T)[0] Base;
466 469
467 static if (!is(Base == Object)) 470 static if (!is(Base == Object))
468 { 471 {
469 archive.archiveBaseClass!(Base)(nextKey); 472 archive.archiveBaseClass!(Base)(nextKey);
470 objectStructSerializeHelper!(Base)(value, nonSerializedFields); 473 objectStructSerializeHelper!(Base)(value);
471 } 474 }
472 } 475 }
473 476
474 private void deserializeBaseTypes (T : Object) (T value, string[] nonSerializedFields) 477 private void deserializeBaseTypes (T : Object) (T value)
475 { 478 {
476 alias BaseTypeTupleOf!(T)[0] Base; 479 alias BaseTypeTupleOf!(T)[0] Base;
477 480
478 static if (!is(Base == Object)) 481 static if (!is(Base == Object))
479 { 482 {
480 archive.unarchiveBaseClass!(Base)(nextKey); 483 archive.unarchiveBaseClass!(Base)(nextKey);
481 objectStructDeserializeHelper!(Base)(value, nonSerializedFields); 484 objectStructDeserializeHelper!(Base)(value);
482 } 485 }
483 } 486 }
484 487
485 private SerializeRegisterWrapper!(T, ArchiveType) getSerializerWrapper (T) (string type) 488 private SerializeRegisterWrapper!(T, ArchiveType) getSerializerWrapper (T) (string type)
486 { 489 {
581 584
582 else 585 else
583 triggerEvent!(onDeserializedField)(value); 586 triggerEvent!(onDeserializedField)(value);
584 } 587 }
585 588
586 private string[] collectAnnotations (string name, T) (T value) 589 private static string[] collectAnnotations (string name, T) (T value)
587 { 590 {
588 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.`)); 591 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.`));
589 592
590 string[] annotations; 593 string[] annotations;
591 594
593 { 596 {
594 const field = nameOfFieldAt!(T, i); 597 const field = nameOfFieldAt!(T, i);
595 598
596 static if (field == name) 599 static if (field == name)
597 { 600 {
598 alias TypeOfField!(T, field) Type; 601 typeof(value.tupleof[i]) f;
599 auto f = getValueOfField!(T, Type, field)(value);
600 annotations ~= f.field; 602 annotations ~= f.field;
601 } 603 }
602 } 604 }
603 605
604 return annotations; 606 return annotations;