---

yaml
---
r: 14838
b: refs/heads/try
c: ffa187d
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: c6f2594319266c73f9b5a6c69dd482d6fda8dd12
+refs/heads/try: ffa187db252a7ee8765025f95d2cae18859258be
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libcore/core.rc

@@ -31,7 +31,7 @@ export uint, u8, u16, u32, u64;
 export float, f32, f64;
 export box, char, str, ptr, vec, bool;
 export either, option, result, iter;
-export libc, os, io, run, rand, sys, unsafe, logging, serialization;
+export libc, os, io, run, rand, sys, unsafe, logging;
 export comm, task, future;
 export extfmt;
 export tuple;
@@ -88,7 +88,6 @@ mod cmath;
 mod sys;
 mod unsafe;
 mod logging;
-mod serialization;
 
 // Concurrency
 mod comm;

branches/try/src/libcore/serialization.rs

@@ -192,14 +192,6 @@ fn compl(i: uint) -> uint {
     max_value ^ i
 }
 
-fn serialize<S: serialization::serializer>(s: S, v: uint) {
-    s.emit_uint(v);
-}
-
-fn deserialize<D: serialization::deserializer>(d: D) -> uint {
-    d.read_uint()
-}
-
 #[cfg(test)]
 mod tests {
 

branches/try/src/libcore/uint.rs

@@ -293,7 +293,7 @@ enum ebml_serializer_tag {
     es_label // Used only when debugging
 }
 
-impl serializer of core::serialization::serializer for ebml::writer {
+impl serializer of serialization::serializer for ebml::writer {
     fn emit_nil() {}
 
     // used internally to emit things like the vector length and so on
@@ -371,7 +371,7 @@ fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
     {mutable parent: d, mutable pos: d.start}
 }
 
-impl deserializer of core::serialization::deserializer for ebml_deserializer {
+impl deserializer of serialization::deserializer for ebml_deserializer {
     fn _check_label(lbl: str) {
         if self.pos < self.parent.end {
             let {tag: r_tag, doc: r_doc} =

branches/try/src/libstd/ebml.rs

@@ -1,12 +1,122 @@
-#[doc = "Support code for serialization.
-
-Deprecated in favor of core::serialization."];
+#[doc = "Support code for serialization."];
 
 use core;
-import list::list;
-import ebml::writer;
 
-import core::serialization::{serializer,deserializer};
+/*
+Core serialization interfaces.
+*/
+
+iface serializer {
+    // Primitive types:
+    fn emit_nil();
+    fn emit_uint(v: uint);
+    fn emit_u64(v: u64);
+    fn emit_u32(v: u32);
+    fn emit_u16(v: u16);
+    fn emit_u8(v: u8);
+    fn emit_int(v: int);
+    fn emit_i64(v: i64);
+    fn emit_i32(v: i32);
+    fn emit_i16(v: i16);
+    fn emit_i8(v: i8);
+    fn emit_bool(v: bool);
+    fn emit_float(v: float);
+    fn emit_f64(v: f64);
+    fn emit_f32(v: f32);
+    fn emit_str(v: str);
+
+    // Compound types:
+    fn emit_enum(name: str, f: fn());
+    fn emit_enum_variant(v_name: str, v_id: uint, sz: uint, f: fn());
+    fn emit_enum_variant_arg(idx: uint, f: fn());
+    fn emit_vec(len: uint, f: fn());
+    fn emit_vec_elt(idx: uint, f: fn());
+    fn emit_box(f: fn());
+    fn emit_uniq(f: fn());
+    fn emit_rec(f: fn());
+    fn emit_rec_field(f_name: str, f_idx: uint, f: fn());
+    fn emit_tup(sz: uint, f: fn());
+    fn emit_tup_elt(idx: uint, f: fn());
+}
+
+iface deserializer {
+    // Primitive types:
+    fn read_nil() -> ();
+
+    fn read_uint() -> uint;
+    fn read_u64() -> u64;
+    fn read_u32() -> u32;
+    fn read_u16() -> u16;
+    fn read_u8() -> u8;
+
+    fn read_int() -> int;
+    fn read_i64() -> i64;
+    fn read_i32() -> i32;
+    fn read_i16() -> i16;
+    fn read_i8() -> i8;
+
+
+    fn read_bool() -> bool;
+
+    fn read_str() -> str;
+
+    fn read_f64() -> f64;
+    fn read_f32() -> f32;
+    fn read_float() -> float;
+
+    // Compound types:
+    fn read_enum<T:copy>(name: str, f: fn() -> T) -> T;
+    fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T;
+    fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T;
+    fn read_vec<T:copy>(f: fn(uint) -> T) -> T;
+    fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T;
+    fn read_box<T:copy>(f: fn() -> T) -> T;
+    fn read_uniq<T:copy>(f: fn() -> T) -> T;
+    fn read_rec<T:copy>(f: fn() -> T) -> T;
+    fn read_rec_field<T:copy>(f_name: str, f_idx: uint, f: fn() -> T) -> T;
+    fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T;
+    fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T;
+}
+
+// ___________________________________________________________________________
+// Helper routines
+//
+// In some cases, these should eventually be coded as traits.
+
+fn emit_from_vec<S: serializer, T>(s: S, v: [T], f: fn(T)) {
+    s.emit_vec(vec::len(v)) {||
+        vec::iteri(v) {|i,e|
+            s.emit_vec_elt(i) {||
+                f(e)
+            }
+        }
+    }
+}
+
+fn read_to_vec<D: deserializer, T>(d: D, f: fn() -> T) -> [T] {
+    d.read_vec {|len|
+        vec::from_fn(len) {|i|
+            d.read_vec_elt(i) {|| f() }
+        }
+    }
+}
+
+impl serializer_helpers<S: serializer> for S {
+    fn emit_from_vec<T>(v: [T], f: fn(T)) {
+        emit_from_vec(self, v, f)
+    }
+}
+
+impl deserializer_helpers<D: deserializer> for D {
+    fn read_to_vec<T>(f: fn() -> T) -> [T] {
+        read_to_vec(self, f)
+    }
+}
+
+fn serialize_uint<S: serializer>(s: S, v: uint) {
+    s.emit_uint(v);
+}
 
-export serializer;
-export deserializer;
+fn deserialize_uint<D: deserializer>(d: D) -> uint {
+    d.read_uint()
+}

branches/try/src/libstd/serialization.rs

@@ -9,10 +9,10 @@ import std::ebml::writer;
 import std::ebml::serializer;
 import std::ebml::deserializer;
 import std::map::hashmap;
-import serialization::serializer;
-import serialization::deserializer;
-import serialization::serializer_helpers;
-import serialization::deserializer_helpers;
+import std::serialization::serializer;
+import std::serialization::deserializer;
+import std::serialization::serializer_helpers;
+import std::serialization::deserializer_helpers;
 import std::smallintmap::map;
 import middle::trans::common::maps;
 import middle::{ty, typeck, last_use, ast_map};
@@ -295,13 +295,13 @@ impl of tr for span {
     }
 }
 
-impl serializer_helpers<S: serialization::serializer> for S {
+impl serializer_helpers<S: serializer> for S {
     fn emit_def_id(did: ast::def_id) {
         astencode_gen::serialize_syntax_ast_def_id(self, did)
     }
 }
 
-impl deserializer_helpers<D: serialization::deserializer> for D {
+impl deserializer_helpers<D: deserializer> for D {
     fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id {
         let did = astencode_gen::deserialize_syntax_ast_def_id(self);
         did.tr(xcx)