pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-24 15:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Serialization should have an error type

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-10-11 11:05:24 -07:00
parent 7b669ac4c0
commit 1c3a42ea56
2 changed files with 144 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde2/src/json/ser.rs
+40 -42
View File
@@ -1,6 +1,6 @@
use std::io;
use std::num::{FPNaN, FPInfinite};
use std::f64;
use std::io::{IoError, MemWriter};
use std::num::{FPNaN, FPInfinite};
use ser;
@@ -26,14 +26,14 @@ impl<W: Writer> Serializer<W> {
}
}
impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
impl<W: Writer> ser::Visitor<(), IoError> for Serializer<W> {
#[inline]
fn visit_null(&mut self) -> io::IoResult<()> {
fn visit_null(&mut self) -> Result<(), IoError> {
self.writer.write_str("null")
}
#[inline]
fn visit_bool(&mut self, value: bool) -> io::IoResult<()> {
fn visit_bool(&mut self, value: bool) -> Result<(), IoError> {
if value {
self.writer.write_str("true")
} else {
@@ -42,80 +42,79 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
}
#[inline]
fn visit_int(&mut self, value: int) -> io::IoResult<()> {
fn visit_int(&mut self, value: int) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i8(&mut self, value: i8) -> io::IoResult<()> {
fn visit_i8(&mut self, value: i8) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i16(&mut self, value: i16) -> io::IoResult<()> {
fn visit_i16(&mut self, value: i16) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i32(&mut self, value: i32) -> io::IoResult<()> {
fn visit_i32(&mut self, value: i32) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i64(&mut self, value: i64) -> io::IoResult<()> {
fn visit_i64(&mut self, value: i64) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_uint(&mut self, value: uint) -> io::IoResult<()> {
fn visit_uint(&mut self, value: uint) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u8(&mut self, value: u8) -> io::IoResult<()> {
fn visit_u8(&mut self, value: u8) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u16(&mut self, value: u16) -> io::IoResult<()> {
fn visit_u16(&mut self, value: u16) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u32(&mut self, value: u32) -> io::IoResult<()> {
fn visit_u32(&mut self, value: u32) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u64(&mut self, value: u64) -> io::IoResult<()> {
fn visit_u64(&mut self, value: u64) -> Result<(), IoError> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_f64(&mut self, value: f64) -> io::IoResult<()> {
fn visit_f64(&mut self, value: f64) -> Result<(), IoError> {
fmt_f64_or_null(&mut self.writer, value)
}
#[inline]
fn visit_char(&mut self, v: char) -> io::IoResult<()> {
fn visit_char(&mut self, v: char) -> Result<(), IoError> {
escape_char(&mut self.writer, v)
}
#[inline]
fn visit_str(&mut self, value: &str) -> io::IoResult<()> {
fn visit_str(&mut self, value: &str) -> Result<(), IoError> {
escape_str(&mut self.writer, value)
}
#[inline]
fn visit_seq<
V: ser::SeqVisitor<Serializer<W>, io::IoResult<()>>
>(&mut self, mut visitor: V) -> io::IoResult<()> {
V: ser::SeqVisitor<Serializer<W>, (), IoError>
>(&mut self, mut visitor: V) -> Result<(), IoError> {
try!(self.writer.write_str("["));
loop {
match visitor.visit(self) {
Some(Ok(())) => { }
Some(Err(err)) => { return Err(err); }
match try!(visitor.visit(self)) {
Some(()) => { }
None => { break; }
}
}
@@ -125,8 +124,8 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
#[inline]
fn visit_seq_elt<
T: ser::Serialize<Serializer<W>, io::IoResult<()>>
>(&mut self, first: bool, value: T) -> io::IoResult<()> {
T: ser::Serialize<Serializer<W>, (), IoError>
>(&mut self, first: bool, value: T) -> Result<(), IoError> {
if !first {
try!(self.writer.write_str(","));
}
@@ -136,14 +135,13 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
#[inline]
fn visit_map<
V: ser::MapVisitor<Serializer<W>, io::IoResult<()>>
>(&mut self, mut visitor: V) -> io::IoResult<()> {
V: ser::MapVisitor<Serializer<W>, (), IoError>
>(&mut self, mut visitor: V) -> Result<(), IoError> {
try!(self.writer.write_str("{{"));
loop {
match visitor.visit(self) {
Some(Ok(())) => { }
Some(Err(err)) => { return Err(err); }
match try!(visitor.visit(self)) {
Some(()) => { }
None => { break; }
}
}
@@ -153,9 +151,9 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
#[inline]
fn visit_map_elt<
K: ser::Serialize<Serializer<W>, io::IoResult<()>>,
V: ser::Serialize<Serializer<W>, io::IoResult<()>>
>(&mut self, first: bool, key: K, value: V) -> io::IoResult<()> {
K: ser::Serialize<Serializer<W>, (), IoError>,
V: ser::Serialize<Serializer<W>, (), IoError>
>(&mut self, first: bool, key: K, value: V) -> Result<(), IoError> {
if !first {
try!(self.writer.write_str(","));
}
@@ -167,7 +165,7 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
}
#[inline]
pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> Result<(), IoError> {
try!(wr.write_str("\""));
let mut start = 0;
@@ -201,18 +199,18 @@ pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
}
#[inline]
pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> io::IoResult<()> {
pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> Result<(), IoError> {
escape_bytes(wr, value.as_bytes())
}
#[inline]
pub fn escape_char<W: Writer>(wr: &mut W, value: char) -> io::IoResult<()> {
pub fn escape_char<W: Writer>(wr: &mut W, value: char) -> Result<(), IoError> {
let mut buf = [0, .. 4];
value.encode_utf8(buf);
escape_bytes(wr, buf)
}
fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> io::IoResult<()> {
fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> Result<(), IoError> {
match value.classify() {
FPNaN | FPInfinite => wr.write_str("null"),
_ => wr.write_str(f64::to_str_digits(value, 6).as_slice()),
@@ -221,9 +219,9 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> io::IoResult<()> {
#[inline]
pub fn to_vec<
T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
>(value: &T) -> io::IoResult<Vec<u8>> {
let writer = io::MemWriter::with_capacity(1024);
T: ser::Serialize<Serializer<MemWriter>, (), IoError>
>(value: &T) -> Result<Vec<u8>, IoError> {
let writer = MemWriter::with_capacity(1024);
let mut state = Serializer::new(writer);
try!(value.serialize(&mut state));
Ok(state.unwrap().unwrap())
@@ -231,8 +229,8 @@ pub fn to_vec<
#[inline]
pub fn to_string<
T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
>(value: &T) -> io::IoResult<Result<String, Vec<u8>>> {
T: ser::Serialize<Serializer<MemWriter>, (), IoError>
>(value: &T) -> Result<Result<String, Vec<u8>>, IoError> {
let vec = try!(to_vec(value));
Ok(String::from_utf8(vec))
}