extra: Rename json constructors into *::init

diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index 02c1ac077d47de65795f527f3822ad71345c98f3..e0792014c77f1076abef43eaabb38fb821e098f6 100644 (file)
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -88,10 +88,12 @@ pub struct Encoder {
     priv wr: @mut io::Writer,
 }
 
-/// Creates a new JSON encoder whose output will be written to the writer
-/// specified.
-pub fn Encoder(wr: @mut io::Writer) -> Encoder {
-    Encoder { wr: wr }
+impl Encoder {
+    /// Creates a new JSON encoder whose output will be written to the writer
+    /// specified.
+    pub fn init(wr: @mut io::Writer) -> Encoder {
+        Encoder { wr: wr }
+    }
 }
 
 impl serialize::Encoder for Encoder {
@@ -243,11 +245,13 @@ pub struct PrettyEncoder {
     priv indent: uint,
 }
 
-/// Creates a new encoder whose output will be written to the specified writer
-pub fn PrettyEncoder(wr: @mut io::Writer) -> PrettyEncoder {
-    PrettyEncoder {
-        wr: wr,
-        indent: 0,
+impl PrettyEncoder {
+    /// Creates a new encoder whose output will be written to the specified writer
+    pub fn init(wr: @mut io::Writer) -> PrettyEncoder {
+        PrettyEncoder {
+            wr: wr,
+            indent: 0,
+        }
     }
 }
 
@@ -445,14 +449,14 @@ fn encode(&self, e: &mut E) {
 impl Json{
     /// Encodes a json value into a io::writer.  Uses a single line.
     pub fn to_writer(&self, wr: @mut io::Writer) {
-        let mut encoder = Encoder(wr);
+        let mut encoder = Encoder::init(wr);
         self.encode(&mut encoder)
     }
 
     /// Encodes a json value into a io::writer.
     /// Pretty-prints in a more readable format.
     pub fn to_pretty_writer(&self, wr: @mut io::Writer) {
-        let mut encoder = PrettyEncoder(wr);
+        let mut encoder = PrettyEncoder::init(wr);
         self.encode(&mut encoder)
     }
 
@@ -465,22 +469,24 @@ pub fn to_pretty_str(&self) -> ~str {
 }
 
 pub struct Parser<T> {
-    priv rdr: ~T,
+    priv rdr: T,
     priv ch: char,
     priv line: uint,
     priv col: uint,
 }
 
-/// Decode a json value from an Iterator<char>
-pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
-    let mut p = Parser {
-        rdr: rdr,
-        ch: '\x00',
-        line: 1,
-        col: 0,
-    };
-    p.bump();
-    p
+impl<T: Iterator<char>> Parser<T> {
+    /// Decode a json value from an Iterator<char>
+    pub fn init(rdr: T) -> Parser<T> {
+        let mut p = Parser {
+            rdr: rdr,
+            ch: '\x00',
+            line: 1,
+            col: 0,
+        };
+        p.bump();
+        p
+    }
 }
 
 impl<T: Iterator<char>> Parser<T> {
@@ -842,13 +848,13 @@ fn parse_object(&mut self) -> Result<Json, Error> {
 /// Decodes a json value from an `&mut io::Reader`
 pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, Error> {
     let s = str::from_utf8(rdr.read_to_end());
-    let mut parser = Parser(~s.chars());
+    let mut parser = Parser::init(s.chars());
     parser.parse()
 }
 
 /// Decodes a json value from a string
 pub fn from_str(s: &str) -> Result<Json, Error> {
-    let mut parser = Parser(~s.chars());
+    let mut parser = Parser::init(s.chars());
     parser.parse()
 }
 
@@ -857,10 +863,12 @@ pub struct Decoder {
     priv stack: ~[Json],
 }
 
-/// Creates a new decoder instance for decoding the specified JSON value.
-pub fn Decoder(json: Json) -> Decoder {
-    Decoder {
-        stack: ~[json]
+impl Decoder {
+    /// Creates a new decoder instance for decoding the specified JSON value.
+    pub fn init(json: Json) -> Decoder {
+        Decoder {
+            stack: ~[json]
+        }
     }
 }
 
@@ -1514,14 +1522,14 @@ fn test_write_enum() {
         let animal = Dog;
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = Encoder(wr);
+                let mut encoder = Encoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"\"Dog\""
         );
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = PrettyEncoder(wr);
+                let mut encoder = PrettyEncoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"\"Dog\""
@@ -1530,14 +1538,14 @@ fn test_write_enum() {
         let animal = Frog(~"Henry", 349);
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = Encoder(wr);
+                let mut encoder = Encoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
         );
         assert_eq!(
             with_str_writer(|wr| {
-                let mut encoder = PrettyEncoder(wr);
+                let mut encoder = PrettyEncoder::init(wr);
                 animal.encode(&mut encoder);
             }),
             ~"\
@@ -1553,14 +1561,14 @@ fn test_write_enum() {
     fn test_write_some() {
         let value = Some(~"jodhpurs");
         let s = with_str_writer(|wr| {
-            let mut encoder = Encoder(wr);
+            let mut encoder = Encoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"\"jodhpurs\"");
 
         let value = Some(~"jodhpurs");
         let s = with_str_writer(|wr| {
-            let mut encoder = PrettyEncoder(wr);
+            let mut encoder = PrettyEncoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"\"jodhpurs\"");
@@ -1570,13 +1578,13 @@ fn test_write_some() {
     fn test_write_none() {
         let value: Option<~str> = None;
         let s = with_str_writer(|wr| {
-            let mut encoder = Encoder(wr);
+            let mut encoder = Encoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"null");
 
         let s = with_str_writer(|wr| {
-            let mut encoder = Encoder(wr);
+            let mut encoder = Encoder::init(wr);
             value.encode(&mut encoder);
         });
         assert_eq!(s, ~"null");
@@ -1625,15 +1633,15 @@ fn test_read_identifiers() {
 
     #[test]
     fn test_decode_identifiers() {
-        let mut decoder = Decoder(from_str("null").unwrap());
+        let mut decoder = Decoder::init(from_str("null").unwrap());
         let v: () = Decodable::decode(&mut decoder);
         assert_eq!(v, ());
 
-        let mut decoder = Decoder(from_str("true").unwrap());
+        let mut decoder = Decoder::init(from_str("true").unwrap());
         let v: bool = Decodable::decode(&mut decoder);
         assert_eq!(v, true);
 
-        let mut decoder = Decoder(from_str("false").unwrap());
+        let mut decoder = Decoder::init(from_str("false").unwrap());
         let v: bool = Decodable::decode(&mut decoder);
         assert_eq!(v, false);
     }
@@ -1668,31 +1676,31 @@ fn test_read_number() {
 
     #[test]
     fn test_decode_numbers() {
-        let mut decoder = Decoder(from_str("3").unwrap());
+        let mut decoder = Decoder::init(from_str("3").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 3.0);
 
-        let mut decoder = Decoder(from_str("3.1").unwrap());
+        let mut decoder = Decoder::init(from_str("3.1").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 3.1);
 
-        let mut decoder = Decoder(from_str("-1.2").unwrap());
+        let mut decoder = Decoder::init(from_str("-1.2").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, -1.2);
 
-        let mut decoder = Decoder(from_str("0.4").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4);
 
-        let mut decoder = Decoder(from_str("0.4e5").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4e5").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4e5);
 
-        let mut decoder = Decoder(from_str("0.4e15").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4e15").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4e15);
 
-        let mut decoder = Decoder(from_str("0.4e-01").unwrap());
+        let mut decoder = Decoder::init(from_str("0.4e-01").unwrap());
         let v: f64 = Decodable::decode(&mut decoder);
         assert_eq!(v, 0.4e-01);
     }
@@ -1720,39 +1728,39 @@ fn test_read_str() {
 
     #[test]
     fn test_decode_str() {
-        let mut decoder = Decoder(from_str("\"\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"");
 
-        let mut decoder = Decoder(from_str("\"foo\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"foo\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"foo");
 
-        let mut decoder = Decoder(from_str("\"\\\"\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\\"\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\"");
 
-        let mut decoder = Decoder(from_str("\"\\b\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\b\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\x08");
 
-        let mut decoder = Decoder(from_str("\"\\n\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\n\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\n");
 
-        let mut decoder = Decoder(from_str("\"\\r\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\r\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\r");
 
-        let mut decoder = Decoder(from_str("\"\\t\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\t\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\t");
 
-        let mut decoder = Decoder(from_str("\"\\u12ab\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\u12ab\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\u12ab");
 
-        let mut decoder = Decoder(from_str("\"\\uAB12\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"\\uAB12\"").unwrap());
         let v: ~str = Decodable::decode(&mut decoder);
         assert_eq!(v, ~"\uAB12");
     }
@@ -1785,27 +1793,27 @@ fn test_read_list() {
 
     #[test]
     fn test_decode_list() {
-        let mut decoder = Decoder(from_str("[]").unwrap());
+        let mut decoder = Decoder::init(from_str("[]").unwrap());
         let v: ~[()] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[]);
 
-        let mut decoder = Decoder(from_str("[null]").unwrap());
+        let mut decoder = Decoder::init(from_str("[null]").unwrap());
         let v: ~[()] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[()]);
 
-        let mut decoder = Decoder(from_str("[true]").unwrap());
+        let mut decoder = Decoder::init(from_str("[true]").unwrap());
         let v: ~[bool] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[true]);
 
-        let mut decoder = Decoder(from_str("[true]").unwrap());
+        let mut decoder = Decoder::init(from_str("[true]").unwrap());
         let v: ~[bool] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[true]);
 
-        let mut decoder = Decoder(from_str("[3, 1]").unwrap());
+        let mut decoder = Decoder::init(from_str("[3, 1]").unwrap());
         let v: ~[int] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[3, 1]);
 
-        let mut decoder = Decoder(from_str("[[3], [1, 2]]").unwrap());
+        let mut decoder = Decoder::init(from_str("[[3], [1, 2]]").unwrap());
         let v: ~[~[uint]] = Decodable::decode(&mut decoder);
         assert_eq!(v, ~[~[3], ~[1, 2]]);
     }
@@ -1907,7 +1915,7 @@ fn test_decode_struct() {
                 { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
             ]
         }";
-        let mut decoder = Decoder(from_str(s).unwrap());
+        let mut decoder = Decoder::init(from_str(s).unwrap());
         let v: Outer = Decodable::decode(&mut decoder);
         assert_eq!(
             v,
@@ -1921,23 +1929,23 @@ fn test_decode_struct() {
 
     #[test]
     fn test_decode_option() {
-        let mut decoder = Decoder(from_str("null").unwrap());
+        let mut decoder = Decoder::init(from_str("null").unwrap());
         let value: Option<~str> = Decodable::decode(&mut decoder);
         assert_eq!(value, None);
 
-        let mut decoder = Decoder(from_str("\"jodhpurs\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"jodhpurs\"").unwrap());
         let value: Option<~str> = Decodable::decode(&mut decoder);
         assert_eq!(value, Some(~"jodhpurs"));
     }
 
     #[test]
     fn test_decode_enum() {
-        let mut decoder = Decoder(from_str("\"Dog\"").unwrap());
+        let mut decoder = Decoder::init(from_str("\"Dog\"").unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Dog);
 
-        let mut decoder =
-            Decoder(from_str("{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}").unwrap());
+        let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
+        let mut decoder = Decoder::init(from_str(s).unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Frog(~"Henry", 349));
     }
@@ -1945,7 +1953,7 @@ fn test_decode_enum() {
     #[test]
     fn test_decode_map() {
         let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
-        let mut decoder = Decoder(from_str(s).unwrap());
+        let mut decoder = Decoder::init(from_str(s).unwrap());
         let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
 
         assert_eq!(map.pop(&~"a"), Some(Dog));
@@ -1982,7 +1990,7 @@ fn check_err<T: Decodable<Decoder>>(to_parse: &'static str, expected_error: &str
             match from_str(to_parse) {
                 Err(e) => Some(e.to_str()),
                 Ok(json) => {
-                    let _: T = Decodable::decode(&mut Decoder(json));
+                    let _: T = Decodable::decode(&mut Decoder::init(json));
                     None
                 }
             }

diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index c16d4aa3e16869da21a6663eae713f6b283fca14..ba9478e4448f2cccdebb176a7fce0dfd70afdf5f 100644 (file)
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -946,7 +946,7 @@ pub fn new() -> MetricMap {
     pub fn load(p: &Path) -> MetricMap {
         assert!(p.exists());
         let f = @mut File::open(p) as @mut io::Reader;
-        let mut decoder = json::Decoder(json::from_reader(f).unwrap());
+        let mut decoder = json::Decoder::init(json::from_reader(f).unwrap());
         MetricMap(Decodable::decode(&mut decoder))
     }
 

diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs
index beb211339083dcce2bd8560a334b06f2f6ef36be..27a0f51559778c0c771fecd98432a6c38f9868fa 100644 (file)
--- a/src/libextra/workcache.rs
+++ b/src/libextra/workcache.rs
@@ -191,7 +191,7 @@ fn load(&mut self) {
                     Err(e) => fail!("Couldn't parse workcache database (from file {}): {}",
                                     self.db_filename.display(), e.to_str()),
                     Ok(r) => {
-                        let mut decoder = json::Decoder(r);
+                        let mut decoder = json::Decoder::init(r);
                         self.db_cache = Decodable::decode(&mut decoder);
                     }
             }
@@ -258,7 +258,7 @@ enum Work<'self, T> {
 
 fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
     let writer = @mut MemWriter::new();
-    let mut encoder = json::Encoder(writer as @mut io::Writer);
+    let mut encoder = json::Encoder::init(writer as @mut io::Writer);
     t.encode(&mut encoder);
     str::from_utf8(writer.inner_ref().as_slice())
 }
@@ -267,7 +267,7 @@ fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
 fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
     debug!("json decoding: {}", s);
     let j = json::from_str(s).unwrap();
-    let mut decoder = json::Decoder(j);
+    let mut decoder = json::Decoder::init(j);
     Decodable::decode(&mut decoder)
 }
 

diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index c5b2125c163c453c9d16d4b2067fcc83c5ac6d76..5edafa1b1f69b0932f7fd4403cab1f8125a9d88e 100644 (file)
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -283,7 +283,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
             }
             let crate = match obj.pop(&~"crate") {
                 Some(json) => {
-                    let mut d = json::Decoder(json);
+                    let mut d = json::Decoder::init(json);
                     Decodable::decode(&mut d)
                 }
                 None => return Err(~"malformed json"),
@@ -313,7 +313,7 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) {
     // straight to the Rust JSON representation.
     let crate_json_str = {
         let w = @mut MemWriter::new();
-        crate.encode(&mut json::Encoder(w as @mut io::Writer));
+        crate.encode(&mut json::Encoder::init(w as @mut io::Writer));
         str::from_utf8(*w.inner_ref())
     };
     let crate_json = match json::from_str(crate_json_str) {

diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 8fbd152543dd9f4919d56d4b71e3bab2073a8faa..c932c188279dd6b99237ed61f48db531c535b019 100644 (file)
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -343,7 +343,7 @@ mod test {
 
     #[cfg(test)] fn to_json_str<E : Encodable<extra::json::Encoder>>(val: @E) -> ~str {
         let writer = @mut MemWriter::new();
-        let mut encoder = extra::json::Encoder(writer as @mut io::Writer);
+        let mut encoder = extra::json::Encoder::init(writer as @mut io::Writer);
         val.encode(&mut encoder);
         str::from_utf8(*writer.inner_ref())
     }

diff --git a/src/test/run-pass/issue-4016.rs b/src/test/run-pass/issue-4016.rs
index c4178961d9e6946577d558a0018cdf8df04ca640..578d210a6fc3f179f9e4d780f1d7f3994a197175 100644 (file)
--- a/src/test/run-pass/issue-4016.rs
+++ b/src/test/run-pass/issue-4016.rs
@@ -18,7 +18,7 @@ trait JD : Decodable<json::Decoder> { }
 
 fn exec<T: JD>() {
     let doc = json::from_str("").unwrap();
-    let mut decoder = json::Decoder(doc);
+    let mut decoder = json::Decoder::init(doc);
     let _v: T = Decodable::decode(&mut decoder);
     fail!()
 }

diff --git a/src/test/run-pass/issue-4036.rs b/src/test/run-pass/issue-4036.rs
index ad82071259593e8b4025a816f4d5f0b2bab81096..bd3ca844263510ce261b9f7f1e68abd68d9a7104 100644 (file)
--- a/src/test/run-pass/issue-4036.rs
+++ b/src/test/run-pass/issue-4036.rs
@@ -17,6 +17,6 @@
 
 pub fn main() {
     let json = json::from_str("[1]").unwrap();
-    let mut decoder = json::Decoder(json);
+    let mut decoder = json::Decoder::init(json);
     let _x: ~[int] = serialize::Decodable::decode(&mut decoder);
 }