aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/lib.rs7
-rw-r--r--src/parser.rs36
-rw-r--r--src/serialization.rs134
-rw-r--r--src/show.rs47
4 files changed, 111 insertions, 113 deletions
diff --git a/src/lib.rs b/src/lib.rs
index 4d714f0..a046189 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -37,9 +37,8 @@
//!
#![deny(missing_docs)]
-#![allow(staged_experimental)]
-#![allow(staged_unstable)]
#![cfg_attr(test, deny(warnings))]
+#![allow(unstable)]
extern crate "rustc-serialize" as rustc_serialize;
@@ -159,7 +158,7 @@ impl Value {
/// Note: arrays have zero-based indexes.
///
/// ```
- /// # #![allow(staged_unstable)]
+ /// # #![allow(unstable)]
/// let toml = r#"
/// [test]
/// foo = "bar"
@@ -192,7 +191,7 @@ impl Value {
}
},
&Value::Array(ref v) => {
- match key.parse::<uint>() {
+ match key.parse::<usize>() {
Some(idx) if idx < v.len() => cur_value = &v[idx],
_ => return None
}
diff --git a/src/parser.rs b/src/parser.rs
index 6df4699..721c83c 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -30,9 +30,9 @@ pub struct Parser<'a> {
#[derive(Show)]
pub struct ParserError {
/// The low byte at which this error is pointing at.
- pub lo: uint,
+ pub lo: usize,
/// One byte beyond the last character at which this error is pointing at.
- pub hi: uint,
+ pub hi: usize,
/// A human-readable description explaining what the error is.
pub desc: String,
}
@@ -69,7 +69,7 @@ impl<'a> Parser<'a> {
/// Converts a byte offset from an error message to a (line, column) pair
///
/// All indexes are 0-based.
- pub fn to_linecol(&self, offset: uint) -> (uint, uint) {
+ pub fn to_linecol(&self, offset: usize) -> (usize, usize) {
let mut cur = 0;
for (i, line) in self.input.lines().enumerate() {
if cur + line.len() > offset {
@@ -80,7 +80,7 @@ impl<'a> Parser<'a> {
return (self.input.lines().count(), 0)
}
- fn next_pos(&self) -> uint {
+ fn next_pos(&self) -> usize {
self.cur.clone().next().map(|p| p.0).unwrap_or(self.input.len())
}
@@ -271,7 +271,7 @@ impl<'a> Parser<'a> {
}
// Parses a single or multi-line string
- fn string(&mut self, start: uint) -> Option<Value> {
+ fn string(&mut self, start: usize) -> Option<Value> {
if !self.expect('"') { return None }
let mut multiline = false;
let mut ret = String::new();
@@ -331,7 +331,7 @@ impl<'a> Parser<'a> {
return Some(Value::String(ret));
- fn escape(me: &mut Parser, pos: uint, multiline: bool) -> Option<char> {
+ fn escape(me: &mut Parser, pos: usize, multiline: bool) -> Option<char> {
match me.cur.next() {
Some((_, 'b')) => Some('\u{8}'),
Some((_, 't')) => Some('\u{9}'),
@@ -417,7 +417,7 @@ impl<'a> Parser<'a> {
}
}
- fn literal_string(&mut self, start: uint) -> Option<Value> {
+ fn literal_string(&mut self, start: usize) -> Option<Value> {
if !self.expect('\'') { return None }
let mut multiline = false;
let mut ret = String::new();
@@ -453,7 +453,7 @@ impl<'a> Parser<'a> {
return Some(Value::String(ret));
}
- fn number_or_datetime(&mut self, start: uint) -> Option<Value> {
+ fn number_or_datetime(&mut self, start: usize) -> Option<Value> {
let negative = self.eat('-');
let mut is_float = false;
loop {
@@ -488,15 +488,15 @@ impl<'a> Parser<'a> {
return ret;
}
- fn boolean(&mut self, start: uint) -> Option<Value> {
+ fn boolean(&mut self, start: usize) -> Option<Value> {
let rest = self.input.slice_from(start);
if rest.starts_with("true") {
- for _ in range(0u, 4u) {
+ for _ in 0..4 {
self.cur.next();
}
Some(Boolean(true))
} else if rest.starts_with("false") {
- for _ in range(0u, 5u) {
+ for _ in 0..5 {
self.cur.next();
}
Some(Boolean(false))
@@ -512,9 +512,9 @@ impl<'a> Parser<'a> {
}
}
- fn datetime(&mut self, start: uint, end_so_far: uint) -> Option<Value> {
+ fn datetime(&mut self, start: usize, end_so_far: usize) -> Option<Value> {
let mut date = self.input.slice(start, end_so_far).to_string();
- for _ in range(0u, 15u) {
+ for _ in 0..15 {
match self.cur.next() {
Some((_, ch)) => date.push(ch),
None => {
@@ -561,7 +561,7 @@ impl<'a> Parser<'a> {
}
}
- fn array(&mut self, _start: uint) -> Option<Value> {
+ fn array(&mut self, _start: usize) -> Option<Value> {
if !self.expect('[') { return None }
let mut ret = Vec::new();
fn consume(me: &mut Parser) {
@@ -612,7 +612,7 @@ impl<'a> Parser<'a> {
}
fn insert(&mut self, into: &mut TomlTable, key: String, value: Value,
- key_lo: uint) {
+ key_lo: usize) {
if into.contains_key(&key) {
self.errors.push(ParserError {
lo: key_lo,
@@ -625,7 +625,7 @@ impl<'a> Parser<'a> {
}
fn recurse<'b>(&mut self, mut cur: &'b mut TomlTable, orig_key: &'b str,
- key_lo: uint) -> Option<(&'b mut TomlTable, &'b str)> {
+ key_lo: usize) -> Option<(&'b mut TomlTable, &'b str)> {
if orig_key.starts_with(".") || orig_key.ends_with(".") ||
orig_key.contains("..") {
self.errors.push(ParserError {
@@ -687,7 +687,7 @@ impl<'a> Parser<'a> {
}
fn insert_table(&mut self, into: &mut TomlTable, key: String, value: TomlTable,
- key_lo: uint) {
+ key_lo: usize) {
let (into, key) = match self.recurse(into, key.as_slice(), key_lo) {
Some(pair) => pair,
None => return,
@@ -730,7 +730,7 @@ impl<'a> Parser<'a> {
}
fn insert_array(&mut self, into: &mut TomlTable, key: String, value: Value,
- key_lo: uint) {
+ key_lo: usize) {
let (into, key) = match self.recurse(into, key.as_slice(), key_lo) {
Some(pair) => pair,
None => return,
diff --git a/src/serialization.rs b/src/serialization.rs
index 4f0fd19..767c160 100644
--- a/src/serialization.rs
+++ b/src/serialization.rs
@@ -23,9 +23,7 @@ use self::DecodeErrorKind::{ExpectedMapElement, NoEnumVariants, NilTooLong};
/// # Example
///
/// ```
-/// # #![feature(old_orphan_check)]
-/// # #![allow(staged_unstable)]
-/// # #![allow(staged_experimental)]
+/// # #![allow(unstable)]
/// extern crate "rustc-serialize" as rustc_serialize;
/// extern crate toml;
///
@@ -92,7 +90,7 @@ pub struct DecodeError {
}
/// Enumeration of possible errors which can occur while decoding a structure.
-#[derive(PartialEq)]
+#[derive(PartialEq, Show)]
pub enum DecodeErrorKind {
/// An error flagged by the application, e.g. value out of range
ApplicationError(String),
@@ -101,9 +99,9 @@ pub enum DecodeErrorKind {
/// A field was found, but it had the wrong type.
ExpectedType(/* expected */ &'static str, /* found */ &'static str),
/// The nth map key was expected, but none was found.
- ExpectedMapKey(uint),
+ ExpectedMapKey(usize),
/// The nth map element was expected, but none was found.
- ExpectedMapElement(uint),
+ ExpectedMapElement(usize),
/// An enum decoding was requested, but no variants were supplied
NoEnumVariants,
/// The unit type was being decoded, but a non-zero length string was found
@@ -166,7 +164,7 @@ impl rustc_serialize::Encoder for Encoder {
type Error = Error;
fn emit_nil(&mut self) -> Result<(), Error> { Ok(()) }
- fn emit_usize(&mut self, v: uint) -> Result<(), Error> {
+ fn emit_usize(&mut self, v: usize) -> Result<(), Error> {
self.emit_i64(v as i64)
}
fn emit_u8(&mut self, v: u8) -> Result<(), Error> {
@@ -181,7 +179,7 @@ impl rustc_serialize::Encoder for Encoder {
fn emit_u64(&mut self, v: u64) -> Result<(), Error> {
self.emit_i64(v as i64)
}
- fn emit_isize(&mut self, v: int) -> Result<(), Error> {
+ fn emit_isize(&mut self, v: isize) -> Result<(), Error> {
self.emit_i64(v as i64)
}
fn emit_i8(&mut self, v: i8) -> Result<(), Error> {
@@ -215,20 +213,20 @@ impl rustc_serialize::Encoder for Encoder {
{
f(self)
}
- fn emit_enum_variant<F>(&mut self, _v_name: &str, _v_id: uint, _len: uint, f: F)
- -> Result<(), Error>
+ fn emit_enum_variant<F>(&mut self, _v_name: &str, _v_id: usize,
+ _len: usize, f: F) -> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
f(self)
}
- fn emit_enum_variant_arg<F>(&mut self, _a_idx: uint, f: F)
+ fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
f(self)
}
- fn emit_enum_struct_variant<F>(&mut self, _v_name: &str, _v_id: uint,
- _len: uint,
+ fn emit_enum_struct_variant<F>(&mut self, _v_name: &str, _v_id: usize,
+ _len: usize,
_f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
@@ -237,14 +235,14 @@ impl rustc_serialize::Encoder for Encoder {
}
fn emit_enum_struct_variant_field<F>(&mut self,
_f_name: &str,
- _f_idx: uint,
+ _f_idx: usize,
_f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
panic!()
}
- fn emit_struct<F>(&mut self, _name: &str, _len: uint, f: F)
+ fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
@@ -266,7 +264,7 @@ impl rustc_serialize::Encoder for Encoder {
NextMapKey => Err(InvalidMapKeyLocation),
}
}
- fn emit_struct_field<F>(&mut self, f_name: &str, _f_idx: uint, f: F)
+ fn emit_struct_field<F>(&mut self, f_name: &str, _f_idx: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
@@ -278,25 +276,25 @@ impl rustc_serialize::Encoder for Encoder {
self.state = old;
Ok(())
}
- fn emit_tuple<F>(&mut self, len: uint, f: F)
+ fn emit_tuple<F>(&mut self, len: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
self.emit_seq(len, f)
}
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F)
+ fn emit_tuple_arg<F>(&mut self, idx: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
self.emit_seq_elt(idx, f)
}
- fn emit_tuple_struct<F>(&mut self, _name: &str, _len: uint, _f: F)
+ fn emit_tuple_struct<F>(&mut self, _name: &str, _len: usize, _f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
unimplemented!()
}
- fn emit_tuple_struct_arg<F>(&mut self, _f_idx: uint, _f: F)
+ fn emit_tuple_struct_arg<F>(&mut self, _f_idx: usize, _f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
@@ -322,7 +320,7 @@ impl rustc_serialize::Encoder for Encoder {
{
f(self)
}
- fn emit_seq<F>(&mut self, _len: uint, f: F)
+ fn emit_seq<F>(&mut self, _len: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
@@ -333,19 +331,19 @@ impl rustc_serialize::Encoder for Encoder {
_ => unreachable!(),
}
}
- fn emit_seq_elt<F>(&mut self, _idx: uint, f: F)
+ fn emit_seq_elt<F>(&mut self, _idx: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
f(self)
}
- fn emit_map<F>(&mut self, len: uint, f: F)
+ fn emit_map<F>(&mut self, len: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
self.emit_struct("foo", len, f)
}
- fn emit_map_elt_key<F>(&mut self, _idx: uint, mut f: F)
+ fn emit_map_elt_key<F>(&mut self, _idx: usize, mut f: F)
-> Result<(), Error>
where F: FnMut(&mut Encoder) -> Result<(), Error>
{
@@ -359,7 +357,7 @@ impl rustc_serialize::Encoder for Encoder {
_ => Err(InvalidMapKeyLocation),
}
}
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F)
+ fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F)
-> Result<(), Error>
where F: FnOnce(&mut Encoder) -> Result<(), Error>
{
@@ -441,8 +439,8 @@ impl rustc_serialize::Decoder for Decoder {
self.toml.take();
Ok(())
}
- fn read_usize(&mut self) -> Result<uint, DecodeError> {
- self.read_i64().map(|i| i as uint)
+ fn read_usize(&mut self) -> Result<usize, DecodeError> {
+ self.read_i64().map(|i| i as usize)
}
fn read_u64(&mut self) -> Result<u64, DecodeError> {
self.read_i64().map(|i| i as u64)
@@ -456,8 +454,8 @@ impl rustc_serialize::Decoder for Decoder {
fn read_u8(&mut self) -> Result<u8, DecodeError> {
self.read_i64().map(|i| i as u8)
}
- fn read_isize(&mut self) -> Result<int, DecodeError> {
- self.read_i64().map(|i| i as int)
+ fn read_isize(&mut self) -> Result<isize, DecodeError> {
+ self.read_i64().map(|i| i as isize)
}
fn read_i64(&mut self) -> Result<i64, DecodeError> {
match self.toml {
@@ -519,7 +517,7 @@ impl rustc_serialize::Decoder for Decoder {
fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F)
-> Result<T, DecodeError>
- where F: FnMut(&mut Decoder, uint) -> Result<T, DecodeError>
+ where F: FnMut(&mut Decoder, usize) -> Result<T, DecodeError>
{
let mut first_error = None;
for i in range(0, names.len()) {
@@ -535,7 +533,7 @@ impl rustc_serialize::Decoder for Decoder {
}
Err(first_error.unwrap_or_else(|| self.err(NoEnumVariants)))
}
- fn read_enum_variant_arg<T, F>(&mut self, _a_idx: uint, f: F)
+ fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -544,13 +542,13 @@ impl rustc_serialize::Decoder for Decoder {
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F)
-> Result<T, DecodeError>
- where F: FnMut(&mut Decoder, uint) -> Result<T, DecodeError>
+ where F: FnMut(&mut Decoder, usize) -> Result<T, DecodeError>
{
panic!()
}
fn read_enum_struct_variant_field<T, F>(&mut self,
_f_name: &str,
- _f_idx: uint,
+ _f_idx: usize,
_f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
@@ -558,7 +556,7 @@ impl rustc_serialize::Decoder for Decoder {
panic!()
}
- fn read_struct<T, F>(&mut self, _s_name: &str, _len: uint, f: F)
+ fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -575,7 +573,7 @@ impl rustc_serialize::Decoder for Decoder {
ref found => Err(self.mismatch("table", found)),
}
}
- fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: uint, f: F)
+ fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -599,7 +597,7 @@ impl rustc_serialize::Decoder for Decoder {
Ok(ret)
}
- fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F)
+ fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -610,20 +608,20 @@ impl rustc_serialize::Decoder for Decoder {
f(d)
})
}
- fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F)
+ fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
self.read_seq_elt(a_idx, f)
}
- fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F)
+ fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
panic!()
}
- fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: uint, _f: F)
+ fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -643,7 +641,7 @@ impl rustc_serialize::Decoder for Decoder {
fn read_seq<T, F>(&mut self, f: F)
-> Result<T, DecodeError>
- where F: FnOnce(&mut Decoder,uint) -> Result<T, DecodeError>
+ where F: FnOnce(&mut Decoder, usize) -> Result<T, DecodeError>
{
let len = match self.toml {
Some(Array(ref arr)) => arr.len(),
@@ -661,7 +659,7 @@ impl rustc_serialize::Decoder for Decoder {
self.toml.take();
Ok(ret)
}
- fn read_seq_elt<T, F>(&mut self, idx: uint, f: F)
+ fn read_seq_elt<T, F>(&mut self, idx: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -683,7 +681,7 @@ impl rustc_serialize::Decoder for Decoder {
fn read_map<T, F>(&mut self, f: F)
-> Result<T, DecodeError>
- where F: FnOnce(&mut Decoder, uint) -> Result<T, DecodeError>
+ where F: FnOnce(&mut Decoder, usize) -> Result<T, DecodeError>
{
let len = match self.toml {
Some(Table(ref table)) => table.len(),
@@ -693,7 +691,7 @@ impl rustc_serialize::Decoder for Decoder {
self.toml.take();
Ok(ret)
}
- fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F)
+ fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -710,7 +708,7 @@ impl rustc_serialize::Decoder for Decoder {
ref found => Err(self.mismatch("table", found)),
}
}
- fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F)
+ fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
-> Result<T, DecodeError>
where F: FnOnce(&mut Decoder) -> Result<T, DecodeError>
{
@@ -738,6 +736,12 @@ impl rustc_serialize::Decoder for Decoder {
impl fmt::Show for DecodeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for DecodeError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(match self.kind {
ApplicationError(ref err) => {
write!(f, "{}", err)
@@ -800,6 +804,12 @@ impl StdError for DecodeError {
impl fmt::Show for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NeedsKey => write!(f, "need a key to encode"),
NoValue => write!(f, "not value to emit for a previous key"),
@@ -845,7 +855,7 @@ mod tests {
#[test]
fn smoke() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { a: int }
+ struct Foo { a: isize }
let v = Foo { a: 2 };
assert_eq!(encode!(v), map! { a, Integer(2) });
@@ -855,7 +865,7 @@ mod tests {
#[test]
fn smoke_hyphen() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { a_b: int }
+ struct Foo { a_b: isize }
let v = Foo { a_b: 2 };
assert_eq!(encode!(v), map! { a_b, Integer(2) });
@@ -869,7 +879,7 @@ mod tests {
#[test]
fn nested() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { a: int, b: Bar }
+ struct Foo { a: isize, b: Bar }
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
struct Bar { a: String }
@@ -887,10 +897,10 @@ mod tests {
#[test]
fn application_decode_error() {
#[derive(PartialEq, Show)]
- struct Range10(uint);
+ struct Range10(usize);
impl Decodable for Range10 {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Range10, D::Error> {
- let x: uint = try!(Decodable::decode(d));
+ let x: usize = try!(Decodable::decode(d));
if x > 10 {
Err(d.error("Value out of range!"))
} else {
@@ -899,7 +909,7 @@ mod tests {
}
}
let mut d_good = Decoder::new(Integer(5));
- let mut d_bad1 = Decoder::new(Value::String("not an int".to_string()));
+ let mut d_bad1 = Decoder::new(Value::String("not an isize".to_string()));
let mut d_bad2 = Decoder::new(Integer(11));
assert_eq!(Ok(Range10(5)), Decodable::decode(&mut d_good));
@@ -913,7 +923,7 @@ mod tests {
#[test]
fn array() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { a: Vec<int> }
+ struct Foo { a: Vec<isize> }
let v = Foo { a: vec![1, 2, 3, 4] };
assert_eq!(encode!(v),
@@ -931,7 +941,7 @@ mod tests {
#[test]
fn tuple() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { a: (int, int, int, int) }
+ struct Foo { a: (isize, isize, isize, isize) }
let v = Foo { a: (1, 2, 3, 4) };
assert_eq!(encode!(v),
@@ -986,7 +996,7 @@ mod tests {
fn hashmap() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
struct Foo {
- map: BTreeMap<String, int>,
+ map: BTreeMap<String, isize>,
set: HashSet<char>,
}
@@ -1018,7 +1028,7 @@ mod tests {
#[test]
fn tuple_struct() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo(int, String, f64);
+ struct Foo(isize, String, f64);
let v = Foo(1, "foo".to_string(), 4.5);
assert_eq!(
@@ -1037,7 +1047,7 @@ mod tests {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
struct Foo { a: Vec<Bar>, }
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Bar { a: int }
+ struct Bar { a: isize }
let v = Foo { a: vec![Bar { a: 1 }, Bar { a: 2 }] };
assert_eq!(
@@ -1055,7 +1065,7 @@ mod tests {
#[test]
fn type_errors() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { bar: int }
+ struct Foo { bar: isize }
let mut d = Decoder::new(Table(map! {
bar, Float(1.0)
@@ -1074,7 +1084,7 @@ mod tests {
#[test]
fn missing_errors() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { bar: int }
+ struct Foo { bar: isize }
let mut d = Decoder::new(Table(map! {
}));
@@ -1094,7 +1104,7 @@ mod tests {
struct Foo { a: E }
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
enum E {
- Bar(int),
+ Bar(isize),
Baz(f64),
Last(Foo2),
}
@@ -1128,7 +1138,7 @@ mod tests {
#[test]
fn unused_fields() {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Foo { a: int }
+ struct Foo { a: isize }
let v = Foo { a: 2 };
let mut d = Decoder::new(Table(map! {
@@ -1147,7 +1157,7 @@ mod tests {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
struct Foo { a: Bar }
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Bar { a: int }
+ struct Bar { a: isize }
let v = Foo { a: Bar { a: 2 } };
let mut d = Decoder::new(Table(map! {
@@ -1170,7 +1180,7 @@ mod tests {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
struct Foo { a: Bar }
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Bar { a: int }
+ struct Bar { a: isize }
let v = Foo { a: Bar { a: 2 } };
let mut d = Decoder::new(Table(map! {
@@ -1232,7 +1242,7 @@ mod tests {
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
struct Foo { a: Vec<Bar> }
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
- struct Bar { a: int }
+ struct Bar { a: isize }
let v = Foo { a: vec![Bar { a: 1 }] };
let mut d = Decoder::new(Table(map! {
diff --git a/src/show.rs b/src/show.rs
index cfa43a2..af1eba0 100644
--- a/src/show.rs
+++ b/src/show.rs
@@ -1,7 +1,6 @@
use std::fmt;
use Table as TomlTable;
-use Array as TomlArray;
use Value::{self, String, Integer, Float, Boolean, Datetime, Array, Table};
struct Printer<'a, 'b:'a> {
@@ -41,9 +40,13 @@ impl fmt::String for Value {
p.print(t)
}
Array(ref a) => {
- let mut p = Printer { output: f, stack: Vec::new() };
- p.print_array(a)
- },
+ try!(write!(f, "["));
+ for (i, v) in a.iter().enumerate() {
+ if i != 0 { try!(write!(f, ", ")); }
+ try!(write!(f, "{}", v));
+ }
+ write!(f, "]")
+ }
}
}
}
@@ -93,20 +96,6 @@ impl<'a, 'b> Printer<'a, 'b> {
}
Ok(())
}
-
- fn print_array(&mut self, array: &'a TomlArray) -> fmt::Result {
- try!(self.output.write_str("["));
- let mut first = true;
- for item in array.iter() {
- if first {
- first = false;
- } else {
- try!(self.output.write_str(", "));
- }
- try!((&item as &fmt::String).fmt(self.output));
- }
- self.output.write_str("]")
- }
}
#[cfg(test)]
@@ -116,7 +105,7 @@ mod tests {
use Value::{String, Integer, Float, Boolean, Datetime, Array, Table};
use std::collections::BTreeMap;
- macro_rules! map( ($($k:expr, $v:expr),*) => ({
+ macro_rules! map( ($($k:expr => $v:expr),*) => ({
let mut _m = BTreeMap::new();
$(_m.insert($k.to_string(), $v);)*
_m
@@ -146,12 +135,12 @@ mod tests {
fn table() {
assert_eq!(Table(map! { }).to_string().as_slice(),
"");
- assert_eq!(Table(map! { "test", Integer(2) }).to_string().as_slice(),
+ assert_eq!(Table(map! { "test" => Integer(2) }).to_string().as_slice(),
"test = 2\n");
assert_eq!(Table(map! {
- "test", Integer(2),
- "test2", Table(map! {
- "test", String("wut".to_string())
+ "test" => Integer(2),
+ "test2" => Table(map! {
+ "test" => String("wut".to_string())
})
}).to_string().as_slice(),
"test = 2\n\
@@ -159,9 +148,9 @@ mod tests {
[test2]\n\
test = \"wut\"\n");
assert_eq!(Table(map! {
- "test", Integer(2),
- "test2", Table(map! {
- "test", String("wut".to_string())
+ "test" => Integer(2),
+ "test2" => Table(map! {
+ "test" => String("wut".to_string())
})
}).to_string().as_slice(),
"test = 2\n\
@@ -169,9 +158,9 @@ mod tests {
[test2]\n\
test = \"wut\"\n");
assert_eq!(Table(map! {
- "test", Integer(2),
- "test2", Array(vec![Table(map! {
- "test", String("wut".to_string())
+ "test" => Integer(2),
+ "test2" => Array(vec![Table(map! {
+ "test" => String("wut".to_string())
})])
}).to_string().as_slice(),
"test = 2\n\