berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rustfmt

This commit is contained in:
Ty Overby 2015-04-29 23:26:58 -07:00
parent a6a43bd55a
commit d87e7dad2d
4 changed files with 306 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/lib.rs
View File

@ -110,7 +110,10 @@ pub fn decode<T: Decodable>(b: &[u8]) -> DecodingResult<T> {
/// If this returns an `EncodingError` (other than SizeLimit), assume that the /// If this returns an `EncodingError` (other than SizeLimit), assume that the
/// writer is in an invalid state, as writing could bail out in the middle of /// writer is in an invalid state, as writing could bail out in the middle of
/// encoding. /// encoding.
pub fn encode_into<T: Encodable, W: Write>(t: &T, w: &mut W, size_limit: SizeLimit) -> EncodingResult<()> { pub fn encode_into<T: Encodable, W: Write>(t: &T,
w: &mut W,
size_limit: SizeLimit)
-> EncodingResult<()> {
try!(match size_limit { try!(match size_limit {
SizeLimit::Infinite => Ok(()), SizeLimit::Infinite => Ok(()),
SizeLimit::Bounded(x) => { SizeLimit::Bounded(x) => {
@ -131,8 +134,7 @@ pub fn encode_into<T: Encodable, W: Write>(t: &T, w: &mut W, size_limit: SizeLim
/// If this returns an `DecodingError`, assume that the buffer that you passed /// If this returns an `DecodingError`, assume that the buffer that you passed
/// in is in an invalid state, as the error could be returned during any point /// in is in an invalid state, as the error could be returned during any point
/// in the reading. /// in the reading.
pub fn decode_from<R: Read, T: Decodable>(r: &mut R, size_limit: SizeLimit) -> pub fn decode_from<R: Read, T: Decodable>(r: &mut R, size_limit: SizeLimit) -> DecodingResult<T> {
DecodingResult<T> {
Decodable::decode(&mut reader::DecoderReader::new(r, size_limit)) Decodable::decode(&mut reader::DecoderReader::new(r, size_limit))
} }

89
src/reader.rs
View File

@ -246,12 +246,14 @@ impl<'a, R: Read> Decoder for DecoderReader<'a, R> {
})), })),
} }
} }
fn read_enum<T, F>(&mut self, _: &str, f: F) -> DecodingResult<T> where fn read_enum<T, F>(&mut self, _: &str, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> DecodingResult<T> where fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> DecodingResult<T>
F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> { where F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
{
let id = try!(self.read_u32()); let id = try!(self.read_u32());
let id = id as usize; let id = id as usize;
if id >= names.len() { if id >= names.len() {
@ -263,52 +265,58 @@ impl<'a, R: Read> Decoder for DecoderReader<'a, R> {
f(self, id) f(self, id)
} }
} }
fn read_enum_variant_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where fn read_enum_variant_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodingResult<T> where fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodingResult<T>
F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> { where F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
{
self.read_enum_variant(names, f) self.read_enum_variant(names, f)
} }
fn read_enum_struct_variant_field<T, F>(&mut self, fn read_enum_struct_variant_field<T, F>(&mut self,
_: &str, _: &str,
f_idx: usize, f_idx: usize,
f: F) f: F)
-> DecodingResult<T> where -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
self.read_enum_variant_arg(f_idx, f) self.read_enum_variant_arg(f_idx, f)
} }
fn read_struct<T, F>(&mut self, _: &str, _: usize, f: F) -> DecodingResult<T> where fn read_struct<T, F>(&mut self, _: &str, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_struct_field<T, F>(&mut self, fn read_struct_field<T, F>(&mut self, _: &str, _: usize, f: F) -> DecodingResult<T>
_: &str, where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
_: usize, {
f: F)
-> DecodingResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
f(self) f(self)
} }
fn read_tuple<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where fn read_tuple<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_tuple_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where fn read_tuple_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_tuple_struct<T, F>(&mut self, _: &str, len: usize, f: F) -> DecodingResult<T> where fn read_tuple_struct<T, F>(&mut self, _: &str, len: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
self.read_tuple(len, f) self.read_tuple(len, f)
} }
fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> DecodingResult<T> where fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
self.read_tuple_arg(a_idx, f) self.read_tuple_arg(a_idx, f)
} }
fn read_option<T, F>(&mut self, mut f: F) -> DecodingResult<T> where fn read_option<T, F>(&mut self, mut f: F) -> DecodingResult<T>
F: FnMut(&mut DecoderReader<'a, R>, bool) -> DecodingResult<T> { where F: FnMut(&mut DecoderReader<'a, R>, bool) -> DecodingResult<T>
{
let x = try!(self.read_u8()); let x = try!(self.read_u8());
match x { match x {
1 => f(self, true), 1 => f(self, true),
@ -319,26 +327,31 @@ impl<'a, R: Read> Decoder for DecoderReader<'a, R> {
})), })),
} }
} }
fn read_seq<T, F>(&mut self, f: F) -> DecodingResult<T> where fn read_seq<T, F>(&mut self, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
{
let len = try!(self.read_usize()); let len = try!(self.read_usize());
f(self, len) f(self, len)
} }
fn read_seq_elt<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where fn read_seq_elt<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_map<T, F>(&mut self, f: F) -> DecodingResult<T> where fn read_map<T, F>(&mut self, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
{
let len = try!(self.read_usize()); let len = try!(self.read_usize());
f(self, len) f(self, len)
} }
fn read_map_elt_key<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where fn read_map_elt_key<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn read_map_elt_val<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where fn read_map_elt_val<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> { where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
{
f(self) f(self)
} }
fn error(&mut self, err: &str) -> DecodingError { fn error(&mut self, err: &str) -> DecodingError {

24
src/test.rs
View File

@ -2,31 +2,21 @@ use std::fmt::Debug;
use std::collections::HashMap; use std::collections::HashMap;
use std::ops::Deref; use std::ops::Deref;
use rustc_serialize::{ use rustc_serialize::{Encoder, Decoder, Encodable, Decodable};
Encoder,
Decoder,
Encodable,
Decodable
};
use super::{ use super::{encode, decode, decode_from, encoded_size, DecodingError,
encode, DecodingResult, RefBox};
decode,
decode_from,
encoded_size,
DecodingError,
DecodingResult,
RefBox,
};
use super::SizeLimit::{Infinite, Bounded}; use super::SizeLimit::{Infinite, Bounded};
fn the_same<V>(element: V) fn the_same<V>(element: V)
where V: Encodable + Decodable + PartialEq + Debug + 'static { where V: Encodable+Decodable+PartialEq+Debug+'static
{
// Make sure that the bahavior isize correct when wrapping with a RefBox. // Make sure that the bahavior isize correct when wrapping with a RefBox.
fn ref_box_correct<V>(v: &V) -> bool fn ref_box_correct<V>(v: &V) -> bool
where V: Encodable + Decodable + PartialEq + Debug + 'static { where V: Encodable+Decodable+PartialEq+Debug+'static
{
let rf = RefBox::new(v); let rf = RefBox::new(v);
let encoded = encode(&rf, Infinite).unwrap(); let encoded = encode(&rf, Infinite).unwrap();

216
src/writer.rs
View File

@ -105,7 +105,9 @@ impl SizeChecker {
impl<'a, W: Write> Encoder for EncoderWriter<'a, W> { impl<'a, W: Write> Encoder for EncoderWriter<'a, W> {
type Error = EncodingError; type Error = EncodingError;
fn emit_nil(&mut self) -> EncodingResult<()> { Ok(()) } fn emit_nil(&mut self) -> EncodingResult<()> {
Ok(())
}
fn emit_usize(&mut self, v: usize) -> EncodingResult<()> { fn emit_usize(&mut self, v: usize) -> EncodingResult<()> {
self.emit_u64(v as u64) self.emit_u64(v as u64)
} }
@ -160,15 +162,14 @@ impl<'a, W: Write> Encoder for EncoderWriter<'a, W> {
try!(self.emit_usize(v.len())); try!(self.emit_usize(v.len()));
self.writer.write_all(v.as_bytes()).map_err(EncodingError::IoError) self.writer.write_all(v.as_bytes()).map_err(EncodingError::IoError)
} }
fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()> where fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_enum_variant<F>(&mut self, _: &str, fn emit_enum_variant<F>(&mut self, _: &str, v_id: usize, _: usize, f: F) -> EncodingResult<()>
v_id: usize, where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
_: usize, {
f: F) -> EncodingResult<()> where
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
let max_u32: u32 = ::std::u32::MAX; let max_u32: u32 = ::std::u32::MAX;
if v_id > (max_u32 as usize) { if v_id > (max_u32 as usize) {
panic!("Variant tag doesn't fit in a u32") panic!("Variant tag doesn't fit in a u32")
@ -176,80 +177,95 @@ impl<'a, W: Write> Encoder for EncoderWriter<'a, W> {
try!(self.emit_u32(v_id as u32)); try!(self.emit_u32(v_id as u32));
f(self) f(self)
} }
fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_enum_struct_variant<F>(&mut self, _: &str, fn emit_enum_struct_variant<F>(&mut self,
_: usize,
_: usize,
f: F) -> EncodingResult<()> where
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
f(self)
}
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str, _: &str,
_: usize, _: usize,
f: F) -> EncodingResult<()> where _: usize,
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { f: F)
-> EncodingResult<()>
where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where fn emit_enum_struct_variant_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()> where fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self)
}
fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()>
where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
self.emit_tuple(len, f) self.emit_tuple(len, f)
} }
fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()> where fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
self.emit_tuple_arg(f_idx, f) self.emit_tuple_arg(f_idx, f)
} }
fn emit_option<F>(&mut self, f: F) -> EncodingResult<()> where fn emit_option<F>(&mut self, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_option_none(&mut self) -> EncodingResult<()> { fn emit_option_none(&mut self) -> EncodingResult<()> {
self.writer.write_u8(0).map_err(wrap_io) self.writer.write_u8(0).map_err(wrap_io)
} }
fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()> where fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
try!(self.writer.write_u8(1).map_err(wrap_io)); try!(self.writer.write_u8(1).map_err(wrap_io));
f(self) f(self)
} }
fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
try!(self.emit_usize(len)); try!(self.emit_usize(len));
f(self) f(self)
} }
fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
try!(self.emit_usize(len)); try!(self.emit_usize(len));
f(self) f(self)
} }
fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> { where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
{
f(self) f(self)
} }
@ -258,7 +274,9 @@ impl<'a, W: Write> Encoder for EncoderWriter<'a, W> {
impl Encoder for SizeChecker { impl Encoder for SizeChecker {
type Error = EncodingError; type Error = EncodingError;
fn emit_nil(&mut self) -> EncodingResult<()> { Ok(()) } fn emit_nil(&mut self) -> EncodingResult<()> {
Ok(())
}
fn emit_usize(&mut self, v: usize) -> EncodingResult<()> { fn emit_usize(&mut self, v: usize) -> EncodingResult<()> {
self.add_value(v as u64) self.add_value(v as u64)
} }
@ -305,92 +323,106 @@ impl Encoder for SizeChecker {
try!(self.add_value(0 as u64)); try!(self.add_value(0 as u64));
self.add_raw(v.len()) self.add_raw(v.len())
} }
fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()> where fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_enum_variant<F>(&mut self, _: &str, fn emit_enum_variant<F>(&mut self, _: &str, v_id: usize, _: usize, f: F) -> EncodingResult<()>
v_id: usize, where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
_: usize, {
f: F) -> EncodingResult<()> where
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
try!(self.add_value(v_id as u32)); try!(self.add_value(v_id as u32));
f(self) f(self)
} }
fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_enum_struct_variant<F>(&mut self, _: &str, fn emit_enum_struct_variant<F>(&mut self,
_: usize,
_: usize,
f: F) -> EncodingResult<()> where
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
f(self)
}
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str, _: &str,
_: usize, _: usize,
f: F) -> EncodingResult<()> where _: usize,
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { f: F)
-> EncodingResult<()>
where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where fn emit_enum_struct_variant_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()> where fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self)
}
fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()>
where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
self.emit_tuple(len, f) self.emit_tuple(len, f)
} }
fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()> where fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
self.emit_tuple_arg(f_idx, f) self.emit_tuple_arg(f_idx, f)
} }
fn emit_option<F>(&mut self, f: F) -> EncodingResult<()> where fn emit_option<F>(&mut self, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_option_none(&mut self) -> EncodingResult<()> { fn emit_option_none(&mut self) -> EncodingResult<()> {
self.add_value(0 as u8) self.add_value(0 as u8)
} }
fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()> where fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
try!(self.add_value(1 as u8)); try!(self.add_value(1 as u8));
f(self) f(self)
} }
fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
try!(self.emit_usize(len)); try!(self.emit_usize(len));
f(self) f(self)
} }
fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
try!(self.emit_usize(len)); try!(self.emit_usize(len));
f(self) f(self)
} }
fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }
fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
F: FnOnce(&mut SizeChecker) -> EncodingResult<()> { where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
{
f(self) f(self)
} }