← Back to branch summary

~ubuntu-branches/ubuntu/maverick/haxe/maverick

« back to all changes in this revision

Viewing changes to haxe/std/haxe/Serializer.hx

  • Committer: Bazaar Package Importer
  • Author(s): Jens Peter Secher
  • Date: 2008-06-15 11:04:09 UTC
  • mfrom: (2.1.6 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080615110409-7pyykgwmk5v0cues
Tags: 1:1.19-3
http://bugs.debian.org/484390
* Remove bashism in script.
  (Closes: #484390)
* Upgrade to Policy 3.8.0 by including a README.source explaining how to
  use dpatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
haxe/std/haxe/Serializer.hx
26
26
 
27
27
class Serializer {
28
28
 
 
29
        /**
 
30
                If the values you are serializing can contain
 
31
                circular references or objects repetitions, you should
 
32
                set USE_CACHE to true to prevent infinite loops.
 
33
        **/
 
34
        public static var USE_CACHE = false;
 
35
 
 
36
        /**
 
37
                Use constructor indexes for enums instead of names.
 
38
                This is less reliable but more compact.
 
39
        **/
 
40
        public static var USE_ENUM_INDEX = false;
 
41
 
29
42
        var buf : StringBuf;
30
43
        var cache : Array<Dynamic>;
31
44
        var shash : Hash<Int>;
32
45
        var scount : Int;
33
46
        var useCache : Bool;
 
47
        var useEnumIndex : Bool;
34
48
 
35
49
        public function new() {
36
50
                buf = new StringBuf();
37
51
                cache = new Array();
38
 
                useCache = true;
 
52
                useCache = USE_CACHE;
 
53
                useEnumIndex = USE_ENUM_INDEX;
39
54
                shash = new Hash();
40
55
                scount = 0;
41
56
        }
42
57
 
43
 
        /**
44
 
                Desactivate object caching. If you are sure that your value
45
 
                does not contain multiple references to the same object or
46
 
                circular references between objects, this should speedup
47
 
                serialization.
48
 
        **/
49
 
        public function dontUseCache() {
50
 
                useCache = false;
51
 
        }
52
 
 
53
58
        public function toString() {
54
59
                return buf.toString();
55
60
        }
64
69
                g : object end
65
70
                h : array/list/hash end
66
71
                i : Int
67
 
                j : utf8 escaped string
 
72
                j : enum (by index)
68
73
                k : NaN
69
74
                l : list
70
75
                m : -Inf
73
78
                p : +Inf
74
79
                q : inthash
75
80
                r : reference
76
 
                s : utf8 string
 
81
                s :
77
82
                t : true
78
83
                u : array nulls
79
84
                v : date
80
85
                w : enum
81
86
                x : exception
82
 
                y : *unused
 
87
                y : urlencoded string
83
88
                z : zero
84
89
        */
85
90
 
91
96
                        return;
92
97
                }
93
98
                shash.set(s,scount++);
94
 
                if( s.indexOf("\n") != -1 || s.indexOf("\r") != -1 ) {
95
 
                        buf.add("j");
96
 
                        s = s.split("\\").join("\\\\").split("\n").join("\\n").split("\r").join("\\r");
97
 
                } else
98
 
                        buf.add("s");
99
 
                #if neko
100
 
                buf.add(neko.Utf8.length(s));
101
 
                #else true
 
99
                #if old_serialize
 
100
                        // no more support for -D old_serialize due to 'j' reuse
 
101
                        #if error #end
 
102
                #end
 
103
                buf.add("y");
 
104
                s = StringTools.urlEncode(s);
102
105
                buf.add(s.length);
103
 
                #end
104
106
                buf.add(":");
105
107
                buf.add(s);
106
108
        }
173
175
                case TBool:
174
176
                        buf.add(if( v ) "t" else "f");
175
177
                case TClass(c):
176
 
                        if( c == cast String ) {
 
178
                        if( c == String ) {
177
179
                                serializeString(v);
178
180
                                return;
179
181
                        }
211
213
                                buf.add("h");
212
214
                        case cast List:
213
215
                                buf.add("l");
214
 
                                for( i in v.iterator() )
 
216
                                var v : List<Dynamic> = v;
 
217
                                for( i in v )
215
218
                                        serialize(i);
216
219
                                buf.add("h");
217
220
                        case cast Date:
 
221
                                var d : Date = v;
218
222
                                buf.add("v");
219
 
                                buf.add(v);
 
223
                                buf.add(d.toString());
220
224
                        case cast Hash:
221
225
                                buf.add("b");
 
226
                                var v : Hash<Dynamic> = v;
222
227
                                for( k in v.keys() ) {
223
228
                                        serializeString(k);
224
229
                                        serialize(v.get(k));
226
231
                                buf.add("h");
227
232
                        case cast IntHash:
228
233
                                buf.add("q");
 
234
                                var v : IntHash<Dynamic> = v;
229
235
                                for( k in v.keys() ) {
230
236
                                        buf.add(":");
231
237
                                        buf.add(k);
232
238
                                        serialize(v.get(k));
233
239
                                }
234
240
                                buf.add("h");
 
241
                        #if flash9
 
242
                        case cast flash.utils.ByteArray:
 
243
                                buf.add("y");
 
244
                                var s = "";
 
245
                                var b : flash.utils.ByteArray = v;
 
246
                                var CHARS = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];
 
247
                                for( p in 0...b.length ) {
 
248
                                        var c = b[p];
 
249
                                        // 0-9a-zA-Z
 
250
                                        if( (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) )
 
251
                                                s += String.fromCharCode(c);
 
252
                                        else
 
253
                                                s += "%"+CHARS[c>>4]+CHARS[c&15];
 
254
                                }
 
255
                                buf.add(s.length);
 
256
                                buf.add(":");
 
257
                                buf.add(s);
 
258
                        #end
235
259
                        default:
236
260
                                cache.pop();
237
261
                                buf.add("c");
238
 
                                serialize(Type.getClassName(c));
 
262
                                serializeString(Type.getClassName(c));
239
263
                                cache.push(v);
240
264
                                #if flash9
241
265
                                serializeClassFields(v,c);
252
276
                        if( useCache && serializeRef(v) )
253
277
                                return;
254
278
                        cache.pop();
255
 
                        buf.add("w");
256
 
                        serialize(Type.getEnumName(e));
 
279
                        buf.add(useEnumIndex?"j":"w");
 
280
                        serializeString(Type.getEnumName(e));
257
281
                        #if neko
258
 
                        serializeString(new String(v.tag));
 
282
                        if( useEnumIndex ) {
 
283
                                buf.add(":");
 
284
                                buf.add(v.index);
 
285
                        } else
 
286
                                serializeString(new String(v.tag));
259
287
                        buf.add(":");
260
288
                        if( v.args == null )
261
289
                                buf.add(0);
266
294
                                        serialize(v.args[i]);
267
295
                        }
268
296
                        #else flash9
269
 
                        serializeString(v.tag);
 
297
                        if( useEnumIndex ) {
 
298
                                buf.add(":");
 
299
                                buf.add(v.index);
 
300
                        } else
 
301
                                serializeString(v.tag);
270
302
                        buf.add(":");
271
303
                        if( v.params == null )
272
304
                                buf.add(0);
277
309
                                        serialize(v.params[i]);
278
310
                        }
279
311
                        #else true
280
 
                        serializeString(v[0]);
 
312
                        if( useEnumIndex ) {
 
313
                                buf.add(":");
 
314
                                buf.add(v[1]);
 
315
                        } else
 
316
                                serializeString(v[0]);
281
317
                        buf.add(":");
282
318
                        var l = v[untyped "length"];
283
 
                        buf.add(l - 1);
284
 
                        for( i in 1...l )
 
319
                        buf.add(l - 2);
 
320
                        for( i in 2...l )
285
321
                                serialize(v[i]);
286
322
                        #end
287
323
                        cache.push(v);
296
332
                buf.add("x");
297
333
                #if flash9
298
334
                if( untyped __is__(e,__global__["Error"]) ) {
299
 
                        serialize(e.message);
 
335
                        var s = e.getStackTrace();
 
336
                        if( s == null )
 
337
                                serialize(e.message);
 
338
                        else
 
339
                                serialize(s);
300
340
                        return;
301
341
                }
302
342
                #end