libstd: make Serializer a trait-level typaram
This commit is contained in:
Erick Tryzelaar
Niko Matsakis
parent
07edf90367
commit
ab89b5c294
5 changed files with 692 additions and 77 deletions
|
|
@ -273,6 +273,7 @@ pub impl PrettySerializer: serialization::Serializer {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub impl Json: serialization::Serializable {
|
||||
fn serialize<S: serialization::Serializer>(&self, s: &S) {
|
||||
match *self {
|
||||
|
|
@ -296,6 +297,33 @@ pub impl Json: serialization::Serializable {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub impl<
|
||||
S: serialization::Serializer
|
||||
> Json: serialization::Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
match *self {
|
||||
Number(v) => v.serialize(s),
|
||||
String(ref v) => v.serialize(s),
|
||||
Boolean(v) => v.serialize(s),
|
||||
List(v) => v.serialize(s),
|
||||
Object(ref v) => {
|
||||
do s.emit_rec || {
|
||||
let mut idx = 0;
|
||||
for v.each |key, value| {
|
||||
do s.emit_field(*key, idx) {
|
||||
value.serialize(s);
|
||||
}
|
||||
idx += 1;
|
||||
}
|
||||
}
|
||||
},
|
||||
Null => s.emit_nil(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Serializes a json value into a io::writer
|
||||
pub fn to_writer(wr: io::Writer, json: &Json) {
|
||||
json.serialize(&Serializer(wr))
|
||||
|
|
|
|||
|
|
@ -92,6 +92,8 @@ pub trait Deserializer {
|
|||
fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T;
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
pub mod traits {
|
||||
pub trait Serializable {
|
||||
fn serialize<S: Serializer>(&self, s: &S);
|
||||
}
|
||||
|
|
@ -561,3 +563,488 @@ pub impl<D: Deserializer> D: DeserializerHelpers {
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
pub mod traits {
|
||||
pub trait Serializable<S: Serializer> {
|
||||
fn serialize(&self, s: &S);
|
||||
}
|
||||
|
||||
pub trait Deserializable<D: Deserializer> {
|
||||
static fn deserialize(&self, d: &D) -> self;
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> uint: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_uint(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> uint: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> uint {
|
||||
d.read_uint()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> u8: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_u8(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> u8: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> u8 {
|
||||
d.read_u8()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> u16: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_u16(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> u16: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> u16 {
|
||||
d.read_u16()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> u32: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_u32(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> u32: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> u32 {
|
||||
d.read_u32()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> u64: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_u64(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> u64: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> u64 {
|
||||
d.read_u64()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> int: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_int(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> int: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> int {
|
||||
d.read_int()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> i8: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_i8(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> i8: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> i8 {
|
||||
d.read_i8()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> i16: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_i16(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> i16: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> i16 {
|
||||
d.read_i16()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> i32: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_i32(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> i32: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> i32 {
|
||||
d.read_i32()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> i64: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_i64(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> i64: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> i64 {
|
||||
d.read_i64()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> &str: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_borrowed_str(*self) }
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> ~str: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_owned_str(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> ~str: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> ~str {
|
||||
d.read_owned_str()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> @str: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_managed_str(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> @str: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> @str {
|
||||
d.read_managed_str()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> float: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_float(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> float: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> float {
|
||||
d.read_float()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> f32: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_f32(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> f32: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> f32 {
|
||||
d.read_f32() }
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> f64: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_f64(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> f64: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> f64 {
|
||||
d.read_f64()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> bool: Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_bool(*self) }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> bool: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> bool {
|
||||
d.read_bool()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> (): Serializable<S> {
|
||||
fn serialize(&self, s: &S) { s.emit_nil() }
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> (): Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> () {
|
||||
d.read_nil()
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> &T: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
s.emit_borrowed(|| (**self).serialize(s))
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> ~T: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
s.emit_owned(|| (**self).serialize(s))
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer, T: Deserializable<D>> ~T: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> ~T {
|
||||
d.read_owned(|| ~deserialize(d))
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> @T: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
s.emit_managed(|| (**self).serialize(s))
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer, T: Deserializable<D>> @T: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> @T {
|
||||
d.read_managed(|| @deserialize(d))
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> &[T]: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
do s.emit_borrowed_vec(self.len()) {
|
||||
for self.eachi |i, e| {
|
||||
s.emit_vec_elt(i, || e.serialize(s))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> ~[T]: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
do s.emit_owned_vec(self.len()) {
|
||||
for self.eachi |i, e| {
|
||||
s.emit_vec_elt(i, || e.serialize(s))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer, T: Deserializable<D>> ~[T]: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> ~[T] {
|
||||
do d.read_owned_vec |len| {
|
||||
do vec::from_fn(len) |i| {
|
||||
d.read_vec_elt(i, || deserialize(d))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> @[T]: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
do s.emit_managed_vec(self.len()) {
|
||||
for self.eachi |i, e| {
|
||||
s.emit_vec_elt(i, || e.serialize(s))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer, T: Deserializable<D>> @[T]: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> @[T] {
|
||||
do d.read_managed_vec |len| {
|
||||
do at_vec::from_fn(len) |i| {
|
||||
d.read_vec_elt(i, || deserialize(d))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<S: Serializer, T: Serializable<S>> Option<T>: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
do s.emit_enum(~"option") {
|
||||
match *self {
|
||||
None => do s.emit_enum_variant(~"none", 0u, 0u) {
|
||||
},
|
||||
|
||||
Some(ref v) => do s.emit_enum_variant(~"some", 1u, 1u) {
|
||||
s.emit_enum_variant_arg(0u, || v.serialize(s))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer, T: Deserializable<D>> Option<T>: Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> Option<T> {
|
||||
do d.read_enum(~"option") {
|
||||
do d.read_enum_variant |i| {
|
||||
match i {
|
||||
0 => None,
|
||||
1 => Some(d.read_enum_variant_arg(0u, || deserialize(d))),
|
||||
_ => fail(#fmt("Bad variant for option: %u", i))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
S: Serializer,
|
||||
T0: Serializable<S>,
|
||||
T1: Serializable<S>
|
||||
> (T0, T1): Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
match *self {
|
||||
(ref t0, ref t1) => {
|
||||
do s.emit_tup(2) {
|
||||
s.emit_tup_elt(0, || t0.serialize(s));
|
||||
s.emit_tup_elt(1, || t1.serialize(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
D: Deserializer,
|
||||
T0: Deserializable<D>,
|
||||
T1: Deserializable<D>
|
||||
> (T0, T1): Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> (T0, T1) {
|
||||
do d.read_tup(2) {
|
||||
(
|
||||
d.read_tup_elt(0, || deserialize(d)),
|
||||
d.read_tup_elt(1, || deserialize(d))
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
S: Serializer,
|
||||
T0: Serializable<S>,
|
||||
T1: Serializable<S>,
|
||||
T2: Serializable<S>
|
||||
> (T0, T1, T2): Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
match *self {
|
||||
(ref t0, ref t1, ref t2) => {
|
||||
do s.emit_tup(3) {
|
||||
s.emit_tup_elt(0, || t0.serialize(s));
|
||||
s.emit_tup_elt(1, || t1.serialize(s));
|
||||
s.emit_tup_elt(2, || t2.serialize(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
D: Deserializer,
|
||||
T0: Deserializable<D>,
|
||||
T1: Deserializable<D>,
|
||||
T2: Deserializable<D>
|
||||
> (T0, T1, T2): Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> (T0, T1, T2) {
|
||||
do d.read_tup(3) {
|
||||
(
|
||||
d.read_tup_elt(0, || deserialize(d)),
|
||||
d.read_tup_elt(1, || deserialize(d)),
|
||||
d.read_tup_elt(2, || deserialize(d))
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
S: Serializer,
|
||||
T0: Serializable<S>,
|
||||
T1: Serializable<S>,
|
||||
T2: Serializable<S>,
|
||||
T3: Serializable<S>
|
||||
> (T0, T1, T2, T3): Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
match *self {
|
||||
(ref t0, ref t1, ref t2, ref t3) => {
|
||||
do s.emit_tup(4) {
|
||||
s.emit_tup_elt(0, || t0.serialize(s));
|
||||
s.emit_tup_elt(1, || t1.serialize(s));
|
||||
s.emit_tup_elt(2, || t2.serialize(s));
|
||||
s.emit_tup_elt(3, || t3.serialize(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
D: Deserializer,
|
||||
T0: Deserializable<D>,
|
||||
T1: Deserializable<D>,
|
||||
T2: Deserializable<D>,
|
||||
T3: Deserializable<D>
|
||||
> (T0, T1, T2, T3): Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D) -> (T0, T1, T2, T3) {
|
||||
do d.read_tup(4) {
|
||||
(
|
||||
d.read_tup_elt(0, || deserialize(d)),
|
||||
d.read_tup_elt(1, || deserialize(d)),
|
||||
d.read_tup_elt(2, || deserialize(d)),
|
||||
d.read_tup_elt(3, || deserialize(d))
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
S: Serializer,
|
||||
T0: Serializable<S>,
|
||||
T1: Serializable<S>,
|
||||
T2: Serializable<S>,
|
||||
T3: Serializable<S>,
|
||||
T4: Serializable<S>
|
||||
> (T0, T1, T2, T3, T4): Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
match *self {
|
||||
(ref t0, ref t1, ref t2, ref t3, ref t4) => {
|
||||
do s.emit_tup(5) {
|
||||
s.emit_tup_elt(0, || t0.serialize(s));
|
||||
s.emit_tup_elt(1, || t1.serialize(s));
|
||||
s.emit_tup_elt(2, || t2.serialize(s));
|
||||
s.emit_tup_elt(3, || t3.serialize(s));
|
||||
s.emit_tup_elt(4, || t4.serialize(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<
|
||||
D: Deserializer,
|
||||
T0: Deserializable<D>,
|
||||
T1: Deserializable<D>,
|
||||
T2: Deserializable<D>,
|
||||
T3: Deserializable<D>,
|
||||
T4: Deserializable<D>
|
||||
> (T0, T1, T2, T3, T4): Deserializable<D> {
|
||||
static fn deserialize(&self, d: &D)
|
||||
-> (T0, T1, T2, T3, T4) {
|
||||
do d.read_tup(5) {
|
||||
(
|
||||
d.read_tup_elt(0, || deserialize(d)),
|
||||
d.read_tup_elt(1, || deserialize(d)),
|
||||
d.read_tup_elt(2, || deserialize(d)),
|
||||
d.read_tup_elt(3, || deserialize(d)),
|
||||
d.read_tup_elt(4, || deserialize(d))
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ___________________________________________________________________________
|
||||
// Helper routines
|
||||
//
|
||||
// In some cases, these should eventually be coded as traits.
|
||||
|
||||
pub trait SerializerHelpers {
|
||||
fn emit_from_vec<T>(&self, v: ~[T], f: fn(v: &T));
|
||||
}
|
||||
|
||||
pub impl<S: Serializer> S: SerializerHelpers {
|
||||
fn emit_from_vec<T>(&self, v: ~[T], f: fn(v: &T)) {
|
||||
do self.emit_owned_vec(v.len()) {
|
||||
for v.eachi |i, e| {
|
||||
do self.emit_vec_elt(i) {
|
||||
f(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait DeserializerHelpers {
|
||||
fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T];
|
||||
}
|
||||
|
||||
pub impl<D: Deserializer> D: DeserializerHelpers {
|
||||
fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T] {
|
||||
do self.read_owned_vec |len| {
|
||||
do vec::from_fn(len) |i| {
|
||||
self.read_vec_elt(i, || f())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub use traits::*;
|
||||
|
|
|
|||
|
|
@ -7,17 +7,34 @@ use std::serialization::{Serializable,
|
|||
use codemap::{span, filename};
|
||||
use parse::token;
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl span: Serializable {
|
||||
/* Note #1972 -- spans are serialized but not deserialized */
|
||||
fn serialize<S: Serializer>(&self, _s: &S) { }
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl span: Deserializable {
|
||||
static fn deserialize<D: Deserializer>(_d: &D) -> span {
|
||||
ast_util::dummy_sp()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl<S: Serializer> span: Serializable<S> {
|
||||
/* Note #1972 -- spans are serialized but not deserialized */
|
||||
fn serialize(&self, _s: &S) { }
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl<D: Deserializer> span: Deserializable<D> {
|
||||
static fn deserialize(_d: &D) -> span {
|
||||
ast_util::dummy_sp()
|
||||
}
|
||||
}
|
||||
|
||||
#[auto_serialize]
|
||||
#[auto_deserialize]
|
||||
type spanned<T> = {node: T, span: span};
|
||||
|
|
@ -34,6 +51,7 @@ macro_rules! interner_key (
|
|||
// implemented.
|
||||
struct ident { repr: uint }
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl ident: Serializable {
|
||||
fn serialize<S: Serializer>(&self, s: &S) {
|
||||
let intr = match unsafe {
|
||||
|
|
@ -47,6 +65,7 @@ impl ident: Serializable {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl ident: Deserializable {
|
||||
static fn deserialize<D: Deserializer>(d: &D) -> ident {
|
||||
let intr = match unsafe {
|
||||
|
|
@ -60,6 +79,36 @@ impl ident: Deserializable {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl<S: Serializer> ident: Serializable<S> {
|
||||
fn serialize(&self, s: &S) {
|
||||
let intr = match unsafe {
|
||||
task::local_data::local_data_get(interner_key!())
|
||||
} {
|
||||
None => fail ~"serialization: TLS interner not set up",
|
||||
Some(intr) => intr
|
||||
};
|
||||
|
||||
s.emit_owned_str(*(*intr).get(*self));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
impl<D: Deserializer> ident: Deserializable<D> {
|
||||
static fn deserialize(d: &D) -> ident {
|
||||
let intr = match unsafe {
|
||||
task::local_data::local_data_get(interner_key!())
|
||||
} {
|
||||
None => fail ~"deserialization: TLS interner not set up",
|
||||
Some(intr) => intr
|
||||
};
|
||||
|
||||
(*intr).intern(@d.read_owned_str())
|
||||
}
|
||||
}
|
||||
|
||||
impl ident: cmp::Eq {
|
||||
pure fn eq(other: &ident) -> bool { self.repr == other.repr }
|
||||
pure fn ne(other: &ident) -> bool { !self.eq(other) }
|
||||
|
|
|
|||
|
|
@ -13,16 +13,16 @@ For example, a type like:
|
|||
|
||||
would generate two implementations like:
|
||||
|
||||
impl Node: Serializable {
|
||||
fn serialize<S: Serializer>(s: &S) {
|
||||
impl<S: Serializer> node_id: Serializable<S> {
|
||||
fn serialize(s: &S) {
|
||||
do s.emit_struct("Node") {
|
||||
s.emit_field("id", 0, || s.emit_uint(self))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl node_id: Deserializable {
|
||||
static fn deserialize<D: Deserializer>(d: &D) -> Node {
|
||||
impl<D: Deserializer> node_id: Deserializable {
|
||||
static fn deserialize(d: &D) -> Node {
|
||||
do d.read_struct("Node") {
|
||||
Node {
|
||||
id: d.read_field(~"x", 0, || deserialize(d))
|
||||
|
|
@ -40,7 +40,10 @@ references other non-built-in types. A type definition like:
|
|||
|
||||
would yield functions like:
|
||||
|
||||
impl<T: Serializable> spanned<T>: Serializable {
|
||||
impl<
|
||||
S: Serializer,
|
||||
T: Serializable<S>
|
||||
> spanned<T>: Serializable<S> {
|
||||
fn serialize<S: Serializer>(s: &S) {
|
||||
do s.emit_rec {
|
||||
s.emit_field("node", 0, || self.node.serialize(s));
|
||||
|
|
@ -49,8 +52,11 @@ would yield functions like:
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: Deserializable> spanned<T>: Deserializable {
|
||||
static fn deserialize<D: Deserializer>(d: &D) -> spanned<T> {
|
||||
impl<
|
||||
D: Deserializer,
|
||||
T: Deserializable<D>
|
||||
> spanned<T>: Deserializable<D> {
|
||||
static fn deserialize(d: &D) -> spanned<T> {
|
||||
do d.read_rec {
|
||||
{
|
||||
node: d.read_field(~"node", 0, || deserialize(d)),
|
||||
|
|
@ -215,6 +221,25 @@ fn expand_auto_deserialize(
|
|||
}
|
||||
|
||||
priv impl ext_ctxt {
|
||||
fn bind_path(
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
path: @ast::path,
|
||||
bounds: @~[ast::ty_param_bound]
|
||||
) -> ast::ty_param {
|
||||
let bound = ast::bound_trait(@{
|
||||
id: self.next_id(),
|
||||
node: ast::ty_path(path, self.next_id()),
|
||||
span: span,
|
||||
});
|
||||
|
||||
{
|
||||
ident: ident,
|
||||
id: self.next_id(),
|
||||
bounds: @vec::append(~[bound], *bounds)
|
||||
}
|
||||
}
|
||||
|
||||
fn expr(span: span, node: ast::expr_) -> @ast::expr {
|
||||
@{id: self.next_id(), callee_id: self.next_id(),
|
||||
node: node, span: span}
|
||||
|
|
@ -332,24 +357,28 @@ fn mk_impl(
|
|||
cx: ext_ctxt,
|
||||
span: span,
|
||||
ident: ast::ident,
|
||||
ty_param: ast::ty_param,
|
||||
path: @ast::path,
|
||||
tps: ~[ast::ty_param],
|
||||
f: fn(@ast::ty) -> @ast::method
|
||||
) -> @ast::item {
|
||||
// All the type parameters need to bound to the trait.
|
||||
let trait_tps = do tps.map |tp| {
|
||||
let t_bound = ast::bound_trait(@{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_path(path, cx.next_id()),
|
||||
span: span,
|
||||
});
|
||||
let mut trait_tps = vec::append(
|
||||
~[ty_param],
|
||||
do tps.map |tp| {
|
||||
let t_bound = ast::bound_trait(@{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_path(path, cx.next_id()),
|
||||
span: span,
|
||||
});
|
||||
|
||||
{
|
||||
ident: tp.ident,
|
||||
id: cx.next_id(),
|
||||
bounds: @vec::append(~[t_bound], *tp.bounds)
|
||||
{
|
||||
ident: tp.ident,
|
||||
id: cx.next_id(),
|
||||
bounds: @vec::append(~[t_bound], *tp.bounds)
|
||||
}
|
||||
}
|
||||
};
|
||||
);
|
||||
|
||||
let opt_trait = Some(@{
|
||||
path: path,
|
||||
|
|
@ -382,20 +411,37 @@ fn mk_ser_impl(
|
|||
tps: ~[ast::ty_param],
|
||||
body: @ast::expr
|
||||
) -> @ast::item {
|
||||
// Make a path to the std::serialization::Serializable typaram.
|
||||
let ty_param = cx.bind_path(
|
||||
span,
|
||||
cx.ident_of(~"__S"),
|
||||
cx.path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization"),
|
||||
cx.ident_of(~"Serializer"),
|
||||
]
|
||||
),
|
||||
@~[]
|
||||
);
|
||||
|
||||
// Make a path to the std::serialization::Serializable trait.
|
||||
let path = cx.path(
|
||||
let path = cx.path_tps(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization"),
|
||||
cx.ident_of(~"Serializable"),
|
||||
]
|
||||
],
|
||||
~[cx.ty_path(span, ~[cx.ident_of(~"__S")], ~[])]
|
||||
);
|
||||
|
||||
mk_impl(
|
||||
cx,
|
||||
span,
|
||||
ident,
|
||||
ty_param,
|
||||
path,
|
||||
tps,
|
||||
|_ty| mk_ser_method(cx, span, cx.expr_blk(body))
|
||||
|
|
@ -409,20 +455,37 @@ fn mk_deser_impl(
|
|||
tps: ~[ast::ty_param],
|
||||
body: @ast::expr
|
||||
) -> @ast::item {
|
||||
// Make a path to the std::serialization::Deserializable typaram.
|
||||
let ty_param = cx.bind_path(
|
||||
span,
|
||||
cx.ident_of(~"__D"),
|
||||
cx.path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization"),
|
||||
cx.ident_of(~"Deserializer"),
|
||||
]
|
||||
),
|
||||
@~[]
|
||||
);
|
||||
|
||||
// Make a path to the std::serialization::Deserializable trait.
|
||||
let path = cx.path(
|
||||
let path = cx.path_tps(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization"),
|
||||
cx.ident_of(~"Deserializable"),
|
||||
]
|
||||
],
|
||||
~[cx.ty_path(span, ~[cx.ident_of(~"__D")], ~[])]
|
||||
);
|
||||
|
||||
mk_impl(
|
||||
cx,
|
||||
span,
|
||||
ident,
|
||||
ty_param,
|
||||
path,
|
||||
tps,
|
||||
|ty| mk_deser_method(cx, span, ty, cx.expr_blk(body))
|
||||
|
|
@ -434,22 +497,6 @@ fn mk_ser_method(
|
|||
span: span,
|
||||
ser_body: ast::blk
|
||||
) -> @ast::method {
|
||||
let ser_bound = cx.ty_path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization"),
|
||||
cx.ident_of(~"Serializer"),
|
||||
],
|
||||
~[]
|
||||
);
|
||||
|
||||
let ser_tps = ~[{
|
||||
ident: cx.ident_of(~"__S"),
|
||||
id: cx.next_id(),
|
||||
bounds: @~[ast::bound_trait(ser_bound)],
|
||||
}];
|
||||
|
||||
let ty_s = @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_rptr(
|
||||
|
|
@ -487,7 +534,7 @@ fn mk_ser_method(
|
|||
@{
|
||||
ident: cx.ident_of(~"serialize"),
|
||||
attrs: ~[],
|
||||
tps: ser_tps,
|
||||
tps: ~[],
|
||||
self_ty: { node: ast::sty_region(ast::m_imm), span: span },
|
||||
purity: ast::impure_fn,
|
||||
decl: ser_decl,
|
||||
|
|
@ -505,22 +552,6 @@ fn mk_deser_method(
|
|||
ty: @ast::ty,
|
||||
deser_body: ast::blk
|
||||
) -> @ast::method {
|
||||
let deser_bound = cx.ty_path(
|
||||
span,
|
||||
~[
|
||||
cx.ident_of(~"std"),
|
||||
cx.ident_of(~"serialization"),
|
||||
cx.ident_of(~"Deserializer"),
|
||||
],
|
||||
~[]
|
||||
);
|
||||
|
||||
let deser_tps = ~[{
|
||||
ident: cx.ident_of(~"__D"),
|
||||
id: cx.next_id(),
|
||||
bounds: @~[ast::bound_trait(deser_bound)],
|
||||
}];
|
||||
|
||||
let ty_d = @{
|
||||
id: cx.next_id(),
|
||||
node: ast::ty_rptr(
|
||||
|
|
@ -552,7 +583,7 @@ fn mk_deser_method(
|
|||
@{
|
||||
ident: cx.ident_of(~"deserialize"),
|
||||
attrs: ~[],
|
||||
tps: deser_tps,
|
||||
tps: ~[],
|
||||
self_ty: { node: ast::sty_static, span: span },
|
||||
purity: ast::impure_fn,
|
||||
decl: deser_decl,
|
||||
|
|
|
|||
|
|
@ -9,18 +9,22 @@ use io::Writer;
|
|||
use std::serialization::{Serializable, Deserializable, deserialize};
|
||||
use std::prettyprint;
|
||||
|
||||
fn test_ser_and_deser<A:Eq Serializable Deserializable>(
|
||||
a1: &A,
|
||||
+expected: ~str
|
||||
fn test_prettyprint<A: Serializable<prettyprint::Serializer>>(
|
||||
a: &A,
|
||||
expected: &~str
|
||||
) {
|
||||
// check the pretty printer:
|
||||
let s = do io::with_str_writer |w| {
|
||||
a1.serialize(&prettyprint::Serializer(w))
|
||||
a.serialize(&prettyprint::Serializer(w))
|
||||
};
|
||||
debug!("s == %?", s);
|
||||
assert s == expected;
|
||||
assert s == *expected;
|
||||
}
|
||||
|
||||
// check the EBML serializer:
|
||||
fn test_ebml<A:
|
||||
Eq
|
||||
Serializable<ebml::Serializer>
|
||||
Deserializable<ebml::Deserializer>
|
||||
>(a1: &A) {
|
||||
let bytes = do io::with_bytes_writer |wr| {
|
||||
let ebml_w = &ebml::Serializer(wr);
|
||||
a1.serialize(ebml_w)
|
||||
|
|
@ -140,24 +144,40 @@ enum Quark<T> {
|
|||
enum CLike { A, B, C }
|
||||
|
||||
fn main() {
|
||||
test_ser_and_deser(&Plus(@Minus(@Val(3u), @Val(10u)),
|
||||
@Plus(@Val(22u), @Val(5u))),
|
||||
~"Plus(@Minus(@Val(3u), @Val(10u)), \
|
||||
@Plus(@Val(22u), @Val(5u)))");
|
||||
let a = &Plus(@Minus(@Val(3u), @Val(10u)), @Plus(@Val(22u), @Val(5u)));
|
||||
test_prettyprint(a, &~"Plus(@Minus(@Val(3u), @Val(10u)), \
|
||||
@Plus(@Val(22u), @Val(5u)))");
|
||||
test_ebml(a);
|
||||
|
||||
test_ser_and_deser(&{lo: 0u, hi: 5u, node: 22u},
|
||||
~"{lo: 0u, hi: 5u, node: 22u}");
|
||||
let a = &{lo: 0u, hi: 5u, node: 22u};
|
||||
test_prettyprint(a, &~"{lo: 0u, hi: 5u, node: 22u}");
|
||||
test_ebml(a);
|
||||
|
||||
test_ser_and_deser(&AnEnum({v: ~[1u, 2u, 3u]}),
|
||||
~"AnEnum({v: ~[1u, 2u, 3u]})");
|
||||
let a = &AnEnum({v: ~[1u, 2u, 3u]});
|
||||
test_prettyprint(a, &~"AnEnum({v: ~[1u, 2u, 3u]})");
|
||||
test_ebml(a);
|
||||
|
||||
test_ser_and_deser(&Point {x: 3u, y: 5u}, ~"Point {x: 3u, y: 5u}");
|
||||
let a = &Point {x: 3u, y: 5u};
|
||||
test_prettyprint(a, &~"Point {x: 3u, y: 5u}");
|
||||
test_ebml(a);
|
||||
|
||||
test_ser_and_deser(&@[1u, 2u, 3u], ~"@[1u, 2u, 3u]");
|
||||
let a = &@[1u, 2u, 3u];
|
||||
test_prettyprint(a, &~"@[1u, 2u, 3u]");
|
||||
test_ebml(a);
|
||||
|
||||
test_ser_and_deser(&Top(22u), ~"Top(22u)");
|
||||
test_ser_and_deser(&Bottom(222u), ~"Bottom(222u)");
|
||||
let a = &Top(22u);
|
||||
test_prettyprint(a, &~"Top(22u)");
|
||||
test_ebml(a);
|
||||
|
||||
test_ser_and_deser(&A, ~"A");
|
||||
test_ser_and_deser(&B, ~"B");
|
||||
let a = &Bottom(222u);
|
||||
test_prettyprint(a, &~"Bottom(222u)");
|
||||
test_ebml(a);
|
||||
|
||||
let a = &A;
|
||||
test_prettyprint(a, &~"A");
|
||||
test_ebml(a);
|
||||
|
||||
let a = &B;
|
||||
test_prettyprint(a, &~"B");
|
||||
test_ebml(a);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue