Mercurial > projects > orange

comparison orange/serialization/Serializer.d @ 30:9d1a8023bb89 experimental

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added IDs to every serialized value.
author Jacob Carlborg <doob@me.com>
date Sun, 21 Nov 2010 17:12:24 +0100
parents c422ff6477dd
children c68d29967c9f
comparison
equal deleted inserted replaced
29:c422ff6477dd 30:9d1a8023bb89
136 postProcess; 136 postProcess;
137 137
138 return archive.untypedData; 138 return archive.untypedData;
139 } 139 }
140 140
141 private void serializeInternal (T) (T value, string key = null) 141 private void serializeInternal (T) (T value, string key = null, Id id = Id.max)
142 { 142 {
143 if (!key) 143 if (!key)
144 key = nextKey; 144 key = nextKey;
145 145
146 if (id == Id.max)
147 id = nextId;
148
146 archive.beginArchiving(); 149 archive.beginArchiving();
147 150
148 static if ( is(T == typedef) ) 151 static if ( is(T == typedef) )
149 serializeTypedef(value, key); 152 serializeTypedef(value, key, id);
150 153
151 else static if (isObject!(T)) 154 else static if (isObject!(T))
152 serializeObject(value, key); 155 serializeObject(value, key, id);
153 156
154 else static if (isStruct!(T)) 157 else static if (isStruct!(T))
155 serializeStruct(value, key); 158 serializeStruct(value, key, id);
156 159
157 else static if (isString!(T)) 160 else static if (isString!(T))
158 serializeString(value, key); 161 serializeString(value, key, id);
159 162
160 else static if (isArray!(T)) 163 else static if (isArray!(T))
161 serializeArray(value, key); 164 serializeArray(value, key, id);
162 165
163 else static if (isAssociativeArray!(T)) 166 else static if (isAssociativeArray!(T))
164 serializeAssociativeArray(value, key); 167 serializeAssociativeArray(value, key, id);
165 168
166 else static if (isPrimitive!(T)) 169 else static if (isPrimitive!(T))
167 serializePrimitive(value, key); 170 serializePrimitive(value, key, id);
168 171
169 else static if (isPointer!(T)) 172 else static if (isPointer!(T))
170 { 173 {
171 static if (isFunctionPointer!(T)) 174 static if (isFunctionPointer!(T))
172 goto error; 175 goto error;
173 176
174 else 177 else
175 serializePointer(value, key); 178 serializePointer(value, key, id);
176 } 179 }
177 180
178 else static if (isEnum!(T)) 181 else static if (isEnum!(T))
179 serializeEnum(value, key); 182 serializeEnum(value, key, id);
180 183
181 else 184 else
182 { 185 {
183 error: 186 error:
184 throw new SerializationException(format!(`The type "`, T, `" cannot be serialized.`), __FILE__, __LINE__); 187 throw new SerializationException(format!(`The type "`, T, `" cannot be serialized.`), __FILE__, __LINE__);
185 } 188 }
186 } 189 }
187 190
188 private void serializeObject (T) (T value, string key) 191 private void serializeObject (T) (T value, string key, Id id)
189 { 192 {
190 if (!value) 193 if (!value)
191 return archive.archiveNull(T.stringof, key); 194 return archive.archiveNull(T.stringof, key);
192 195
193 auto reference = getSerializedReference(value); 196 auto reference = getSerializedReference(value);
195 if (reference != Id.max) 198 if (reference != Id.max)
196 return archive.archiveReference(key, reference); 199 return archive.archiveReference(key, reference);
197 200
198 auto runtimeType = value.classinfo.name; 201 auto runtimeType = value.classinfo.name;
199 202
200 Id id = nextId;
201 addSerializedReference(value, id); 203 addSerializedReference(value, id);
202 204
203 triggerEvents(serializing, value, { 205 triggerEvents(serializing, value, {
204 archive.archiveObject(runtimeType, T.stringof, key, id, { 206 archive.archiveObject(runtimeType, T.stringof, key, id, {
205 if (runtimeType in serializers) 207 if (runtimeType in serializers)
220 } 222 }
221 }); 223 });
222 }); 224 });
223 } 225 }
224 226
225 private void serializeStruct (T) (T value, string key) 227 private void serializeStruct (T) (T value, string key, Id id)
226 { 228 {
227 string type = T.stringof; 229 string type = T.stringof;
228 230
229 triggerEvents(serializing, value, { 231 triggerEvents(serializing, value, {
230 archive.archiveStruct(type, key, nextId, { 232 archive.archiveStruct(type, key, id, {
231 if (type in serializers) 233 if (type in serializers)
232 { 234 {
233 auto wrapper = getSerializerWrapper!(T)(type); 235 auto wrapper = getSerializerWrapper!(T)(type);
234 wrapper(value, this, key); 236 wrapper(value, this, key);
235 } 237 }
244 } 246 }
245 }); 247 });
246 }); 248 });
247 } 249 }
248 250
249 private void serializeString (T) (T value, string key) 251 private void serializeString (T) (T value, string key, Id id)
250 { 252 {
251 auto id = nextId;
252 auto array = Array(value.ptr, value.length, ElementTypeOfArray!(T).sizeof); 253 auto array = Array(value.ptr, value.length, ElementTypeOfArray!(T).sizeof);
253 254
254 archive.archive(value, key, id); 255 archive.archive(value, key, id);
255 addSerializedArray(array, id); 256 addSerializedArray(array, id);
256 } 257 }
257 258
258 private void serializeArray (T) (T value, string key) 259 private void serializeArray (T) (T value, string key, Id id)
259 { 260 {
260 auto array = Array(value.ptr, value.length, ElementTypeOfArray!(T).sizeof); 261 auto array = Array(value.ptr, value.length, ElementTypeOfArray!(T).sizeof);
261 auto id = nextId;
262 262
263 archive.archiveArray(array, arrayToString!(T), key, id, { 263 archive.archiveArray(array, arrayToString!(T), key, id, {
264 foreach (i, e ; value) 264 foreach (i, e ; value)
265 serializeInternal(e, toData(i)); 265 serializeInternal(e, toData(i));
266 }); 266 });
267 267
268 addSerializedArray(array, id); 268 addSerializedArray(array, id);
269 } 269 }
270 270
271 private void serializeAssociativeArray (T) (T value, string key) 271 private void serializeAssociativeArray (T) (T value, string key, Id id)
272 { 272 {
273 auto reference = getSerializedReference(value); 273 auto reference = getSerializedReference(value);
274 274
275 if (reference != Id.max) 275 if (reference != Id.max)
276 return archive.archiveReference(key, reference); 276 return archive.archiveReference(key, reference);
277 277
278 Id id = nextId;
279 addSerializedReference(value, id); 278 addSerializedReference(value, id);
280 279
281 string keyType = KeyTypeOfAssociativeArray!(T).stringof; 280 string keyType = KeyTypeOfAssociativeArray!(T).stringof;
282 string valueType = ValueTypeOfAssociativeArray!(T).stringof; 281 string valueType = ValueTypeOfAssociativeArray!(T).stringof;
283 282
297 i++; 296 i++;
298 } 297 }
299 }); 298 });
300 } 299 }
301 300
302 private void serializePointer (T) (T value, string key) 301 private void serializePointer (T) (T value, string key, Id id)
303 { 302 {
304 if (!value) 303 if (!value)
305 return archive.archiveNull(T.stringof, key); 304 return archive.archiveNull(T.stringof, key);
306
307 Id id = nextId;
308 305
309 archive.archivePointer(key, id, { 306 archive.archivePointer(key, id, {
310 if (key in serializers) 307 if (key in serializers)
311 { 308 {
312 auto wrapper = getSerializerWrapper!(T)(key); 309 auto wrapper = getSerializerWrapper!(T)(key);
327 }); 324 });
328 325
329 addSerializedPointer(value, id); 326 addSerializedPointer(value, id);
330 } 327 }
331 328
332 private void serializeEnum (T) (T value, string key) 329 private void serializeEnum (T) (T value, string key, Id id)
333 { 330 {
334 alias BaseTypeOfEnum!(T) EnumBaseType; 331 alias BaseTypeOfEnum!(T) EnumBaseType;
335 auto val = cast(EnumBaseType) value; 332 auto val = cast(EnumBaseType) value;
336 string type = T.stringof; 333 string type = T.stringof;
337 334
338 archive.archiveEnum(val, type, key, nextId); 335 archive.archiveEnum(val, type, key, id);
339 } 336 }
340 337
341 private void serializePrimitive (T) (T value, string key) 338 private void serializePrimitive (T) (T value, string key, Id id)
342 { 339 {
343 archive.archive(value, key, nextId); 340 archive.archive(value, key, id);
344 } 341 }
345 342
346 private void serializeTypedef (T) (T value, string key) 343 private void serializeTypedef (T) (T value, string key, Id id)
347 { 344 {
348 archive.archiveTypedef(T.stringof, key, nextId, { 345 archive.archiveTypedef(T.stringof, key, nextId, {
349 serializeInternal!(BaseTypeOfTypedef!(T))(value, nextKey); 346 serializeInternal!(BaseTypeOfTypedef!(T))(value, id);
350 }); 347 });
351 } 348 }
352 349
353 T deserialize (T) (Data data, string key = null) 350 T deserialize (T) (Data data, string key = null)
354 { 351 {
663 const field = nameOfFieldAt!(T, i); 660 const field = nameOfFieldAt!(T, i);
664 661
665 static if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field)) 662 static if (!internalFields.ctfeContains(field) && !nonSerializedFields.ctfeContains(field))
666 { 663 {
667 alias typeof(T.tupleof[i]) Type; 664 alias typeof(T.tupleof[i]) Type;
668 Type v = value.tupleof[i]; 665 Type v = value.tupleof[i];
669 666 auto id = nextId;
670 addSerializedValue(value.tupleof[i], nextId); 667
671 serializeInternal(v, toData(field)); 668 addSerializedValue(value.tupleof[i], id);
672 } 669 serializeInternal(v, toData(field), id);
670 }
673 } 671 }
674 672
675 static if (isObject!(T) && !is(T == Object)) 673 static if (isObject!(T) && !is(T == Object))
676 serializeBaseTypes(value); 674 serializeBaseTypes(value);
677 } 675 }