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

Follow rust std: int, uint were renamed to isize, usize

Browse Source
This commit is contained in:
Thomas Bahn
2015-02-06 14:14:35 +01:00
parent 3b5d71fbb5
commit 361acd37d0
15 changed files with 443 additions and 443 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/de.rs
+59 -59
View File
@@ -22,12 +22,12 @@ use std::sync::Arc;
pub enum Token {
Null,
Bool(bool),
Int(int),
Isize(isize),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
Uint(uint),
Usize(usize),
U8(u8),
U16(u16),
U32(u32),
@@ -39,11 +39,11 @@ pub enum Token {
String(String),
Option(bool),
TupleStart(uint),
StructStart(&'static str, uint),
EnumStart(&'static str, &'static str, uint),
SeqStart(uint),
MapStart(uint),
TupleStart(usize),
StructStart(&'static str, usize),
EnumStart(&'static str, &'static str, usize),
SeqStart(usize),
MapStart(usize),
End,
}
@@ -53,12 +53,12 @@ impl Token {
match *self {
Token::Null => TokenKind::NullKind,
Token::Bool(_) => TokenKind::BoolKind,
Token::Int(_) => TokenKind::IntKind,
Token::Isize(_) => TokenKind::IsizeKind,
Token::I8(_) => TokenKind::I8Kind,
Token::I16(_) => TokenKind::I16Kind,
Token::I32(_) => TokenKind::I32Kind,
Token::I64(_) => TokenKind::I64Kind,
Token::Uint(_) => TokenKind::UintKind,
Token::Usize(_) => TokenKind::UsizeKind,
Token::U8(_) => TokenKind::U8Kind,
Token::U16(_) => TokenKind::U16Kind,
Token::U32(_) => TokenKind::U32Kind,
@@ -83,12 +83,12 @@ impl Token {
pub enum TokenKind {
NullKind,
BoolKind,
IntKind,
IsizeKind,
I8Kind,
I16Kind,
I32Kind,
I64Kind,
UintKind,
UsizeKind,
U8Kind,
U16Kind,
U32Kind,
@@ -110,12 +110,12 @@ pub enum TokenKind {
}
static PRIMITIVE_TOKEN_KINDS: &'static [TokenKind] = &[
TokenKind::IntKind,
TokenKind::IsizeKind,
TokenKind::I8Kind,
TokenKind::I16Kind,
TokenKind::I32Kind,
TokenKind::I64Kind,
TokenKind::UintKind,
TokenKind::UsizeKind,
TokenKind::U8Kind,
TokenKind::U16Kind,
TokenKind::U32Kind,
@@ -143,12 +143,12 @@ impl ::std::fmt::Show for TokenKind {
match *self {
TokenKind::NullKind => "Null".fmt(f),
TokenKind::BoolKind => "Bool".fmt(f),
TokenKind::IntKind => "Int".fmt(f),
TokenKind::IsizeKind => "Isize".fmt(f),
TokenKind::I8Kind => "I8".fmt(f),
TokenKind::I16Kind => "I16".fmt(f),
TokenKind::I32Kind => "I32".fmt(f),
TokenKind::I64Kind => "I64".fmt(f),
TokenKind::UintKind => "Uint".fmt(f),
TokenKind::UsizeKind => "Usize".fmt(f),
TokenKind::U8Kind => "U8".fmt(f),
TokenKind::U16Kind => "U16".fmt(f),
TokenKind::U32Kind => "U32".fmt(f),
@@ -253,12 +253,12 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
#[inline]
fn expect_num<T: num::NumCast>(&mut self, token: Token) -> Result<T, E> {
match token {
Token::Int(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::Isize(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::I8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::I16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::I32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::I64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::Uint(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::Usize(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::U8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::U16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
Token::U32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
@@ -272,12 +272,12 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
#[inline]
fn expect_from_primitive<T: FromPrimitive>(&mut self, token: Token) -> Result<T, E> {
match token {
Token::Int(x) => to_result!(num::from_int(x), self.conversion_error(token)),
Token::Isize(x) => to_result!(num::from_int(x), self.conversion_error(token)),
Token::I8(x) => to_result!(num::from_i8(x), self.conversion_error(token)),
Token::I16(x) => to_result!(num::from_i16(x), self.conversion_error(token)),
Token::I32(x) => to_result!(num::from_i32(x), self.conversion_error(token)),
Token::I64(x) => to_result!(num::from_i64(x), self.conversion_error(token)),
Token::Uint(x) => to_result!(num::from_uint(x), self.conversion_error(token)),
Token::Usize(x) => to_result!(num::from_uint(x), self.conversion_error(token)),
Token::U8(x) => to_result!(num::from_u8(x), self.conversion_error(token)),
Token::U16(x) => to_result!(num::from_u16(x), self.conversion_error(token)),
Token::U32(x) => to_result!(num::from_u32(x), self.conversion_error(token)),
@@ -345,7 +345,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
}
#[inline]
fn expect_tuple_start(&mut self, token: Token) -> Result<uint, E> {
fn expect_tuple_start(&mut self, token: Token) -> Result<usize, E> {
match token {
Token::TupleStart(len) => Ok(len),
Token::SeqStart(len) => Ok(len),
@@ -401,7 +401,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
#[inline]
fn expect_struct_field_or_end(&mut self,
fields: &'static [&'static str]
) -> Result<option::Option<option::Option<uint>>, E> {
) -> Result<option::Option<option::Option<usize>>, E> {
match try!(self.expect_token()) {
Token::End => {
Ok(None)
@@ -439,7 +439,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
}
#[inline]
fn expect_enum_start(&mut self, token: Token, name: &str, variants: &[&str]) -> Result<uint, E> {
fn expect_enum_start(&mut self, token: Token, name: &str, variants: &[&str]) -> Result<usize, E> {
match token {
Token::EnumStart(n, v, _) => {
if name == n {
@@ -481,7 +481,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
}
#[inline]
fn expect_seq_start(&mut self, token: Token) -> Result<uint, E> {
fn expect_seq_start(&mut self, token: Token) -> Result<usize, E> {
match token {
Token::TupleStart(len) => Ok(len),
Token::SeqStart(len) => Ok(len),
@@ -533,7 +533,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
}
#[inline]
fn expect_map_start(&mut self, token: Token) -> Result<uint, E> {
fn expect_map_start(&mut self, token: Token) -> Result<usize, E> {
match token {
Token::MapStart(len) => Ok(len),
_ => {
@@ -590,7 +590,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
struct SeqDeserializer<'a, D: 'a, E: 'a, T> {
d: &'a mut D,
len: uint,
len: usize,
err: &'a mut Option<E>,
}
@@ -617,7 +617,7 @@ impl<
}
#[inline]
fn size_hint(&self) -> (uint, option::Option<uint>) {
fn size_hint(&self) -> (usize, option::Option<usize>) {
(self.len, Some(self.len))
}
}
@@ -626,7 +626,7 @@ impl<
struct MapDeserializer<'a, D:'a, E: 'a, K, V> {
d: &'a mut D,
len: uint,
len: usize,
err: &'a mut option::Option<E>,
}
@@ -651,7 +651,7 @@ impl<
}
#[inline]
fn size_hint(&self) -> (uint, option::Option<uint>) {
fn size_hint(&self) -> (usize, option::Option<usize>) {
(self.len, Some(self.len))
}
}
@@ -682,12 +682,12 @@ macro_rules! impl_deserialize {
}
impl_deserialize!(bool, expect_bool);
impl_deserialize!(int, expect_num);
impl_deserialize!(isize, expect_num);
impl_deserialize!(i8, expect_num);
impl_deserialize!(i16, expect_num);
impl_deserialize!(i32, expect_num);
impl_deserialize!(i64, expect_num);
impl_deserialize!(uint, expect_num);
impl_deserialize!(usize, expect_num);
impl_deserialize!(u8, expect_num);
impl_deserialize!(u16, expect_num);
impl_deserialize!(u32, expect_num);
@@ -1094,7 +1094,7 @@ mod tests {
#[derive(Clone, PartialEq, Show, RustcDecodable)]
struct Inner {
a: (),
b: uint,
b: usize,
c: BTreeMap<string::String, option::Option<char>>,
}
@@ -1169,7 +1169,7 @@ mod tests {
#[derive(Clone, PartialEq, Show, RustcDecodable)]
enum Animal {
Dog,
Frog(string::String, int)
Frog(string::String, isize)
}
impl<D: Deserializer<E>, E> Deserialize<D, E> for Animal {
@@ -1271,12 +1271,12 @@ mod tests {
vec!(Token::Null) => (), (),
vec!(Token::Bool(true)) => true, bool,
vec!(Token::Bool(false)) => false, bool,
vec!(Token::Int(5)) => 5, int,
vec!(Token::Isize(5)) => 5, isize,
vec!(Token::I8(5)) => 5, i8,
vec!(Token::I16(5)) => 5, i16,
vec!(Token::I32(5)) => 5, i32,
vec!(Token::I64(5)) => 5, i64,
vec!(Token::Uint(5)) => 5, uint,
vec!(Token::Usize(5)) => 5, usize,
vec!(Token::U8(5)) => 5, u8,
vec!(Token::U16(5)) => 5, u16,
vec!(Token::U32(5)) => 5, u32,
@@ -1296,11 +1296,11 @@ mod tests {
vec!(
Token::TupleStart(2),
Token::Int(5),
Token::Isize(5),
Token::Str("a"),
Token::End,
) => (5, "a"), (int, &'static str),
) => (5, "a"), (isize, &'static str),
vec!(
Token::TupleStart(3),
@@ -1310,21 +1310,21 @@ mod tests {
Token::End,
Token::TupleStart(2),
Token::Int(5),
Token::Isize(5),
Token::Str("a"),
Token::End,
Token::End,
) => ((), (), (5, "a")), ((), (), (int, &'static str))
) => ((), (), (5, "a")), ((), (), (isize, &'static str))
]);
test_value!(test_options, [
vec!(Token::Option(false)) => None, option::Option<int>,
vec!(Token::Option(false)) => None, option::Option<isize>,
vec!(
Token::Option(true),
Token::Int(5),
) => Some(5), option::Option<int>
Token::Isize(5),
) => Some(5), option::Option<isize>
]);
test_value!(test_structs, [
@@ -1345,7 +1345,7 @@ mod tests {
Token::Null,
Token::Str("b"),
Token::Uint(5),
Token::Usize(5),
Token::Str("c"),
Token::MapStart(1),
@@ -1377,7 +1377,7 @@ mod tests {
vec!(
Token::EnumStart("Animal", "Frog", 2),
Token::String("Henry".to_string()),
Token::Int(349),
Token::Isize(349),
Token::End,
) => Animal::Frog("Henry".to_string(), 349), Animal
]);
@@ -1386,57 +1386,57 @@ mod tests {
vec!(
Token::SeqStart(0),
Token::End,
) => vec!(), Vec<int>,
) => vec!(), Vec<isize>,
vec!(
Token::SeqStart(3),
Token::Int(5),
Token::Isize(5),
Token::Int(6),
Token::Isize(6),
Token::Int(7),
Token::Isize(7),
Token::End,
) => vec!(5, 6, 7), Vec<int>,
) => vec!(5, 6, 7), Vec<isize>,
vec!(
Token::SeqStart(3),
Token::SeqStart(1),
Token::Int(1),
Token::Isize(1),
Token::End,
Token::SeqStart(2),
Token::Int(2),
Token::Isize(2),
Token::Int(3),
Token::Isize(3),
Token::End,
Token::SeqStart(3),
Token::Int(4),
Token::Isize(4),
Token::Int(5),
Token::Isize(5),
Token::Int(6),
Token::Isize(6),
Token::End,
Token::End,
) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)), Vec<Vec<int>>
) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)), Vec<Vec<isize>>
]);
test_value!(test_treemaps, [
vec!(
Token::MapStart(0),
Token::End,
) => treemap!(), BTreeMap<int, string::String>,
) => treemap!(), BTreeMap<isize, string::String>,
vec!(
Token::MapStart(2),
Token::Int(5),
Token::Isize(5),
Token::String("a".to_string()),
Token::Int(6),
Token::Isize(6),
Token::String("b".to_string()),
Token::End,
) => treemap!(5i => "a".to_string(), 6i => "b".to_string()), BTreeMap<int, string::
) => treemap!(5is => "a".to_string(), 6is => "b".to_string()), BTreeMap<isize, string::
String>
]);
}
src/json/builder.rs
+8 -8
View File
@@ -93,22 +93,22 @@ mod tests {
assert_eq!(value, Value::Array(Vec::new()));
let value = ArrayBuilder::new()
.push(1i)
.push(2i)
.push(3i)
.push(1is)
.push(2is)
.push(3is)
.unwrap();
assert_eq!(value, Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
let value = ArrayBuilder::new()
.push_array(|bld| bld.push(1i).push(2i).push(3i))
.push_array(|bld| bld.push(1is).push(2is).push(3is))
.unwrap();
assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
let value = ArrayBuilder::new()
.push_object(|bld|
bld
.insert("a".to_string(), 1i)
.insert("b".to_string(), 2i))
.insert("a".to_string(), 1is)
.insert("b".to_string(), 2is))
.unwrap();
let mut map = BTreeMap::new();
@@ -123,8 +123,8 @@ mod tests {
assert_eq!(value, Value::Object(BTreeMap::new()));
let value = ObjectBuilder::new()
.insert("a".to_string(), 1i)
.insert("b".to_string(), 2i)
.insert("a".to_string(), 1is)
.insert("b".to_string(), 2is)
.unwrap();
let mut map = BTreeMap::new();
src/json/de.rs
+11 -11
View File
@@ -30,8 +30,8 @@ enum State {
pub struct Parser<Iter> {
rdr: Iter,
ch: Option<u8>,
line: uint,
col: uint,
line: usize,
col: usize,
// A state machine is kept to make it possible to interupt and resume parsing.
state_stack: Vec<State>,
buf: Vec<u8>,
@@ -261,7 +261,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
match self.ch_or_null() {
c @ b'0' ... b'9' => {
dec /= 10.0;
res += (((c as int) - (b'0' as int)) as f64) * dec;
res += (((c as isize) - (b'0' as isize)) as f64) * dec;
self.bump();
}
_ => break,
@@ -275,7 +275,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
self.bump();
let mut exp = 0u;
let mut exp = 0us;
let mut neg_exp = false;
if self.ch_is(b'+') {
@@ -294,7 +294,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
match self.ch_or_null() {
c @ b'0' ... b'9' => {
exp *= 10;
exp += (c as uint) - (b'0' as uint);
exp += (c as usize) - (b'0' as usize);
self.bump();
}
@@ -314,9 +314,9 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
#[inline]
fn decode_hex_escape(&mut self) -> Result<u16, Error> {
let mut i = 0u;
let mut i = 0us;
let mut n = 0u16;
while i < 4u && !self.eof() {
while i < 4us && !self.eof() {
self.bump();
n = match self.ch_or_null() {
c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
@@ -329,11 +329,11 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
_ => { return Err(self.error(ErrorCode::InvalidEscape)); }
};
i += 1u;
i += 1us;
}
// Error out if we didn't parse 4 digits.
if i != 4u {
if i != 4us {
return Err(self.error(ErrorCode::InvalidEscape));
}
@@ -562,7 +562,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer<Error> for Parser<Iter> {
fn expect_enum_start(&mut self,
token: de::Token,
_name: &str,
variants: &[&str]) -> Result<uint, Error> {
variants: &[&str]) -> Result<usize, Error> {
match token {
de::Token::MapStart(_) => { }
_ => { return Err(self.error(ErrorCode::ExpectedEnumMapStart)); }
@@ -615,7 +615,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer<Error> for Parser<Iter> {
#[inline]
fn expect_struct_field_or_end(&mut self,
fields: &'static [&'static str]
) -> Result<Option<Option<uint>>, Error> {
) -> Result<Option<Option<usize>>, Error> {
let result = match self.state_stack.pop() {
Some(State::ObjectStart) => {
try!(self.parse_object_start())
src/json/error.rs
+1 -1
View File
@@ -81,7 +81,7 @@ impl fmt::Show for ErrorCode {
#[derive(Clone, PartialEq, Show)]
pub enum Error {
/// msg, line, col
SyntaxError(ErrorCode, uint, uint),
SyntaxError(ErrorCode, usize, usize),
IoError(io::IoError),
ExpectedError(String, String),
MissingFieldError(String),
src/json/mod.rs
+41 -41
View File
@@ -362,7 +362,7 @@ mod tests {
#[derive_deserialize]
enum Animal {
Dog,
Frog(String, Vec<int>)
Frog(String, Vec<isize>)
}
impl ToJson for Animal {
@@ -391,7 +391,7 @@ mod tests {
#[derive_deserialize]
struct Inner {
a: (),
b: uint,
b: usize,
c: Vec<string::String>,
}
@@ -464,9 +464,9 @@ mod tests {
#[test]
fn test_write_i64() {
let tests = &[
(3i, "3"),
(-2i, "-2"),
(-1234i, "-1234"),
(3is, "3"),
(-2is, "-2"),
(-1234is, "-1234"),
];
test_encode_ok(tests);
test_pretty_encode_ok(tests);
@@ -643,14 +643,14 @@ mod tests {
fn test_write_tuple() {
test_encode_ok(&[
(
(5i,),
(5is,),
"[5]",
),
]);
test_pretty_encode_ok(&[
(
(5i,),
(5is,),
concat!(
"[\n",
" 5\n",
@@ -661,14 +661,14 @@ mod tests {
test_encode_ok(&[
(
(5i, (6i, "abc")),
(5is, (6is, "abc")),
"[5,[6,\"abc\"]]",
),
]);
test_pretty_encode_ok(&[
(
(5i, (6i, "abc")),
(5is, (6is, "abc")),
concat!(
"[\n",
" 5,\n",
@@ -964,19 +964,19 @@ mod tests {
]);
test_parse_ok(&[
("[3,1]", vec!(3i, 1)),
("[ 3 , 1 ]", vec!(3i, 1)),
("[3,1]", vec!(3is, 1)),
("[ 3 , 1 ]", vec!(3is, 1)),
]);
test_parse_ok(&[
("[[3], [1, 2]]", vec!(vec!(3i), vec!(1, 2))),
("[[3], [1, 2]]", vec!(vec!(3is), vec!(1, 2))),
]);
let v: () = from_str("[]").unwrap();
assert_eq!(v, ());
test_parse_ok(&[
("[1, 2, 3]", (1u, 2u, 3u)),
("[1, 2, 3]", (1us, 2us, 3us)),
]);
}
@@ -992,17 +992,17 @@ mod tests {
]);
test_json_deserialize_ok(&[
vec!(3i, 1),
vec!(3is, 1),
]);
test_json_deserialize_ok(&[
vec!(vec!(3i), vec!(1, 2)),
vec!(vec!(3is), vec!(1, 2)),
]);
}
#[test]
fn test_parse_object() {
test_parse_err::<BTreeMap<string::String, int>>(&[
test_parse_err::<BTreeMap<string::String, isize>>(&[
("{", SyntaxError(EOFWhileParsingString, 1, 2)),
("{ ", SyntaxError(EOFWhileParsingString, 1, 3)),
("{1", SyntaxError(KeyMustBeAString, 1, 2)),
@@ -1022,26 +1022,26 @@ mod tests {
("{ }", treemap!()),
(
"{\"a\":3}",
treemap!("a".to_string() => 3i)
treemap!("a".to_string() => 3is)
),
(
"{ \"a\" : 3 }",
treemap!("a".to_string() => 3i)
treemap!("a".to_string() => 3is)
),
(
"{\"a\":3,\"b\":4}",
treemap!("a".to_string() => 3i, "b".to_string() => 4)
treemap!("a".to_string() => 3is, "b".to_string() => 4)
),
(
"{ \"a\" : 3 , \"b\" : 4 }",
treemap!("a".to_string() => 3i, "b".to_string() => 4),
treemap!("a".to_string() => 3is, "b".to_string() => 4),
),
]);
test_parse_ok(&[
(
"{\"a\": {\"b\": 3, \"c\": 4}}",
treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4i)),
treemap!("a".to_string() => treemap!("b".to_string() => 3is, "c".to_string() => 4is)),
),
]);
}
@@ -1050,12 +1050,12 @@ mod tests {
fn test_json_deserialize_object() {
test_json_deserialize_ok(&[
treemap!(),
treemap!("a".to_string() => 3i),
treemap!("a".to_string() => 3i, "b".to_string() => 4),
treemap!("a".to_string() => 3is),
treemap!("a".to_string() => 3is, "b".to_string() => 4),
]);
test_json_deserialize_ok(&[
treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4)),
treemap!("a".to_string() => treemap!("b".to_string() => 3is, "c".to_string() => 4)),
]);
}
@@ -1107,7 +1107,7 @@ mod tests {
#[derive_serialize]
#[derive_deserialize]
struct Foo {
x: Option<int>,
x: Option<isize>,
}
let value: Foo = from_str("{}").unwrap();
@@ -1172,7 +1172,7 @@ mod tests {
#[test]
fn test_multiline_errors() {
test_parse_err::<BTreeMap<string::String, string::String>>(&[
("{\n \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)),
("{\n \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3us, 8us)),
]);
}
@@ -1371,7 +1371,7 @@ mod tests {
fn test_encode_hashmap_with_numeric_key() {
use std::str::from_utf8;
use std::collections::HashMap;
let mut hm: HashMap<uint, bool> = HashMap::new();
let mut hm: HashMap<usize, bool> = HashMap::new();
hm.insert(1, true);
let mut mem_buf = MemWriter::new();
{
@@ -1386,7 +1386,7 @@ mod tests {
fn test_prettyencode_hashmap_with_numeric_key() {
use std::str::from_utf8;
use std::collections::HashMap;
let mut hm: HashMap<uint, bool> = HashMap::new();
let mut hm: HashMap<usize, bool> = HashMap::new();
hm.insert(1, true);
let mut mem_buf = MemWriter::new();
{
@@ -1402,7 +1402,7 @@ mod tests {
fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
use std::collections::HashMap;
let json_str = "{\"1\":true}";
let map: HashMap<uint, bool> = from_str(json_str).unwrap();
let map: HashMap<usize, bool> = from_str(json_str).unwrap();
let mut m = HashMap::new();
m.insert(1u, true);
assert_eq!(map, m);
@@ -1715,7 +1715,7 @@ mod bench {
})
}
fn json_str(count: uint) -> string::String {
fn json_str(count: usize) -> string::String {
let mut src = "[".to_string();
for _ in range(0, count) {
src.push_str(r#"{"a":true,"b":null,"c":3.1415,"d":"Hello world","e":[1,2,3]},"#);
@@ -1724,7 +1724,7 @@ mod bench {
src
}
fn pretty_json_str(count: uint) -> string::String {
fn pretty_json_str(count: usize) -> string::String {
let mut src = "[\n".to_string();
for _ in range(0, count) {
src.push_str(
@@ -1747,7 +1747,7 @@ mod bench {
src
}
fn encoder_json(count: uint) -> serialize::json::Json {
fn encoder_json(count: usize) -> serialize::json::Json {
use serialize::json::Json;
let mut list = vec!();
@@ -1768,7 +1768,7 @@ mod bench {
Json::Array(list)
}
fn serializer_json(count: uint) -> Value {
fn serializer_json(count: usize) -> Value {
let mut list = vec!();
for _ in range(0, count) {
list.push(Value::Object(treemap!(
@@ -1787,7 +1787,7 @@ mod bench {
Value::Array(list)
}
fn bench_encoder(b: &mut Bencher, count: uint) {
fn bench_encoder(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = encoder_json(count);
@@ -1796,7 +1796,7 @@ mod bench {
});
}
fn bench_encoder_pretty(b: &mut Bencher, count: uint) {
fn bench_encoder_pretty(b: &mut Bencher, count: usize) {
let src = pretty_json_str(count);
let json = encoder_json(count);
@@ -1805,7 +1805,7 @@ mod bench {
});
}
fn bench_serializer(b: &mut Bencher, count: uint) {
fn bench_serializer(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = serializer_json(count);
@@ -1814,7 +1814,7 @@ mod bench {
});
}
fn bench_serializer_pretty(b: &mut Bencher, count: uint) {
fn bench_serializer_pretty(b: &mut Bencher, count: usize) {
let src = pretty_json_str(count);
let json = serializer_json(count);
@@ -1823,7 +1823,7 @@ mod bench {
});
}
fn bench_decoder(b: &mut Bencher, count: uint) {
fn bench_decoder(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = encoder_json(count);
b.iter(|| {
@@ -1831,7 +1831,7 @@ mod bench {
});
}
fn bench_deserializer(b: &mut Bencher, count: uint) {
fn bench_deserializer(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = encoder_json(count);
b.iter(|| {
@@ -1839,7 +1839,7 @@ mod bench {
});
}
fn bench_decoder_streaming(b: &mut Bencher, count: uint) {
fn bench_decoder_streaming(b: &mut Bencher, count: usize) {
let src = json_str(count);
b.iter( || {
@@ -1878,7 +1878,7 @@ mod bench {
});
}
fn bench_deserializer_streaming(b: &mut Bencher, count: uint) {
fn bench_deserializer_streaming(b: &mut Bencher, count: usize) {
let src = json_str(count);
b.iter( || {
src/json/ser.rs
+13 -13
View File
@@ -64,8 +64,8 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, v: f64) -> IoResult<()> {
}
}
fn spaces<W: Writer>(wr: &mut W, mut n: uint) -> IoResult<()> {
const LEN: uint = 16;
fn spaces<W: Writer>(wr: &mut W, mut n: usize) -> IoResult<()> {
const LEN: usize = 16;
const BUF: &'static [u8; LEN] = &[b' '; LEN];
while n >= LEN {
@@ -128,7 +128,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
}
#[inline]
fn serialize_int(&mut self, v: int) -> IoResult<()> {
fn serialize_isize(&mut self, v: isize) -> IoResult<()> {
write!(&mut self.wr, "{}", v)
}
@@ -153,7 +153,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
}
#[inline]
fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
fn serialize_usize(&mut self, v: usize) -> IoResult<()> {
write!(&mut self.wr, "{}", v)
}
@@ -198,7 +198,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
}
#[inline]
fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> {
fn serialize_tuple_start(&mut self, _len: usize) -> IoResult<()> {
self.first = true;
self.wr.write_str("[")
}
@@ -221,7 +221,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
}
#[inline]
fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> {
fn serialize_struct_start(&mut self, _name: &str, _len: usize) -> IoResult<()> {
self.first = true;
self.wr.write_str("{")
}
@@ -246,7 +246,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
}
#[inline]
fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> {
fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: usize) -> IoResult<()> {
self.first = true;
try!(self.wr.write_str("{"));
try!(self.serialize_str(variant));
@@ -329,7 +329,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
/// compact data
pub struct PrettySerializer<W> {
wr: W,
indent: uint,
indent: usize,
first: bool,
}
@@ -391,7 +391,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_int(&mut self, v: int) -> IoResult<()> {
fn serialize_isize(&mut self, v: isize) -> IoResult<()> {
write!(&mut self.wr, "{}", v)
}
@@ -416,7 +416,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
fn serialize_usize(&mut self, v: usize) -> IoResult<()> {
write!(&mut self.wr, "{}", v)
}
@@ -461,7 +461,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> {
fn serialize_tuple_start(&mut self, _len: usize) -> IoResult<()> {
self.first = true;
self.wr.write_str("[")
}
@@ -480,7 +480,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> {
fn serialize_struct_start(&mut self, _name: &str, _len: usize) -> IoResult<()> {
self.first = true;
self.wr.write_str("{")
}
@@ -501,7 +501,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> {
fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: usize) -> IoResult<()> {
self.first = true;
try!(self.wr.write_str("{"));
try!(self.serialize_sep());
src/json/value.rs
+5 -5
View File
@@ -269,12 +269,12 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
match token {
Token::Null => Ok(Value::Null),
Token::Bool(x) => Ok(Value::Boolean(x)),
Token::Int(x) => Ok(Value::Integer(x as i64)),
Token::Isize(x) => Ok(Value::Integer(x as i64)),
Token::I8(x) => Ok(Value::Integer(x as i64)),
Token::I16(x) => Ok(Value::Integer(x as i64)),
Token::I32(x) => Ok(Value::Integer(x as i64)),
Token::I64(x) => Ok(Value::Integer(x)),
Token::Uint(x) => Ok(Value::Integer(x as i64)),
Token::Usize(x) => Ok(Value::Integer(x as i64)),
Token::U8(x) => Ok(Value::Integer(x as i64)),
Token::U16(x) => Ok(Value::Integer(x as i64)),
Token::U32(x) => Ok(Value::Integer(x as i64)),
@@ -439,7 +439,7 @@ impl de::Deserializer<Error> for Deserializer {
fn expect_enum_start(&mut self,
token: Token,
_name: &str,
variants: &[&str]) -> Result<uint, Error> {
variants: &[&str]) -> Result<usize, Error> {
let variant = match token {
Token::MapStart(_) => {
let state = match self.stack.pop() {
@@ -536,7 +536,7 @@ impl ToJson for Value {
fn to_json(&self) -> Value { (*self).clone() }
}
impl ToJson for int {
impl ToJson for isize {
fn to_json(&self) -> Value { Value::Integer(*self as i64) }
}
@@ -556,7 +556,7 @@ impl ToJson for i64 {
fn to_json(&self) -> Value { Value::Integer(*self as i64) }
}
impl ToJson for uint {
impl ToJson for usize {
fn to_json(&self) -> Value { Value::Integer(*self as i64) }
}
src/ser.rs
+50 -50
View File
@@ -22,7 +22,7 @@ pub trait Serializer<E> {
fn serialize_bool(&mut self, v: bool) -> Result<(), E>;
#[inline]
fn serialize_int(&mut self, v: int) -> Result<(), E> {
fn serialize_isize(&mut self, v: isize) -> Result<(), E> {
self.serialize_i64(v as i64)
}
@@ -45,7 +45,7 @@ pub trait Serializer<E> {
fn serialize_i64(&mut self, v: i64) -> Result<(), E>;
#[inline]
fn serialize_uint(&mut self, v: uint) -> Result<(), E> {
fn serialize_usize(&mut self, v: usize) -> Result<(), E> {
self.serialize_u64(v as u64)
}
@@ -78,19 +78,19 @@ pub trait Serializer<E> {
fn serialize_str(&mut self, v: &str) -> Result<(), E>;
fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
fn serialize_tuple_start(&mut self, len: usize) -> Result<(), E>;
fn serialize_tuple_elt<
T: Serialize<Self, E>
>(&mut self, v: &T) -> Result<(), E>;
fn serialize_tuple_end(&mut self) -> Result<(), E>;
fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>;
fn serialize_struct_start(&mut self, name: &str, len: usize) -> Result<(), E>;
fn serialize_struct_elt<
T: Serialize<Self, E>
>(&mut self, name: &str, v: &T) -> Result<(), E>;
fn serialize_struct_end(&mut self) -> Result<(), E>;
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: usize) -> Result<(), E>;
fn serialize_enum_elt<
T: Serialize<Self, E>
>(&mut self, v: &T) -> Result<(), E>;
@@ -132,12 +132,12 @@ macro_rules! impl_serialize {
}
impl_serialize!(bool, serialize_bool);
impl_serialize!(int, serialize_int);
impl_serialize!(isize, serialize_isize);
impl_serialize!(i8, serialize_i8);
impl_serialize!(i16, serialize_i16);
impl_serialize!(i32, serialize_i32);
impl_serialize!(i64, serialize_i64);
impl_serialize!(uint, serialize_uint);
impl_serialize!(usize, serialize_usize);
impl_serialize!(u8, serialize_u8);
impl_serialize!(u16, serialize_u16);
impl_serialize!(u32, serialize_u32);
@@ -332,7 +332,7 @@ mod tests {
#[derive_serialize]
struct Inner {
a: (),
b: uint,
b: usize,
c: HashMap<string::String, option::Option<char>>,
}
@@ -350,7 +350,7 @@ mod tests {
#[derive_serialize]
enum Animal {
Dog,
Frog(String, int)
Frog(String, isize)
}
//////////////////////////////////////////////////////////////////////////////
@@ -359,12 +359,12 @@ mod tests {
pub enum Token<'a> {
Null,
Bool(bool),
Int(int),
Isize(isize),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
Uint(uint),
Usize(usize),
U8(u8),
U16(u16),
U32(u32),
@@ -374,24 +374,24 @@ mod tests {
Char(char),
Str(&'a str),
TupleStart(uint),
TupleStart(usize),
TupleSep,
TupleEnd,
StructStart(&'a str, uint),
StructStart(&'a str, usize),
StructSep(&'a str),
StructEnd,
EnumStart(&'a str, &'a str, uint),
EnumStart(&'a str, &'a str, usize),
EnumSep,
EnumEnd,
Option(bool),
SeqStart(uint),
SeqStart(usize),
SeqEnd,
MapStart(uint),
MapStart(usize),
MapEnd,
}
@@ -434,8 +434,8 @@ mod tests {
fn serialize_bool(&mut self, v: bool) -> Result<(), Error> {
self.serialize(Token::Bool(v))
}
fn serialize_int(&mut self, v: int) -> Result<(), Error> {
self.serialize(Token::Int(v))
fn serialize_isize(&mut self, v: isize) -> Result<(), Error> {
self.serialize(Token::Isize(v))
}
fn serialize_i8(&mut self, v: i8) -> Result<(), Error> {
@@ -454,8 +454,8 @@ mod tests {
self.serialize(Token::I64(v))
}
fn serialize_uint(&mut self, v: uint) -> Result<(), Error> {
self.serialize(Token::Uint(v))
fn serialize_usize(&mut self, v: usize) -> Result<(), Error> {
self.serialize(Token::Usize(v))
}
fn serialize_u8(&mut self, v: u8) -> Result<(), Error> {
@@ -490,7 +490,7 @@ mod tests {
self.serialize(Token::Str(v))
}
fn serialize_tuple_start(&mut self, len: uint) -> Result<(), Error> {
fn serialize_tuple_start(&mut self, len: usize) -> Result<(), Error> {
self.serialize(Token::TupleStart(len))
}
@@ -505,7 +505,7 @@ mod tests {
self.serialize(Token::TupleEnd)
}
fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), Error> {
fn serialize_struct_start(&mut self, name: &str, len: usize) -> Result<(), Error> {
self.serialize(Token::StructStart(name, len))
}
@@ -520,7 +520,7 @@ mod tests {
self.serialize(Token::StructEnd)
}
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), Error> {
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: usize) -> Result<(), Error> {
self.serialize(Token::EnumStart(name, variant, len))
}
@@ -581,10 +581,10 @@ mod tests {
#[test]
fn test_tokens_int() {
let tokens = vec!(
Token::Int(5)
Token::Isize(5)
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
5i.serialize(&mut serializer).unwrap();
5is.serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -617,7 +617,7 @@ mod tests {
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
None::<int>.serialize(&mut serializer).unwrap();
None::<isize>.serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -625,11 +625,11 @@ mod tests {
fn test_tokens_option_some() {
let tokens = vec!(
Token::Option(true),
Token::Int(5),
Token::Isize(5),
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
Some(5i).serialize(&mut serializer).unwrap();
Some(5is).serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -638,7 +638,7 @@ mod tests {
let tokens = vec!(
Token::TupleStart(2),
Token::TupleSep,
Token::Int(5),
Token::Isize(5),
Token::TupleSep,
Token::Str("a"),
@@ -646,7 +646,7 @@ mod tests {
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
(5i, "a").serialize(&mut serializer).unwrap();
(5is, "a").serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -663,7 +663,7 @@ mod tests {
Token::TupleSep,
Token::TupleStart(2),
Token::TupleSep,
Token::Int(5),
Token::Isize(5),
Token::TupleSep,
Token::Str("a"),
@@ -672,7 +672,7 @@ mod tests {
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
((), (), (5i, "a")).serialize(&mut serializer).unwrap();
((), (), (5is, "a")).serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -702,7 +702,7 @@ mod tests {
Token::Null,
Token::StructSep("b"),
Token::Uint(5),
Token::Usize(5),
Token::StructSep("c"),
Token::MapStart(1),
@@ -749,7 +749,7 @@ mod tests {
Token::Str("Henry"),
Token::EnumSep,
Token::Int(349),
Token::Isize(349),
Token::EnumEnd,
);
@@ -766,7 +766,7 @@ mod tests {
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
let v: Vec<int> = vec!();
let v: Vec<isize> = vec!();
v.serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -775,14 +775,14 @@ mod tests {
fn test_tokens_vec() {
let tokens = vec!(
Token::SeqStart(3),
Token::Int(5),
Token::Int(6),
Token::Int(7),
Token::Isize(5),
Token::Isize(6),
Token::Isize(7),
Token::SeqEnd,
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
(vec!(5i, 6, 7)).serialize(&mut serializer).unwrap();
(vec!(5is, 6, 7)).serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -791,24 +791,24 @@ mod tests {
let tokens = vec!(
Token::SeqStart(3),
Token::SeqStart(1),
Token::Int(1),
Token::Isize(1),
Token::SeqEnd,
Token::SeqStart(2),
Token::Int(2),
Token::Int(3),
Token::Isize(2),
Token::Isize(3),
Token::SeqEnd,
Token::SeqStart(3),
Token::Int(4),
Token::Int(5),
Token::Int(6),
Token::Isize(4),
Token::Isize(5),
Token::Isize(6),
Token::SeqEnd,
Token::SeqEnd,
);
let mut serializer = AssertSerializer::new(tokens.into_iter());
(vec!(vec!(1i), vec!(2, 3), vec!(4, 5, 6))).serialize(&mut serializer).unwrap();
(vec!(vec!(1is), vec!(2, 3), vec!(4, 5, 6))).serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);
}
@@ -816,10 +816,10 @@ mod tests {
fn test_tokens_treemap() {
let tokens = vec!(
Token::MapStart(2),
Token::Int(5),
Token::Isize(5),
Token::Str("a"),
Token::Int(6),
Token::Isize(6),
Token::Str("b"),
Token::MapEnd,
);
@@ -827,8 +827,8 @@ mod tests {
let mut serializer = AssertSerializer::new(tokens.into_iter());
let mut map = BTreeMap::new();
map.insert(5i, "a".to_string());
map.insert(6i, "b".to_string());
map.insert(5is, "a".to_string());
map.insert(6is, "b".to_string());
map.serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None);