OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto merge of #20514 : alexcrichton/rust/serialize-associated-type, r=aturon 

This commit moves the libserialize crate (and will force the hand of the
rustc-serialize crate) to not require the `old_orphan_check` feature gate as
well as using associated types wherever possible. Concretely, the following
changes were made:

* The error type of `Encoder` and `Decoder` is now an associated type, meaning
  that these traits have no type parameters.

* The `Encoder` and `Decoder` type parameters on the `Encodable` and `Decodable`
  traits have moved to the corresponding method of the trait. This movement
  alleviates the dependency on `old_orphan_check` but implies that
  implementations can no longer be specialized for the type of encoder/decoder
  being implemented.

Due to the trait definitions changing, this is a:

[breaking-change]
This commit is contained in:
bors 2015-01-05 14:51:03 +00:00
parent 8e83af6e87 0cb7a4062a
commit 03268bbf35
20 changed files with 5744 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

465
src/librbml/lib.rs
View File

@ -25,7 +25,7 @@
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
#![feature(macro_rules, phase, slicing_syntax, globs)]
#![feature(unboxed_closures)]
#![feature(unboxed_closures, associated_types)]
#![allow(missing_docs)]
extern crate serialize;
@ -417,6 +417,7 @@ pub mod reader {
}
}
#[cfg(stage0)]
impl<'doc> serialize::Decoder<Error> for Decoder<'doc> {
fn read_nil(&mut self) -> DecodeResult<()> { Ok(()) }
@ -671,6 +672,263 @@ pub mod reader {
ApplicationError(err.to_string())
}
}
#[cfg(not(stage0))]
impl<'doc> serialize::Decoder for Decoder<'doc> {
type Error = Error;
fn read_nil(&mut self) -> DecodeResult<()> { Ok(()) }
fn read_u64(&mut self) -> DecodeResult<u64> { Ok(doc_as_u64(try!(self.next_doc(EsU64)))) }
fn read_u32(&mut self) -> DecodeResult<u32> { Ok(doc_as_u32(try!(self.next_doc(EsU32)))) }
fn read_u16(&mut self) -> DecodeResult<u16> { Ok(doc_as_u16(try!(self.next_doc(EsU16)))) }
fn read_u8 (&mut self) -> DecodeResult<u8 > { Ok(doc_as_u8 (try!(self.next_doc(EsU8 )))) }
fn read_uint(&mut self) -> DecodeResult<uint> {
let v = doc_as_u64(try!(self.next_doc(EsUint)));
if v > (::std::uint::MAX as u64) {
Err(IntTooBig(v as uint))
} else {
Ok(v as uint)
}
}
fn read_i64(&mut self) -> DecodeResult<i64> {
Ok(doc_as_u64(try!(self.next_doc(EsI64))) as i64)
}
fn read_i32(&mut self) -> DecodeResult<i32> {
Ok(doc_as_u32(try!(self.next_doc(EsI32))) as i32)
}
fn read_i16(&mut self) -> DecodeResult<i16> {
Ok(doc_as_u16(try!(self.next_doc(EsI16))) as i16)
}
fn read_i8 (&mut self) -> DecodeResult<i8> {
Ok(doc_as_u8(try!(self.next_doc(EsI8 ))) as i8)
}
fn read_int(&mut self) -> DecodeResult<int> {
let v = doc_as_u64(try!(self.next_doc(EsInt))) as i64;
if v > (int::MAX as i64) || v < (int::MIN as i64) {
debug!("FIXME \\#6122: Removing this makes this function miscompile");
Err(IntTooBig(v as uint))
} else {
Ok(v as int)
}
}
fn read_bool(&mut self) -> DecodeResult<bool> {
Ok(doc_as_u8(try!(self.next_doc(EsBool))) != 0)
}
fn read_f64(&mut self) -> DecodeResult<f64> {
let bits = doc_as_u64(try!(self.next_doc(EsF64)));
Ok(unsafe { transmute(bits) })
}
fn read_f32(&mut self) -> DecodeResult<f32> {
let bits = doc_as_u32(try!(self.next_doc(EsF32)));
Ok(unsafe { transmute(bits) })
}
fn read_char(&mut self) -> DecodeResult<char> {
Ok(char::from_u32(doc_as_u32(try!(self.next_doc(EsChar)))).unwrap())
}
fn read_str(&mut self) -> DecodeResult<String> {
Ok(try!(self.next_doc(EsStr)).as_str())
}
// Compound types:
fn read_enum<T, F>(&mut self, name: &str, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_enum({})", name);
try!(self._check_label(name));
let doc = try!(self.next_doc(EsEnum));
let (old_parent, old_pos) = (self.parent, self.pos);
self.parent = doc;
self.pos = self.parent.start;
let result = try!(f(self));
self.parent = old_parent;
self.pos = old_pos;
Ok(result)
}
fn read_enum_variant<T, F>(&mut self, _: &[&str],
mut f: F) -> DecodeResult<T>
where F: FnMut(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
{
debug!("read_enum_variant()");
let idx = try!(self._next_uint(EsEnumVid));
debug!(" idx={}", idx);
let doc = try!(self.next_doc(EsEnumBody));
let (old_parent, old_pos) = (self.parent, self.pos);
self.parent = doc;
self.pos = self.parent.start;
let result = try!(f(self, idx));
self.parent = old_parent;
self.pos = old_pos;
Ok(result)
}
fn read_enum_variant_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_enum_variant_arg(idx={})", idx);
f(self)
}
fn read_enum_struct_variant<T, F>(&mut self, _: &[&str],
mut f: F) -> DecodeResult<T>
where F: FnMut(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
{
debug!("read_enum_struct_variant()");
let idx = try!(self._next_uint(EsEnumVid));
debug!(" idx={}", idx);
let doc = try!(self.next_doc(EsEnumBody));
let (old_parent, old_pos) = (self.parent, self.pos);
self.parent = doc;
self.pos = self.parent.start;
let result = try!(f(self, idx));
self.parent = old_parent;
self.pos = old_pos;
Ok(result)
}
fn read_enum_struct_variant_field<T, F>(&mut self,
name: &str,
idx: uint,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_enum_struct_variant_arg(name={}, idx={})", name, idx);
f(self)
}
fn read_struct<T, F>(&mut self, name: &str, _: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_struct(name={})", name);
f(self)
}
fn read_struct_field<T, F>(&mut self, name: &str, idx: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_struct_field(name={}, idx={})", name, idx);
try!(self._check_label(name));
f(self)
}
fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple()");
self.read_seq(move |d, len| {
if len == tuple_len {
f(d)
} else {
Err(Expected(format!("Expected tuple of length `{}`, \
found tuple of length `{}`", tuple_len, len)))
}
})
}
fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple_arg(idx={})", idx);
self.read_seq_elt(idx, f)
}
fn read_tuple_struct<T, F>(&mut self, name: &str, len: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple_struct(name={})", name);
self.read_tuple(len, f)
}
fn read_tuple_struct_arg<T, F>(&mut self,
idx: uint,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple_struct_arg(idx={})", idx);
self.read_tuple_arg(idx, f)
}
fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
F: FnMut(&mut Decoder<'doc>, bool) -> DecodeResult<T>,
{
debug!("read_option()");
self.read_enum("Option", move |this| {
this.read_enum_variant(&["None", "Some"], move |this, idx| {
match idx {
0 => f(this, false),
1 => f(this, true),
_ => {
Err(Expected(format!("Expected None or Some")))
}
}
})
})
}
fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
{
debug!("read_seq()");
self.push_doc(EsVec, move |d| {
let len = try!(d._next_uint(EsVecLen));
debug!(" len={}", len);
f(d, len)
})
}
fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_seq_elt(idx={})", idx);
self.push_doc(EsVecElt, f)
}
fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
{
debug!("read_map()");
self.push_doc(EsMap, move |d| {
let len = try!(d._next_uint(EsMapLen));
debug!(" len={}", len);
f(d, len)
})
}
fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_map_elt_key(idx={})", idx);
self.push_doc(EsMapKey, f)
}
fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_map_elt_val(idx={})", idx);
self.push_doc(EsMapVal, f)
}
fn error(&mut self, err: &str) -> Error {
ApplicationError(err.to_string())
}
}
}
pub mod writer {
@ -872,7 +1130,212 @@ pub mod writer {
}
}
#[cfg(stage0)]
impl<'a, W: Writer + Seek> serialize::Encoder<io::IoError> for Encoder<'a, W> {
fn emit_nil(&mut self) -> EncodeResult {
Ok(())
}
fn emit_uint(&mut self, v: uint) -> EncodeResult {
self.wr_tagged_u64(EsUint as uint, v as u64)
}
fn emit_u64(&mut self, v: u64) -> EncodeResult {
self.wr_tagged_u64(EsU64 as uint, v)
}
fn emit_u32(&mut self, v: u32) -> EncodeResult {
self.wr_tagged_u32(EsU32 as uint, v)
}
fn emit_u16(&mut self, v: u16) -> EncodeResult {
self.wr_tagged_u16(EsU16 as uint, v)
}
fn emit_u8(&mut self, v: u8) -> EncodeResult {
self.wr_tagged_u8(EsU8 as uint, v)
}
fn emit_int(&mut self, v: int) -> EncodeResult {
self.wr_tagged_i64(EsInt as uint, v as i64)
}
fn emit_i64(&mut self, v: i64) -> EncodeResult {
self.wr_tagged_i64(EsI64 as uint, v)
}
fn emit_i32(&mut self, v: i32) -> EncodeResult {
self.wr_tagged_i32(EsI32 as uint, v)
}
fn emit_i16(&mut self, v: i16) -> EncodeResult {
self.wr_tagged_i16(EsI16 as uint, v)
}
fn emit_i8(&mut self, v: i8) -> EncodeResult {
self.wr_tagged_i8(EsI8 as uint, v)
}
fn emit_bool(&mut self, v: bool) -> EncodeResult {
self.wr_tagged_u8(EsBool as uint, v as u8)
}
fn emit_f64(&mut self, v: f64) -> EncodeResult {
let bits = unsafe { mem::transmute(v) };
self.wr_tagged_u64(EsF64 as uint, bits)
}
fn emit_f32(&mut self, v: f32) -> EncodeResult {
let bits = unsafe { mem::transmute(v) };
self.wr_tagged_u32(EsF32 as uint, bits)
}
fn emit_char(&mut self, v: char) -> EncodeResult {
self.wr_tagged_u32(EsChar as uint, v as u32)
}
fn emit_str(&mut self, v: &str) -> EncodeResult {
self.wr_tagged_str(EsStr as uint, v)
}
fn emit_enum<F>(&mut self, name: &str, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self._emit_label(name));
try!(self.start_tag(EsEnum as uint));
try!(f(self));
self.end_tag()
}
fn emit_enum_variant<F>(&mut self,
_: &str,
v_id: uint,
_: uint,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self._emit_tagged_uint(EsEnumVid, v_id));
try!(self.start_tag(EsEnumBody as uint));
try!(f(self));
self.end_tag()
}
fn emit_enum_variant_arg<F>(&mut self, _: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
f(self)
}
fn emit_enum_struct_variant<F>(&mut self,
v_name: &str,
v_id: uint,
cnt: uint,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_enum_variant(v_name, v_id, cnt, f)
}
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str,
idx: uint,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_enum_variant_arg(idx, f)
}
fn emit_struct<F>(&mut self, _: &str, _len: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
f(self)
}
fn emit_struct_field<F>(&mut self, name: &str, _: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self._emit_label(name));
f(self)
}
fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_seq(len, f)
}
fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_seq_elt(idx, f)
}
fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_seq(len, f)
}
fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_seq_elt(idx, f)
}
fn emit_option<F>(&mut self, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_enum("Option", f)
}
fn emit_option_none(&mut self) -> EncodeResult {
self.emit_enum_variant("None", 0, 0, |_| Ok(()))
}
fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
self.emit_enum_variant("Some", 1, 1, f)
}
fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self.start_tag(EsVec as uint));
try!(self._emit_tagged_uint(EsVecLen, len));
try!(f(self));
self.end_tag()
}
fn emit_seq_elt<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self.start_tag(EsVecElt as uint));
try!(f(self));
self.end_tag()
}
fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self.start_tag(EsMap as uint));
try!(self._emit_tagged_uint(EsMapLen, len));
try!(f(self));
self.end_tag()
}
fn emit_map_elt_key<F>(&mut self, _idx: uint, mut f: F) -> EncodeResult where
F: FnMut(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self.start_tag(EsMapKey as uint));
try!(f(self));
self.end_tag()
}
fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
{
try!(self.start_tag(EsMapVal as uint));
try!(f(self));
self.end_tag()
}
}
#[cfg(not(stage0))]
impl<'a, W: Writer + Seek> serialize::Encoder for Encoder<'a, W> {
type Error = io::IoError;
fn emit_nil(&mut self) -> EncodeResult {
Ok(())
}

23
src/librustc/middle/astencode.rs
View File

@ -263,18 +263,27 @@ trait def_id_encoder_helpers {
fn emit_def_id(&mut self, did: ast::DefId);
}
#[cfg(stage0)]
impl<S:serialize::Encoder<E>, E> def_id_encoder_helpers for S {
fn emit_def_id(&mut self, did: ast::DefId) {
did.encode(self).ok().unwrap()
}
}
#[cfg(not(stage0))]
impl<S:serialize::Encoder> def_id_encoder_helpers for S {
fn emit_def_id(&mut self, did: ast::DefId) {
did.encode(self).ok().unwrap()
}
}
trait def_id_decoder_helpers {
fn read_def_id(&mut self, dcx: &DecodeContext) -> ast::DefId;
fn read_def_id_nodcx(&mut self,
cdata: &cstore::crate_metadata) -> ast::DefId;
}
#[cfg(stage0)]
impl<D:serialize::Decoder<E>, E> def_id_decoder_helpers for D {
fn read_def_id(&mut self, dcx: &DecodeContext) -> ast::DefId {
let did: ast::DefId = Decodable::decode(self).ok().unwrap();
@ -288,6 +297,20 @@ impl<D:serialize::Decoder<E>, E> def_id_decoder_helpers for D {
}
}
#[cfg(not(stage0))]
impl<D:serialize::Decoder> def_id_decoder_helpers for D {
fn read_def_id(&mut self, dcx: &DecodeContext) -> ast::DefId {
let did: ast::DefId = Decodable::decode(self).ok().unwrap();
did.tr(dcx)
}
fn read_def_id_nodcx(&mut self,
cdata: &cstore::crate_metadata) -> ast::DefId {
let did: ast::DefId = Decodable::decode(self).ok().unwrap();
decoder::translate_def_id(cdata, did)
}
}
// ______________________________________________________________________
// Encoding and decoding the AST itself
//

128
src/libserialize/collection_impls.rs
View File

@ -19,11 +19,9 @@ use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, Vec
use collections::enum_set::{EnumSet, CLike};
impl<
E,
S: Encoder<E>,
T: Encodable<S, E>
> Encodable<S, E> for DList<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
T: Encodable
> Encodable for DList<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)));
@ -33,8 +31,8 @@ impl<
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for DList<T> {
fn decode(d: &mut D) -> Result<DList<T>, E> {
impl<T:Decodable> Decodable for DList<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<DList<T>, D::Error> {
d.read_seq(|d, len| {
let mut list = DList::new();
for i in range(0u, len) {
@ -45,12 +43,8 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for DList<T> {
}
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E>
> Encodable<S, E> for RingBuf<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T: Encodable> Encodable for RingBuf<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)));
@ -60,8 +54,8 @@ impl<
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
fn decode(d: &mut D) -> Result<RingBuf<T>, E> {
impl<T:Decodable> Decodable for RingBuf<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<RingBuf<T>, D::Error> {
d.read_seq(|d, len| {
let mut deque: RingBuf<T> = RingBuf::new();
for i in range(0u, len) {
@ -73,12 +67,10 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
}
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + PartialEq + Ord,
V: Encodable<S, E> + PartialEq
> Encodable<S, E> for BTreeMap<K, V> {
fn encode(&self, e: &mut S) -> Result<(), E> {
K: Encodable + PartialEq + Ord,
V: Encodable + PartialEq
> Encodable for BTreeMap<K, V> {
fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
e.emit_map(self.len(), |e| {
let mut i = 0;
for (key, val) in self.iter() {
@ -92,12 +84,10 @@ impl<
}
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + PartialEq + Ord,
V: Decodable<D, E> + PartialEq
> Decodable<D, E> for BTreeMap<K, V> {
fn decode(d: &mut D) -> Result<BTreeMap<K, V>, E> {
K: Decodable + PartialEq + Ord,
V: Decodable + PartialEq
> Decodable for BTreeMap<K, V> {
fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
d.read_map(|d, len| {
let mut map = BTreeMap::new();
for i in range(0u, len) {
@ -111,11 +101,9 @@ impl<
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + PartialEq + Ord
> Encodable<S, E> for BTreeSet<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
T: Encodable + PartialEq + Ord
> Encodable for BTreeSet<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| {
let mut i = 0;
for e in self.iter() {
@ -128,11 +116,9 @@ impl<
}
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + PartialEq + Ord
> Decodable<D, E> for BTreeSet<T> {
fn decode(d: &mut D) -> Result<BTreeSet<T>, E> {
T: Decodable + PartialEq + Ord
> Decodable for BTreeSet<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
d.read_seq(|d, len| {
let mut set = BTreeSet::new();
for i in range(0u, len) {
@ -144,11 +130,9 @@ impl<
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + CLike
> Encodable<S, E> for EnumSet<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
T: Encodable + CLike
> Encodable for EnumSet<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let mut bits = 0;
for item in self.iter() {
bits |= item.to_uint();
@ -158,11 +142,9 @@ impl<
}
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + CLike
> Decodable<D, E> for EnumSet<T> {
fn decode(d: &mut D) -> Result<EnumSet<T>, E> {
T: Decodable + CLike
> Decodable for EnumSet<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<EnumSet<T>, D::Error> {
let bits = try!(d.read_uint());
let mut set = EnumSet::new();
for bit in range(0, uint::BITS) {
@ -175,14 +157,12 @@ impl<
}
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + Hash<X> + Eq,
V: Encodable<S, E>,
K: Encodable + Hash<X> + Eq,
V: Encodable,
X,
H: Hasher<X>
> Encodable<S, E> for HashMap<K, V, H> {
fn encode(&self, e: &mut S) -> Result<(), E> {
> Encodable for HashMap<K, V, H> {
fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
e.emit_map(self.len(), |e| {
let mut i = 0;
for (key, val) in self.iter() {
@ -196,14 +176,12 @@ impl<
}
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + Hash<S> + Eq,
V: Decodable<D, E>,
K: Decodable + Hash<S> + Eq,
V: Decodable,
S,
H: Hasher<S> + Default
> Decodable<D, E> for HashMap<K, V, H> {
fn decode(d: &mut D) -> Result<HashMap<K, V, H>, E> {
> Decodable for HashMap<K, V, H> {
fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, H>, D::Error> {
d.read_map(|d, len| {
let hasher = Default::default();
let mut map = HashMap::with_capacity_and_hasher(len, hasher);
@ -218,13 +196,11 @@ impl<
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + Hash<X> + Eq,
T: Encodable + Hash<X> + Eq,
X,
H: Hasher<X>
> Encodable<S, E> for HashSet<T, H> {
fn encode(&self, s: &mut S) -> Result<(), E> {
> Encodable for HashSet<T, H> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| {
let mut i = 0;
for e in self.iter() {
@ -237,13 +213,11 @@ impl<
}
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + Hash<S> + Eq,
T: Decodable + Hash<S> + Eq,
S,
H: Hasher<S> + Default
> Decodable<D, E> for HashSet<T, H> {
fn decode(d: &mut D) -> Result<HashSet<T, H>, E> {
> Decodable for HashSet<T, H> {
fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, H>, D::Error> {
d.read_seq(|d, len| {
let mut set = HashSet::with_capacity_and_hasher(len, Default::default());
for i in range(0u, len) {
@ -254,12 +228,8 @@ impl<
}
}
impl<
E,
S: Encoder<E>,
V: Encodable<S, E>
> Encodable<S, E> for VecMap<V> {
fn encode(&self, e: &mut S) -> Result<(), E> {
impl<V: Encodable> Encodable for VecMap<V> {
fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
e.emit_map(self.len(), |e| {
for (i, (key, val)) in self.iter().enumerate() {
try!(e.emit_map_elt_key(i, |e| key.encode(e)));
@ -270,12 +240,8 @@ impl<
}
}
impl<
E,
D: Decoder<E>,
V: Decodable<D, E>
> Decodable<D, E> for VecMap<V> {
fn decode(d: &mut D) -> Result<VecMap<V>, E> {
impl<V: Decodable> Decodable for VecMap<V> {
fn decode<D: Decoder>(d: &mut D) -> Result<VecMap<V>, D::Error> {
d.read_map(|d, len| {
let mut map = VecMap::new();
for i in range(0u, len) {

289
src/libserialize/collection_impls_stage0.rs Normal file
View File

@ -0,0 +1,289 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Implementations of serialization for structures found in libcollections
use std::uint;
use std::default::Default;
use std::hash::{Hash, Hasher};
use {Decodable, Encodable, Decoder, Encoder};
use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
use collections::enum_set::{EnumSet, CLike};
impl<
E,
S: Encoder<E>,
T: Encodable<S, E>
> Encodable<S, E> for DList<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)));
}
Ok(())
})
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for DList<T> {
fn decode(d: &mut D) -> Result<DList<T>, E> {
d.read_seq(|d, len| {
let mut list = DList::new();
for i in range(0u, len) {
list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
}
Ok(list)
})
}
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E>
> Encodable<S, E> for RingBuf<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)));
}
Ok(())
})
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
fn decode(d: &mut D) -> Result<RingBuf<T>, E> {
d.read_seq(|d, len| {
let mut deque: RingBuf<T> = RingBuf::new();
for i in range(0u, len) {
deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
}
Ok(deque)
})
}
}
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + PartialEq + Ord,
V: Encodable<S, E> + PartialEq
> Encodable<S, E> for BTreeMap<K, V> {
fn encode(&self, e: &mut S) -> Result<(), E> {
e.emit_map(self.len(), |e| {
let mut i = 0;
for (key, val) in self.iter() {
try!(e.emit_map_elt_key(i, |e| key.encode(e)));
try!(e.emit_map_elt_val(i, |e| val.encode(e)));
i += 1;
}
Ok(())
})
}
}
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + PartialEq + Ord,
V: Decodable<D, E> + PartialEq
> Decodable<D, E> for BTreeMap<K, V> {
fn decode(d: &mut D) -> Result<BTreeMap<K, V>, E> {
d.read_map(|d, len| {
let mut map = BTreeMap::new();
for i in range(0u, len) {
let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
map.insert(key, val);
}
Ok(map)
})
}
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + PartialEq + Ord
> Encodable<S, E> for BTreeSet<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
let mut i = 0;
for e in self.iter() {
try!(s.emit_seq_elt(i, |s| e.encode(s)));
i += 1;
}
Ok(())
})
}
}
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + PartialEq + Ord
> Decodable<D, E> for BTreeSet<T> {
fn decode(d: &mut D) -> Result<BTreeSet<T>, E> {
d.read_seq(|d, len| {
let mut set = BTreeSet::new();
for i in range(0u, len) {
set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
}
Ok(set)
})
}
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + CLike
> Encodable<S, E> for EnumSet<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
let mut bits = 0;
for item in self.iter() {
bits |= item.to_uint();
}
s.emit_uint(bits)
}
}
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + CLike
> Decodable<D, E> for EnumSet<T> {
fn decode(d: &mut D) -> Result<EnumSet<T>, E> {
let bits = try!(d.read_uint());
let mut set = EnumSet::new();
for bit in range(0, uint::BITS) {
if bits & (1 << bit) != 0 {
set.insert(CLike::from_uint(1 << bit));
}
}
Ok(set)
}
}
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + Hash<X> + Eq,
V: Encodable<S, E>,
X,
H: Hasher<X>
> Encodable<S, E> for HashMap<K, V, H> {
fn encode(&self, e: &mut S) -> Result<(), E> {
e.emit_map(self.len(), |e| {
let mut i = 0;
for (key, val) in self.iter() {
try!(e.emit_map_elt_key(i, |e| key.encode(e)));
try!(e.emit_map_elt_val(i, |e| val.encode(e)));
i += 1;
}
Ok(())
})
}
}
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + Hash<S> + Eq,
V: Decodable<D, E>,
S,
H: Hasher<S> + Default
> Decodable<D, E> for HashMap<K, V, H> {
fn decode(d: &mut D) -> Result<HashMap<K, V, H>, E> {
d.read_map(|d, len| {
let hasher = Default::default();
let mut map = HashMap::with_capacity_and_hasher(len, hasher);
for i in range(0u, len) {
let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
map.insert(key, val);
}
Ok(map)
})
}
}
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + Hash<X> + Eq,
X,
H: Hasher<X>
> Encodable<S, E> for HashSet<T, H> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
let mut i = 0;
for e in self.iter() {
try!(s.emit_seq_elt(i, |s| e.encode(s)));
i += 1;
}
Ok(())
})
}
}
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + Hash<S> + Eq,
S,
H: Hasher<S> + Default
> Decodable<D, E> for HashSet<T, H> {
fn decode(d: &mut D) -> Result<HashSet<T, H>, E> {
d.read_seq(|d, len| {
let mut set = HashSet::with_capacity_and_hasher(len, Default::default());
for i in range(0u, len) {
set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
}
Ok(set)
})
}
}
impl<
E,
S: Encoder<E>,
V: Encodable<S, E>
> Encodable<S, E> for VecMap<V> {
fn encode(&self, e: &mut S) -> Result<(), E> {
e.emit_map(self.len(), |e| {
for (i, (key, val)) in self.iter().enumerate() {
try!(e.emit_map_elt_key(i, |e| key.encode(e)));
try!(e.emit_map_elt_val(i, |e| val.encode(e)));
}
Ok(())
})
}
}
impl<
E,
D: Decoder<E>,
V: Decodable<D, E>
> Decodable<D, E> for VecMap<V> {
fn decode(d: &mut D) -> Result<VecMap<V>, E> {
d.read_map(|d, len| {
let mut map = VecMap::new();
for i in range(0u, len) {
let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
map.insert(key, val);
}
Ok(map)
})
}
}

33
src/libserialize/json.rs
View File

@ -300,7 +300,7 @@ pub fn error_str(error: ErrorCode) -> &'static str {
}
/// Shortcut function to decode a JSON `&str` into an object
pub fn decode<T: ::Decodable<Decoder, DecoderError>>(s: &str) -> DecodeResult<T> {
pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
let json = match from_str(s) {
Ok(x) => x,
Err(e) => return Err(ParseError(e))
@ -311,9 +311,7 @@ pub fn decode<T: ::Decodable<Decoder, DecoderError>>(s: &str) -> DecodeResult<T>
}
/// Shortcut function to encode a `T` into a JSON `String`
pub fn encode<T>(object: &T) -> string::String
where T: for<'a> Encodable<Encoder<'a>, fmt::Error>
{
pub fn encode<T: ::Encodable>(object: &T) -> string::String {
let mut s = String::new();
{
let mut encoder = Encoder::new(&mut s);
@ -444,7 +442,9 @@ impl<'a> Encoder<'a> {
}
}
impl<'a> ::Encoder<fmt::Error> for Encoder<'a> {
impl<'a> ::Encoder for Encoder<'a> {
type Error = fmt::Error;
fn emit_nil(&mut self) -> EncodeResult { write!(self.writer, "null") }
fn emit_uint(&mut self, v: uint) -> EncodeResult { write!(self.writer, "{}", v) }
@ -664,7 +664,9 @@ impl<'a> PrettyEncoder<'a> {
}
}
impl<'a> ::Encoder<fmt::Error> for PrettyEncoder<'a> {
impl<'a> ::Encoder for PrettyEncoder<'a> {
type Error = fmt::Error;
fn emit_nil(&mut self) -> EncodeResult { write!(self.writer, "null") }
fn emit_uint(&mut self, v: uint) -> EncodeResult { write!(self.writer, "{}", v) }
@ -909,8 +911,8 @@ impl<'a> ::Encoder<fmt::Error> for PrettyEncoder<'a> {
}
}
impl<E: ::Encoder<S>, S> Encodable<E, S> for Json {
fn encode(&self, e: &mut E) -> Result<(), S> {
impl Encodable for Json {
fn encode<E: ::Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
match *self {
Json::I64(v) => v.encode(e),
Json::U64(v) => v.encode(e),
@ -2062,7 +2064,9 @@ macro_rules! read_primitive {
}
}
impl ::Decoder<DecoderError> for Decoder {
impl ::Decoder for Decoder {
type Error = DecoderError;
fn read_nil(&mut self) -> DecodeResult<()> {
expect!(self.pop(), Null)
}
@ -2474,9 +2478,7 @@ impl<'a> fmt::Show for PrettyJson<'a> {
}
}
impl<'a, T> fmt::Show for AsJson<'a, T>
where T: for<'b> Encodable<Encoder<'b>, fmt::Error>
{
impl<'a, T: Encodable> fmt::Show for AsJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
@ -2493,9 +2495,7 @@ impl<'a, T> AsPrettyJson<'a, T> {
}
}
impl<'a, T> fmt::Show for AsPrettyJson<'a, T>
where T: for<'b> Encodable<PrettyEncoder<'b>, fmt::Error>
{
impl<'a, T: Encodable> fmt::Show for AsPrettyJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
@ -3155,8 +3155,7 @@ mod tests {
A(f64),
B(string::String)
}
fn check_err<T: Decodable<Decoder, DecoderError>>(to_parse: &'static str,
expected: DecoderError) {
fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
let res: DecodeResult<T> = match from_str(to_parse) {
Err(e) => Err(ParseError(e)),
Ok(json) => Decodable::decode(&mut Decoder::new(json))

3883
src/libserialize/json_stage0.rs Normal file
View File

File diff suppressed because it is too large Load Diff

14
src/libserialize/lib.rs
View File

@ -40,11 +40,25 @@ extern crate collections;
pub use self::serialize::{Decoder, Encoder, Decodable, Encodable,
DecoderHelpers, EncoderHelpers};
#[cfg(stage0)]
#[path = "serialize_stage0.rs"]
mod serialize;
#[cfg(not(stage0))]
mod serialize;
#[cfg(stage0)]
#[path = "collection_impls_stage0.rs"]
mod collection_impls;
#[cfg(not(stage0))]
mod collection_impls;
pub mod base64;
pub mod hex;
#[cfg(stage0)]
#[path = "json_stage0.rs"]
pub mod json;
#[cfg(not(stage0))]
pub mod json;
mod rustc_serialize {

491
src/libserialize/serialize.rs
View File

@ -19,406 +19,424 @@ use std::rc::Rc;
use std::cell::{Cell, RefCell};
use std::sync::Arc;
pub trait Encoder<E> {
pub trait Encoder {
type Error;
// Primitive types:
fn emit_nil(&mut self) -> Result<(), E>;
fn emit_uint(&mut self, v: uint) -> Result<(), E>;
fn emit_u64(&mut self, v: u64) -> Result<(), E>;
fn emit_u32(&mut self, v: u32) -> Result<(), E>;
fn emit_u16(&mut self, v: u16) -> Result<(), E>;
fn emit_u8(&mut self, v: u8) -> Result<(), E>;
fn emit_int(&mut self, v: int) -> Result<(), E>;
fn emit_i64(&mut self, v: i64) -> Result<(), E>;
fn emit_i32(&mut self, v: i32) -> Result<(), E>;
fn emit_i16(&mut self, v: i16) -> Result<(), E>;
fn emit_i8(&mut self, v: i8) -> Result<(), E>;
fn emit_bool(&mut self, v: bool) -> Result<(), E>;
fn emit_f64(&mut self, v: f64) -> Result<(), E>;
fn emit_f32(&mut self, v: f32) -> Result<(), E>;
fn emit_char(&mut self, v: char) -> Result<(), E>;
fn emit_str(&mut self, v: &str) -> Result<(), E>;
fn emit_nil(&mut self) -> Result<(), Self::Error>;
fn emit_uint(&mut self, v: uint) -> Result<(), Self::Error>;
fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
fn emit_int(&mut self, v: int) -> Result<(), Self::Error>;
fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;
fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>;
fn emit_char(&mut self, v: char) -> Result<(), Self::Error>;
fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
// Compound types:
fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_variant<F>(&mut self, v_name: &str,
v_id: uint,
len: uint,
f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
v_id: uint,
len: uint,
f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_struct_variant_field<F>(&mut self,
f_name: &str,
f_idx: uint,
f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_struct<F>(&mut self, name: &str, len: uint, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_tuple<F>(&mut self, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple<F>(&mut self, len: uint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
// Specialized types:
fn emit_option<F>(&mut self, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_option_none(&mut self) -> Result<(), E>;
fn emit_option_some<F>(&mut self, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_option_none(&mut self) -> Result<(), Self::Error>;
fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_seq<F>(&mut self, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_seq<F>(&mut self, len: uint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_map<F>(&mut self, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnMut(&mut Self) -> Result<(), E>;
fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_map<F>(&mut self, len: uint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
where F: FnMut(&mut Self) -> Result<(), Self::Error>;
fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
}
pub trait Decoder<E> {
pub trait Decoder {
type Error;
// Primitive types:
fn read_nil(&mut self) -> Result<(), E>;
fn read_uint(&mut self) -> Result<uint, E>;
fn read_u64(&mut self) -> Result<u64, E>;
fn read_u32(&mut self) -> Result<u32, E>;
fn read_u16(&mut self) -> Result<u16, E>;
fn read_u8(&mut self) -> Result<u8, E>;
fn read_int(&mut self) -> Result<int, E>;
fn read_i64(&mut self) -> Result<i64, E>;
fn read_i32(&mut self) -> Result<i32, E>;
fn read_i16(&mut self) -> Result<i16, E>;
fn read_i8(&mut self) -> Result<i8, E>;
fn read_bool(&mut self) -> Result<bool, E>;
fn read_f64(&mut self) -> Result<f64, E>;
fn read_f32(&mut self) -> Result<f32, E>;
fn read_char(&mut self) -> Result<char, E>;
fn read_str(&mut self) -> Result<String, E>;
fn read_nil(&mut self) -> Result<(), Self::Error>;
fn read_uint(&mut self) -> Result<uint, Self::Error>;
fn read_u64(&mut self) -> Result<u64, Self::Error>;
fn read_u32(&mut self) -> Result<u32, Self::Error>;
fn read_u16(&mut self) -> Result<u16, Self::Error>;
fn read_u8(&mut self) -> Result<u8, Self::Error>;
fn read_int(&mut self) -> Result<int, Self::Error>;
fn read_i64(&mut self) -> Result<i64, Self::Error>;
fn read_i32(&mut self) -> Result<i32, Self::Error>;
fn read_i16(&mut self) -> Result<i16, Self::Error>;
fn read_i8(&mut self) -> Result<i8, Self::Error>;
fn read_bool(&mut self) -> Result<bool, Self::Error>;
fn read_f64(&mut self) -> Result<f64, Self::Error>;
fn read_f32(&mut self) -> Result<f32, Self::Error>;
fn read_char(&mut self) -> Result<char, Self::Error>;
fn read_str(&mut self) -> Result<String, Self::Error>;
// Compound types:
fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
F: FnMut(&mut Self, uint) -> Result<T, E>;
fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
-> Result<T, Self::Error>
where F: FnMut(&mut Self, uint) -> Result<T, Self::Error>;
fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
F: FnMut(&mut Self, uint) -> Result<T, E>;
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
-> Result<T, Self::Error>
where F: FnMut(&mut Self, uint) -> Result<T, Self::Error>;
fn read_enum_struct_variant_field<T, F>(&mut self,
&f_name: &str,
f_idx: uint,
f: F)
-> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_struct_field<T, F>(&mut self,
f_name: &str,
f_idx: uint,
f: F)
-> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
// Specialized types:
fn read_option<T, F>(&mut self, f: F) -> Result<T, E> where
F: FnMut(&mut Self, bool) -> Result<T, E>;
fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
where F: FnMut(&mut Self, bool) -> Result<T, Self::Error>;
fn read_seq<T, F>(&mut self, f: F) -> Result<T, E> where
F: FnOnce(&mut Self, uint) -> Result<T, E>;
fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self, uint) -> Result<T, Self::Error>;
fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_map<T, F>(&mut self, f: F) -> Result<T, E> where
F: FnOnce(&mut Self, uint) -> Result<T, E>;
fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self, uint) -> Result<T, Self::Error>;
fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
// Failure
fn error(&mut self, err: &str) -> E;
fn error(&mut self, err: &str) -> Self::Error;
}
pub trait Encodable<S:Encoder<E>, E> for Sized? {
fn encode(&self, s: &mut S) -> Result<(), E>;
pub trait Encodable for Sized? {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>;
}
pub trait Decodable<D:Decoder<E>, E> {
fn decode(d: &mut D) -> Result<Self, E>;
pub trait Decodable {
fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>;
}
impl<E, S:Encoder<E>> Encodable<S, E> for uint {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for uint {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_uint(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for uint {
fn decode(d: &mut D) -> Result<uint, E> {
impl Decodable for uint {
fn decode<D: Decoder>(d: &mut D) -> Result<uint, D::Error> {
d.read_uint()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u8 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for u8 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_u8(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u8 {
fn decode(d: &mut D) -> Result<u8, E> {
impl Decodable for u8 {
fn decode<D: Decoder>(d: &mut D) -> Result<u8, D::Error> {
d.read_u8()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u16 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for u16 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_u16(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u16 {
fn decode(d: &mut D) -> Result<u16, E> {
impl Decodable for u16 {
fn decode<D: Decoder>(d: &mut D) -> Result<u16, D::Error> {
d.read_u16()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u32 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for u32 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_u32(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u32 {
fn decode(d: &mut D) -> Result<u32, E> {
impl Decodable for u32 {
fn decode<D: Decoder>(d: &mut D) -> Result<u32, D::Error> {
d.read_u32()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u64 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for u64 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_u64(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u64 {
fn decode(d: &mut D) -> Result<u64, E> {
impl Decodable for u64 {
fn decode<D: Decoder>(d: &mut D) -> Result<u64, D::Error> {
d.read_u64()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for int {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for int {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_int(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for int {
fn decode(d: &mut D) -> Result<int, E> {
impl Decodable for int {
fn decode<D: Decoder>(d: &mut D) -> Result<int, D::Error> {
d.read_int()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i8 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for i8 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_i8(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i8 {
fn decode(d: &mut D) -> Result<i8, E> {
impl Decodable for i8 {
fn decode<D: Decoder>(d: &mut D) -> Result<i8, D::Error> {
d.read_i8()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i16 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for i16 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_i16(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i16 {
fn decode(d: &mut D) -> Result<i16, E> {
impl Decodable for i16 {
fn decode<D: Decoder>(d: &mut D) -> Result<i16, D::Error> {
d.read_i16()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i32 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for i32 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_i32(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i32 {
fn decode(d: &mut D) -> Result<i32, E> {
impl Decodable for i32 {
fn decode<D: Decoder>(d: &mut D) -> Result<i32, D::Error> {
d.read_i32()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i64 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for i64 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_i64(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i64 {
fn decode(d: &mut D) -> Result<i64, E> {
impl Decodable for i64 {
fn decode<D: Decoder>(d: &mut D) -> Result<i64, D::Error> {
d.read_i64()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for str {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for str {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_str(self)
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for String {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for String {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_str(self[])
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for String {
fn decode(d: &mut D) -> Result<String, E> {
impl Decodable for String {
fn decode<D: Decoder>(d: &mut D) -> Result<String, D::Error> {
d.read_str()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for f32 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for f32 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_f32(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for f32 {
fn decode(d: &mut D) -> Result<f32, E> {
impl Decodable for f32 {
fn decode<D: Decoder>(d: &mut D) -> Result<f32, D::Error> {
d.read_f32()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for f64 {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for f64 {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_f64(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for f64 {
fn decode(d: &mut D) -> Result<f64, E> {
impl Decodable for f64 {
fn decode<D: Decoder>(d: &mut D) -> Result<f64, D::Error> {
d.read_f64()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for bool {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for bool {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_bool(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for bool {
fn decode(d: &mut D) -> Result<bool, E> {
impl Decodable for bool {
fn decode<D: Decoder>(d: &mut D) -> Result<bool, D::Error> {
d.read_bool()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for char {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for char {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_char(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for char {
fn decode(d: &mut D) -> Result<char, E> {
impl Decodable for char {
fn decode<D: Decoder>(d: &mut D) -> Result<char, D::Error> {
d.read_char()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for () {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl Encodable for () {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_nil()
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for () {
fn decode(d: &mut D) -> Result<(), E> {
impl Decodable for () {
fn decode<D: Decoder>(d: &mut D) -> Result<(), D::Error> {
d.read_nil()
}
}
impl<'a, E, S: Encoder<E>, Sized? T: Encodable<S, E>> Encodable<S, E> for &'a T {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<'a, Sized? T: Encodable> Encodable for &'a T {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s)
}
}
impl<E, S: Encoder<E>, Sized? T: Encodable<S, E>> Encodable<S, E> for Box<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<Sized? T: Encodable> Encodable for Box<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s)
}
}
impl<E, D:Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for Box<T> {
fn decode(d: &mut D) -> Result<Box<T>, E> {
impl< T: Decodable> Decodable for Box<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error> {
Ok(box try!(Decodable::decode(d)))
}
}
impl<E, D:Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for Box<[T]> {
fn decode(d: &mut D) -> Result<Box<[T]>, E> {
impl< T: Decodable> Decodable for Box<[T]> {
fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error> {
let v: Vec<T> = try!(Decodable::decode(d));
Ok(v.into_boxed_slice())
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Rc<T> {
impl<T:Encodable> Encodable for Rc<T> {
#[inline]
fn encode(&self, s: &mut S) -> Result<(), E> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s)
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Rc<T> {
impl<T:Decodable> Decodable for Rc<T> {
#[inline]
fn decode(d: &mut D) -> Result<Rc<T>, E> {
fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error> {
Ok(Rc::new(try!(Decodable::decode(d))))
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for [T] {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T:Encodable> Encodable for [T] {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)))
@ -428,8 +446,8 @@ impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for [T] {
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Vec<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T:Encodable> Encodable for Vec<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)))
@ -439,8 +457,8 @@ impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Vec<T> {
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Vec<T> {
fn decode(d: &mut D) -> Result<Vec<T>, E> {
impl<T:Decodable> Decodable for Vec<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
d.read_seq(|d, len| {
let mut v = Vec::with_capacity(len);
for i in range(0, len) {
@ -451,8 +469,8 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Vec<T> {
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Option<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T:Encodable> Encodable for Option<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_option(|s| {
match *self {
None => s.emit_option_none(),
@ -462,8 +480,8 @@ impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Option<T> {
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Option<T> {
fn decode(d: &mut D) -> Result<Option<T>, E> {
impl<T:Decodable> Decodable for Option<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error> {
d.read_option(|d, b| {
if b {
Ok(Some(try!(Decodable::decode(d))))
@ -487,22 +505,23 @@ macro_rules! count_idents {
macro_rules! tuple {
() => ();
( $($name:ident,)+ ) => (
impl<E, D:Decoder<E>,$($name:Decodable<D, E>),*> Decodable<D,E> for ($($name,)*) {
impl<$($name:Decodable),*> Decodable for ($($name,)*) {
#[allow(non_snake_case)]
fn decode(d: &mut D) -> Result<($($name,)*), E> {
fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
let len: uint = count_idents!($($name),*);
d.read_tuple(len, |d| {
let mut i = 0;
let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name,E> {
let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },
|d| -> Result<$name,D::Error> {
Decodable::decode(d)
})),)*);
return Ok(ret);
})
}
}
impl<E, S:Encoder<E>,$($name:Encodable<S, E>),*> Encodable<S, E> for ($($name,)*) {
impl<$($name:Encodable),*> Encodable for ($($name,)*) {
#[allow(non_snake_case)]
fn encode(&self, s: &mut S) -> Result<(), E> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let ($(ref $name,)*) = *self;
let mut n = 0;
$(let $name = $name; n += 1;)*
@ -519,40 +538,40 @@ macro_rules! tuple {
tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
impl<E, S: Encoder<E>> Encodable<S, E> for path::posix::Path {
fn encode(&self, e: &mut S) -> Result<(), E> {
impl Encodable for path::posix::Path {
fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
self.as_vec().encode(e)
}
}
impl<E, D: Decoder<E>> Decodable<D, E> for path::posix::Path {
fn decode(d: &mut D) -> Result<path::posix::Path, E> {
impl Decodable for path::posix::Path {
fn decode<D: Decoder>(d: &mut D) -> Result<path::posix::Path, D::Error> {
let bytes: Vec<u8> = try!(Decodable::decode(d));
Ok(path::posix::Path::new(bytes))
}
}
impl<E, S: Encoder<E>> Encodable<S, E> for path::windows::Path {
fn encode(&self, e: &mut S) -> Result<(), E> {
impl Encodable for path::windows::Path {
fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
self.as_vec().encode(e)
}
}
impl<E, D: Decoder<E>> Decodable<D, E> for path::windows::Path {
fn decode(d: &mut D) -> Result<path::windows::Path, E> {
impl Decodable for path::windows::Path {
fn decode<D: Decoder>(d: &mut D) -> Result<path::windows::Path, D::Error> {
let bytes: Vec<u8> = try!(Decodable::decode(d));
Ok(path::windows::Path::new(bytes))
}
}
impl<E, S: Encoder<E>, T: Encodable<S, E> + Copy> Encodable<S, E> for Cell<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T: Encodable + Copy> Encodable for Cell<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
self.get().encode(s)
}
}
impl<E, D: Decoder<E>, T: Decodable<D, E> + Copy> Decodable<D, E> for Cell<T> {
fn decode(d: &mut D) -> Result<Cell<T>, E> {
impl<T: Decodable + Copy> Decodable for Cell<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<Cell<T>, D::Error> {
Ok(Cell::new(try!(Decodable::decode(d))))
}
}
@ -562,26 +581,26 @@ impl<E, D: Decoder<E>, T: Decodable<D, E> + Copy> Decodable<D, E> for Cell<T> {
// `encoder.error("attempting to Encode borrowed RefCell")`
// from `encode` when `try_borrow` returns `None`.
impl<E, S: Encoder<E>, T: Encodable<S, E>> Encodable<S, E> for RefCell<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T: Encodable> Encodable for RefCell<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
self.borrow().encode(s)
}
}
impl<E, D: Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for RefCell<T> {
fn decode(d: &mut D) -> Result<RefCell<T>, E> {
impl<T: Decodable> Decodable for RefCell<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error> {
Ok(RefCell::new(try!(Decodable::decode(d))))
}
}
impl<E, S:Encoder<E>, T:Encodable<S, E>> Encodable<S, E> for Arc<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
impl<T:Encodable> Encodable for Arc<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s)
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>+Send+Sync> Decodable<D, E> for Arc<T> {
fn decode(d: &mut D) -> Result<Arc<T>, E> {
impl<T:Decodable+Send+Sync> Decodable for Arc<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error> {
Ok(Arc::new(try!(Decodable::decode(d))))
}
}
@ -589,14 +608,15 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>+Send+Sync> Decodable<D, E> for Arc<T> {
// ___________________________________________________________________________
// Helper routines
pub trait EncoderHelpers<E> {
fn emit_from_vec<T, F>(&mut self, v: &[T], f: F) -> Result<(), E> where
F: FnMut(&mut Self, &T) -> Result<(), E>;
pub trait EncoderHelpers: Encoder {
fn emit_from_vec<T, F>(&mut self, v: &[T], f: F)
-> Result<(), <Self as Encoder>::Error>
where F: FnMut(&mut Self, &T) -> Result<(), <Self as Encoder>::Error>;
}
impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), E> where
F: FnMut(&mut S, &T) -> Result<(), E>,
impl<S:Encoder> EncoderHelpers for S {
fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), S::Error> where
F: FnMut(&mut S, &T) -> Result<(), S::Error>,
{
self.emit_seq(v.len(), |this| {
for (i, e) in v.iter().enumerate() {
@ -609,14 +629,15 @@ impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
}
}
pub trait DecoderHelpers<E> {
fn read_to_vec<T, F>(&mut self, f: F) -> Result<Vec<T>, E> where
F: FnMut(&mut Self) -> Result<T, E>;
pub trait DecoderHelpers: Decoder {
fn read_to_vec<T, F>(&mut self, f: F)
-> Result<Vec<T>, <Self as Decoder>::Error> where
F: FnMut(&mut Self) -> Result<T, <Self as Decoder>::Error>;
}
impl<E, D:Decoder<E>> DecoderHelpers<E> for D {
fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, E> where F:
FnMut(&mut D) -> Result<T, E>,
impl<D: Decoder> DecoderHelpers for D {
fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, D::Error> where F:
FnMut(&mut D) -> Result<T, D::Error>,
{
self.read_seq(|this, len| {
let mut v = Vec::with_capacity(len);

629
src/libserialize/serialize_stage0.rs Normal file
View File

@ -0,0 +1,629 @@
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Support code for encoding and decoding types.
/*
Core encoding and decoding interfaces.
*/
use std::path;
use std::rc::Rc;
use std::cell::{Cell, RefCell};
use std::sync::Arc;
pub trait Encoder<E> {
// Primitive types:
fn emit_nil(&mut self) -> Result<(), E>;
fn emit_uint(&mut self, v: uint) -> Result<(), E>;
fn emit_u64(&mut self, v: u64) -> Result<(), E>;
fn emit_u32(&mut self, v: u32) -> Result<(), E>;
fn emit_u16(&mut self, v: u16) -> Result<(), E>;
fn emit_u8(&mut self, v: u8) -> Result<(), E>;
fn emit_int(&mut self, v: int) -> Result<(), E>;
fn emit_i64(&mut self, v: i64) -> Result<(), E>;
fn emit_i32(&mut self, v: i32) -> Result<(), E>;
fn emit_i16(&mut self, v: i16) -> Result<(), E>;
fn emit_i8(&mut self, v: i8) -> Result<(), E>;
fn emit_bool(&mut self, v: bool) -> Result<(), E>;
fn emit_f64(&mut self, v: f64) -> Result<(), E>;
fn emit_f32(&mut self, v: f32) -> Result<(), E>;
fn emit_char(&mut self, v: char) -> Result<(), E>;
fn emit_str(&mut self, v: &str) -> Result<(), E>;
// Compound types:
fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_variant<F>(&mut self, v_name: &str,
v_id: uint,
len: uint,
f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
v_id: uint,
len: uint,
f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_struct_variant_field<F>(&mut self,
f_name: &str,
f_idx: uint,
f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple<F>(&mut self, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
// Specialized types:
fn emit_option<F>(&mut self, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_option_none(&mut self) -> Result<(), E>;
fn emit_option_some<F>(&mut self, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_seq<F>(&mut self, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_map<F>(&mut self, len: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnMut(&mut Self) -> Result<(), E>;
fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
}
pub trait Decoder<E> {
// Primitive types:
fn read_nil(&mut self) -> Result<(), E>;
fn read_uint(&mut self) -> Result<uint, E>;
fn read_u64(&mut self) -> Result<u64, E>;
fn read_u32(&mut self) -> Result<u32, E>;
fn read_u16(&mut self) -> Result<u16, E>;
fn read_u8(&mut self) -> Result<u8, E>;
fn read_int(&mut self) -> Result<int, E>;
fn read_i64(&mut self) -> Result<i64, E>;
fn read_i32(&mut self) -> Result<i32, E>;
fn read_i16(&mut self) -> Result<i16, E>;
fn read_i8(&mut self) -> Result<i8, E>;
fn read_bool(&mut self) -> Result<bool, E>;
fn read_f64(&mut self) -> Result<f64, E>;
fn read_f32(&mut self) -> Result<f32, E>;
fn read_char(&mut self) -> Result<char, E>;
fn read_str(&mut self) -> Result<String, E>;
// Compound types:
fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
F: FnMut(&mut Self, uint) -> Result<T, E>;
fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
F: FnMut(&mut Self, uint) -> Result<T, E>;
fn read_enum_struct_variant_field<T, F>(&mut self,
&f_name: &str,
f_idx: uint,
f: F)
-> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_struct_field<T, F>(&mut self,
f_name: &str,
f_idx: uint,
f: F)
-> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
// Specialized types:
fn read_option<T, F>(&mut self, f: F) -> Result<T, E> where
F: FnMut(&mut Self, bool) -> Result<T, E>;
fn read_seq<T, F>(&mut self, f: F) -> Result<T, E> where
F: FnOnce(&mut Self, uint) -> Result<T, E>;
fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_map<T, F>(&mut self, f: F) -> Result<T, E> where
F: FnOnce(&mut Self, uint) -> Result<T, E>;
fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
// Failure
fn error(&mut self, err: &str) -> E;
}
pub trait Encodable<S:Encoder<E>, E> for Sized? {
fn encode(&self, s: &mut S) -> Result<(), E>;
}
pub trait Decodable<D:Decoder<E>, E> {
fn decode(d: &mut D) -> Result<Self, E>;
}
impl<E, S:Encoder<E>> Encodable<S, E> for uint {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_uint(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for uint {
fn decode(d: &mut D) -> Result<uint, E> {
d.read_uint()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u8 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_u8(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u8 {
fn decode(d: &mut D) -> Result<u8, E> {
d.read_u8()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u16 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_u16(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u16 {
fn decode(d: &mut D) -> Result<u16, E> {
d.read_u16()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u32 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_u32(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u32 {
fn decode(d: &mut D) -> Result<u32, E> {
d.read_u32()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for u64 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_u64(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for u64 {
fn decode(d: &mut D) -> Result<u64, E> {
d.read_u64()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for int {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_int(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for int {
fn decode(d: &mut D) -> Result<int, E> {
d.read_int()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i8 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_i8(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i8 {
fn decode(d: &mut D) -> Result<i8, E> {
d.read_i8()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i16 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_i16(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i16 {
fn decode(d: &mut D) -> Result<i16, E> {
d.read_i16()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i32 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_i32(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i32 {
fn decode(d: &mut D) -> Result<i32, E> {
d.read_i32()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for i64 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_i64(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for i64 {
fn decode(d: &mut D) -> Result<i64, E> {
d.read_i64()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for str {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_str(self)
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for String {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_str(self[])
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for String {
fn decode(d: &mut D) -> Result<String, E> {
d.read_str()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for f32 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_f32(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for f32 {
fn decode(d: &mut D) -> Result<f32, E> {
d.read_f32()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for f64 {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_f64(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for f64 {
fn decode(d: &mut D) -> Result<f64, E> {
d.read_f64()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for bool {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_bool(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for bool {
fn decode(d: &mut D) -> Result<bool, E> {
d.read_bool()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for char {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_char(*self)
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for char {
fn decode(d: &mut D) -> Result<char, E> {
d.read_char()
}
}
impl<E, S:Encoder<E>> Encodable<S, E> for () {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_nil()
}
}
impl<E, D:Decoder<E>> Decodable<D, E> for () {
fn decode(d: &mut D) -> Result<(), E> {
d.read_nil()
}
}
impl<'a, E, S: Encoder<E>, Sized? T: Encodable<S, E>> Encodable<S, E> for &'a T {
fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s)
}
}
impl<E, S: Encoder<E>, Sized? T: Encodable<S, E>> Encodable<S, E> for Box<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s)
}
}
impl<E, D:Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for Box<T> {
fn decode(d: &mut D) -> Result<Box<T>, E> {
Ok(box try!(Decodable::decode(d)))
}
}
impl<E, D:Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for Box<[T]> {
fn decode(d: &mut D) -> Result<Box<[T]>, E> {
let v: Vec<T> = try!(Decodable::decode(d));
Ok(v.into_boxed_slice())
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Rc<T> {
#[inline]
fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s)
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Rc<T> {
#[inline]
fn decode(d: &mut D) -> Result<Rc<T>, E> {
Ok(Rc::new(try!(Decodable::decode(d))))
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for [T] {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)))
}
Ok(())
})
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Vec<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
for (i, e) in self.iter().enumerate() {
try!(s.emit_seq_elt(i, |s| e.encode(s)))
}
Ok(())
})
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Vec<T> {
fn decode(d: &mut D) -> Result<Vec<T>, E> {
d.read_seq(|d, len| {
let mut v = Vec::with_capacity(len);
for i in range(0, len) {
v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
}
Ok(v)
})
}
}
impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Option<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_option(|s| {
match *self {
None => s.emit_option_none(),
Some(ref v) => s.emit_option_some(|s| v.encode(s)),
}
})
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Option<T> {
fn decode(d: &mut D) -> Result<Option<T>, E> {
d.read_option(|d, b| {
if b {
Ok(Some(try!(Decodable::decode(d))))
} else {
Ok(None)
}
})
}
}
macro_rules! peel {
($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
}
/// Evaluates to the number of identifiers passed to it, for example: `count_idents!(a, b, c) == 3
macro_rules! count_idents {
() => { 0u };
($_i:ident $(, $rest:ident)*) => { 1 + count_idents!($($rest),*) }
}
macro_rules! tuple {
() => ();
( $($name:ident,)+ ) => (
impl<E, D:Decoder<E>,$($name:Decodable<D, E>),*> Decodable<D,E> for ($($name,)*) {
#[allow(non_snake_case)]
fn decode(d: &mut D) -> Result<($($name,)*), E> {
let len: uint = count_idents!($($name),*);
d.read_tuple(len, |d| {
let mut i = 0;
let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name,E> {
Decodable::decode(d)
})),)*);
return Ok(ret);
})
}
}
impl<E, S:Encoder<E>,$($name:Encodable<S, E>),*> Encodable<S, E> for ($($name,)*) {
#[allow(non_snake_case)]
fn encode(&self, s: &mut S) -> Result<(), E> {
let ($(ref $name,)*) = *self;
let mut n = 0;
$(let $name = $name; n += 1;)*
s.emit_tuple(n, |s| {
let mut i = 0;
$(try!(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s)));)*
Ok(())
})
}
}
peel! { $($name,)* }
)
}
tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
impl<E, S: Encoder<E>> Encodable<S, E> for path::posix::Path {
fn encode(&self, e: &mut S) -> Result<(), E> {
self.as_vec().encode(e)
}
}
impl<E, D: Decoder<E>> Decodable<D, E> for path::posix::Path {
fn decode(d: &mut D) -> Result<path::posix::Path, E> {
let bytes: Vec<u8> = try!(Decodable::decode(d));
Ok(path::posix::Path::new(bytes))
}
}
impl<E, S: Encoder<E>> Encodable<S, E> for path::windows::Path {
fn encode(&self, e: &mut S) -> Result<(), E> {
self.as_vec().encode(e)
}
}
impl<E, D: Decoder<E>> Decodable<D, E> for path::windows::Path {
fn decode(d: &mut D) -> Result<path::windows::Path, E> {
let bytes: Vec<u8> = try!(Decodable::decode(d));
Ok(path::windows::Path::new(bytes))
}
}
impl<E, S: Encoder<E>, T: Encodable<S, E> + Copy> Encodable<S, E> for Cell<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
self.get().encode(s)
}
}
impl<E, D: Decoder<E>, T: Decodable<D, E> + Copy> Decodable<D, E> for Cell<T> {
fn decode(d: &mut D) -> Result<Cell<T>, E> {
Ok(Cell::new(try!(Decodable::decode(d))))
}
}
// FIXME: #15036
// Should use `try_borrow`, returning a
// `encoder.error("attempting to Encode borrowed RefCell")`
// from `encode` when `try_borrow` returns `None`.
impl<E, S: Encoder<E>, T: Encodable<S, E>> Encodable<S, E> for RefCell<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
self.borrow().encode(s)
}
}
impl<E, D: Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for RefCell<T> {
fn decode(d: &mut D) -> Result<RefCell<T>, E> {
Ok(RefCell::new(try!(Decodable::decode(d))))
}
}
impl<E, S:Encoder<E>, T:Encodable<S, E>> Encodable<S, E> for Arc<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s)
}
}
impl<E, D:Decoder<E>,T:Decodable<D, E>+Send+Sync> Decodable<D, E> for Arc<T> {
fn decode(d: &mut D) -> Result<Arc<T>, E> {
Ok(Arc::new(try!(Decodable::decode(d))))
}
}
// ___________________________________________________________________________
// Helper routines
pub trait EncoderHelpers<E> {
fn emit_from_vec<T, F>(&mut self, v: &[T], f: F) -> Result<(), E> where
F: FnMut(&mut Self, &T) -> Result<(), E>;
}
impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), E> where
F: FnMut(&mut S, &T) -> Result<(), E>,
{
self.emit_seq(v.len(), |this| {
for (i, e) in v.iter().enumerate() {
try!(this.emit_seq_elt(i, |this| {
f(this, e)
}));
}
Ok(())
})
}
}
pub trait DecoderHelpers<E> {
fn read_to_vec<T, F>(&mut self, f: F) -> Result<Vec<T>, E> where
F: FnMut(&mut Self) -> Result<T, E>;
}
impl<E, D:Decoder<E>> DecoderHelpers<E> for D {
fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, E> where F:
FnMut(&mut D) -> Result<T, E>,
{
self.read_seq(|this, len| {
let mut v = Vec::with_capacity(len);
for i in range(0, len) {
v.push(try!(this.read_seq_elt(i, |this| f(this))));
}
Ok(v)
})
}
}

40
src/libsyntax/ast.rs
View File

@ -182,18 +182,34 @@ impl Name {
/// A mark represents a unique id associated with a macro expansion
pub type Mrk = u32;
#[cfg(stage0)]
impl<S: Encoder<E>, E> Encodable<S, E> for Ident {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_str(token::get_ident(*self).get())
}
}
#[cfg(not(stage0))]
impl Encodable for Ident {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_str(token::get_ident(*self).get())
}
}
#[cfg(stage0)]
impl<D: Decoder<E>, E> Decodable<D, E> for Ident {
fn decode(d: &mut D) -> Result<Ident, E> {
Ok(str_to_ident(try!(d.read_str())[]))
}
}
#[cfg(not(stage0))]
impl Decodable for Ident {
fn decode<D: Decoder>(d: &mut D) -> Result<Ident, D::Error> {
Ok(str_to_ident(try!(d.read_str())[]))
}
}
/// Function name (not all functions have names)
pub type FnIdent = Option<Ident>;
@ -1686,27 +1702,7 @@ mod test {
// are ASTs encodable?
#[test]
fn check_asts_encodable() {
use std::io;
let e = Crate {
module: Mod {
inner: Span {
lo: BytePos(11),
hi: BytePos(19),
expn_id: NO_EXPANSION,
},
view_items: Vec::new(),
items: Vec::new(),
},
attrs: Vec::new(),
config: Vec::new(),
span: Span {
lo: BytePos(10),
hi: BytePos(20),
expn_id: NO_EXPANSION,
},
exported_macros: Vec::new(),
};
// doesn't matter which encoder we use....
let _f = &e as &serialize::Encodable<json::Encoder, fmt::Error>;
fn assert_encodable<T: serialize::Encodable>() {}
assert_encodable::<Crate>();
}
}

17
src/libsyntax/codemap.rs
View File

@ -120,6 +120,7 @@ impl PartialEq for Span {
impl Eq for Span {}
#[cfg(stage0)]
impl<S:Encoder<E>, E> Encodable<S, E> for Span {
/* Note #1972 -- spans are encoded but not decoded */
fn encode(&self, s: &mut S) -> Result<(), E> {
@ -127,12 +128,28 @@ impl<S:Encoder<E>, E> Encodable<S, E> for Span {
}
}
#[cfg(not(stage0))]
impl Encodable for Span {
/* Note #1972 -- spans are encoded but not decoded */
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_nil()
}
}
#[cfg(stage0)]
impl<D:Decoder<E>, E> Decodable<D, E> for Span {
fn decode(_d: &mut D) -> Result<Span, E> {
Ok(DUMMY_SP)
}
}
#[cfg(not(stage0))]
impl Decodable for Span {
fn decode<D: Decoder>(_d: &mut D) -> Result<Span, D::Error> {
Ok(DUMMY_SP)
}
}
pub fn spanned<T>(lo: BytePos, hi: BytePos, t: T) -> Spanned<T> {
respan(mk_sp(lo, hi), t)
}

30
src/libsyntax/ext/deriving/decodable.rs
View File

@ -52,27 +52,29 @@ fn expand_deriving_decodable_imp<F>(cx: &mut ExtCtxt,
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
path: Path::new_(vec!(krate, "Decodable"), None,
vec!(box Literal(Path::new_local("__D")),
box Literal(Path::new_local("__E"))), true),
path: Path::new_(vec!(krate, "Decodable"), None, vec!(), true),
additional_bounds: Vec::new(),
generics: LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec!(("__D", vec!(Path::new_(
vec!(krate, "Decoder"), None,
vec!(box Literal(Path::new_local("__E"))), true))),
("__E", vec!()))
},
generics: LifetimeBounds::empty(),
methods: vec!(
MethodDef {
name: "decode",
generics: LifetimeBounds::empty(),
generics: LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec!(("__D", vec!(Path::new_(
vec!(krate, "Decoder"), None,
vec!(), true))))
},
explicit_self: None,
args: vec!(Ptr(box Literal(Path::new_local("__D")),
Borrowed(None, MutMutable))),
ret_ty: Literal(Path::new_(vec!("std", "result", "Result"), None,
vec!(box Self,
box Literal(Path::new_local("__E"))), true)),
ret_ty: Literal(Path::new_(
vec!("std", "result", "Result"),
None,
vec!(box Self, box Literal(Path::new_(
vec!["__D", "Error"], None, vec![], false
))),
true
)),
attributes: Vec::new(),
combine_substructure: combine_substructure(|a, b, c| {
decodable_substructure(a, b, c, krate)

32
src/libsyntax/ext/deriving/encodable.rs
View File

@ -128,29 +128,29 @@ fn expand_deriving_encodable_imp<F>(cx: &mut ExtCtxt,
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
path: Path::new_(vec!(krate, "Encodable"), None,
vec!(box Literal(Path::new_local("__S")),
box Literal(Path::new_local("__E"))), true),
path: Path::new_(vec!(krate, "Encodable"), None, vec!(), true),
additional_bounds: Vec::new(),
generics: LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec!(("__S", vec!(Path::new_(
vec!(krate, "Encoder"), None,
vec!(box Literal(Path::new_local("__E"))), true))),
("__E", vec!()))
},
generics: LifetimeBounds::empty(),
methods: vec!(
MethodDef {
name: "encode",
generics: LifetimeBounds::empty(),
generics: LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec!(("__S", vec!(Path::new_(
vec!(krate, "Encoder"), None,
vec!(), true))))
},
explicit_self: borrowed_explicit_self(),
args: vec!(Ptr(box Literal(Path::new_local("__S")),
Borrowed(None, MutMutable))),
ret_ty: Literal(Path::new_(vec!("std", "result", "Result"),
None,
vec!(box Tuple(Vec::new()),
box Literal(Path::new_local("__E"))),
true)),
ret_ty: Literal(Path::new_(
vec!("std", "result", "Result"),
None,
vec!(box Tuple(Vec::new()), box Literal(Path::new_(
vec!["__S", "Error"], None, vec![], false
))),
true
)),
attributes: Vec::new(),
combine_substructure: combine_substructure(|a, b, c| {
encodable_substructure(a, b, c)

19
src/libsyntax/owned_slice.rs
View File

@ -82,12 +82,21 @@ impl<T> FromIterator<T> for OwnedSlice<T> {
}
}
#[cfg(stage0)]
impl<S: Encoder<E>, T: Encodable<S, E>, E> Encodable<S, E> for OwnedSlice<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
self.as_slice().encode(s)
}
}
#[cfg(not(stage0))]
impl<T: Encodable> Encodable for OwnedSlice<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
self.as_slice().encode(s)
}
}
#[cfg(stage0)]
impl<D: Decoder<E>, T: Decodable<D, E>, E> Decodable<D, E> for OwnedSlice<T> {
fn decode(d: &mut D) -> Result<OwnedSlice<T>, E> {
Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
@ -96,3 +105,13 @@ impl<D: Decoder<E>, T: Decodable<D, E>, E> Decodable<D, E> for OwnedSlice<T> {
}))
}
}
#[cfg(not(stage0))]
impl<T: Decodable> Decodable for OwnedSlice<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<OwnedSlice<T>, D::Error> {
Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
Ok(t) => t,
Err(e) => return Err(e)
}))
}
}

17
src/libsyntax/parse/token.rs
View File

@ -653,6 +653,7 @@ impl<'a> PartialEq<InternedString > for &'a str {
}
}
#[cfg(stage0)]
impl<D:Decoder<E>, E> Decodable<D, E> for InternedString {
fn decode(d: &mut D) -> Result<InternedString, E> {
Ok(get_name(get_ident_interner().intern(
@ -660,12 +661,28 @@ impl<D:Decoder<E>, E> Decodable<D, E> for InternedString {
}
}
#[cfg(not(stage0))]
impl Decodable for InternedString {
fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {
Ok(get_name(get_ident_interner().intern(
try!(d.read_str())[])))
}
}
#[cfg(stage0)]
impl<S:Encoder<E>, E> Encodable<S, E> for InternedString {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_str(self.string[])
}
}
#[cfg(not(stage0))]
impl Encodable for InternedString {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_str(self.string[])
}
}
/// Returns the string contents of a name, using the task-local interner.
#[inline]
pub fn get_name(name: ast::Name) -> InternedString {

16
src/libsyntax/ptr.rs
View File

@ -111,14 +111,30 @@ impl<S, T: Hash<S>> Hash<S> for P<T> {
}
}
#[cfg(stage0)]
impl<E, D: Decoder<E>, T: 'static + Decodable<D, E>> Decodable<D, E> for P<T> {
fn decode(d: &mut D) -> Result<P<T>, E> {
Decodable::decode(d).map(P)
}
}
#[cfg(not(stage0))]
impl<T: 'static + Decodable> Decodable for P<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<P<T>, D::Error> {
Decodable::decode(d).map(P)
}
}
#[cfg(stage0)]
impl<E, S: Encoder<E>, T: Encodable<S, E>> Encodable<S, E> for P<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s)
}
}
#[cfg(not(stage0))]
impl<T: Encodable> Encodable for P<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s)
}
}

30
src/test/compile-fail/variance-trait-matching-2.rs
View File

@ -1,30 +0,0 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
extern crate serialize;
use std::fmt;
use serialize::{Encodable, Encoder};
pub fn buffer_encode<'a,
T:Encodable<serialize::json::Encoder<'a>,fmt::Error>>(
to_encode_object: &T)
-> String {
let mut m = String::new();
{
let mut encoder =
serialize::json::Encoder::new(&mut m);
//~^ ERROR `m` does not live long enough
to_encode_object.encode(&mut encoder);
}
m
}
fn main() {}

10
src/test/run-pass/issue-11881.rs
View File

@ -40,16 +40,10 @@ enum WireProtocol {
// ...
}
fn encode_json<
T: for<'a> Encodable<json::Encoder<'a>,
fmt::Error>>(val: &T,
wr: &mut SeekableMemWriter) {
fn encode_json<T: Encodable>(val: &T, wr: &mut SeekableMemWriter) {
write!(wr, "{}", json::as_json(val));
}
fn encode_rbml<'a,
T: Encodable<writer::Encoder<'a, SeekableMemWriter>,
io::IoError>>(val: &T,
wr: &'a mut SeekableMemWriter) {
fn encode_rbml<T: Encodable>(val: &T, wr: &mut SeekableMemWriter) {
let mut encoder = writer::Encoder::new(wr);
val.encode(&mut encoder);
}

2
src/test/run-pass/issue-15924.rs
View File

@ -21,7 +21,7 @@ struct Foo<T> {
}
#[unsafe_destructor]
impl<T: for<'a> Encodable<json::Encoder<'a>, fmt::Error>> Drop for Foo<T> {
impl<T: Encodable> Drop for Foo<T> {
fn drop(&mut self) {
json::encode(&self.v);
}

2
src/test/run-pass/issue-4016.rs
View File

@ -13,7 +13,7 @@ extern crate serialize;
use serialize::{json, Decodable};
trait JD : Decodable<json::Decoder, json::DecoderError> { }
trait JD : Decodable {}
fn exec<T: JD>() {
let doc = json::from_str("").unwrap();