---

yaml
---
r: 80859
b: refs/heads/try
c: 9ea295b
h: refs/heads/master
i:
  80857: 1325805
  80855: ea769d7
v: v3

Author: emberian

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 6bc48b63f376439801d43820f6df0990797b8787
+refs/heads/try: 9ea295b7df26c954cbb4f5f3c0dc669b14a2389d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/json.rs

@@ -135,18 +135,21 @@ impl serialize::Encoder for Encoder {
                          _id: uint,
                          cnt: uint,
                          f: &fn(&mut Encoder)) {
-        // enums are encoded as strings or vectors:
+        // enums are encoded as strings or objects
         // Bunny => "Bunny"
-        // Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
-
+        // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
         if cnt == 0 {
             self.wr.write_str(escape_str(name));
         } else {
-            self.wr.write_char('[');
+            self.wr.write_char('{');
+            self.wr.write_str("\"variant\"");
+            self.wr.write_char(':');
             self.wr.write_str(escape_str(name));
             self.wr.write_char(',');
+            self.wr.write_str("\"fields\"");
+            self.wr.write_str(":[");
             f(self);
-            self.wr.write_char(']');
+            self.wr.write_str("]}");
         }
     }
 
@@ -947,14 +950,20 @@ impl serialize::Decoder for Decoder {
         debug!("read_enum_variant(names=%?)", names);
         let name = match self.stack.pop() {
             String(s) => s,
-            List(list) => {
-                for v in list.move_rev_iter() {
-                    self.stack.push(v);
-                }
-                match self.stack.pop() {
-                    String(s) => s,
-                    value => fail!("invalid variant name: %?", value),
+            Object(o) => {
+                let n = match o.find(&~"variant").expect("invalidly encoded json") {
+                    &String(ref s) => s.clone(),
+                    _ => fail!("invalidly encoded json"),
+                };
+                match o.find(&~"fields").expect("invalidly encoded json") {
+                    &List(ref l) => {
+                        for field in l.rev_iter() {
+                            self.stack.push(field.clone());
+                        }
+                    },
+                    _ => fail!("invalidly encoded json")
                 }
+                n
             }
             ref json => fail!("invalid variant: %?", *json),
         };
@@ -1517,7 +1526,7 @@ mod tests {
                 let mut encoder = Encoder(wr);
                 animal.encode(&mut encoder);
             },
-            ~"[\"Frog\",\"Henry\",349]"
+            ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
         );
         assert_eq!(
             do io::with_str_writer |wr| {
@@ -1921,14 +1930,14 @@ mod tests {
         assert_eq!(value, Dog);
 
         let mut decoder =
-            Decoder(from_str("[\"Frog\",\"Henry\",349]").unwrap());
+            Decoder(from_str("{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}").unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Frog(~"Henry", 349));
     }
 
     #[test]
     fn test_decode_map() {
-        let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}";
+        let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
         let mut decoder = Decoder(from_str(s).unwrap());
         let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
 

branches/try/src/libstd/logging.rs

@@ -13,8 +13,7 @@
 use option::*;
 use os;
 use rt;
-use rt::logging::{Logger, StdErrLogger};
-use send_str::SendStrOwned;
+use rt::logging::{Logger, StdErrLogger, OwnedString};
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -57,12 +56,12 @@ fn newsched_log_str(msg: ~str) {
         match optional_task {
             Some(local) => {
                 // Use the available logger
-                (*local).logger.log(SendStrOwned(msg));
+                (*local).logger.log(OwnedString(msg));
             }
             None => {
                 // There is no logger anywhere, just write to stderr
                 let mut logger = StdErrLogger;
-                logger.log(SendStrOwned(msg));
+                logger.log(OwnedString(msg));
             }
         }
     }

branches/try/src/libstd/prelude.rs

@@ -66,7 +66,6 @@ pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::RawPtr;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, ToBytesConsume};
-pub use send_str::{SendStr, SendStrOwned, SendStrStatic, IntoSendStr};
 pub use str::{Str, StrVector, StrSlice, OwnedStr};
 pub use from_str::FromStr;
 pub use to_bytes::IterBytes;

branches/try/src/libstd/rt/logging.rs

@@ -17,7 +17,6 @@ use str::raw::from_c_str;
 use u32;
 use vec::ImmutableVector;
 use cast::transmute;
-use send_str::{SendStr, SendStrOwned, SendStrStatic};
 
 struct LogDirective {
     name: Option<~str>,
@@ -169,26 +168,32 @@ fn update_log_settings(crate_map: *u8, settings: ~str) {
     }
 }
 
+/// Represent a string with `Send` bound.
+pub enum SendableString {
+    OwnedString(~str),
+    StaticString(&'static str)
+}
+
 pub trait Logger {
-    fn log(&mut self, msg: SendStr);
+    fn log(&mut self, msg: SendableString);
 }
 
 pub struct StdErrLogger;
 
 impl Logger for StdErrLogger {
-    fn log(&mut self, msg: SendStr) {
+    fn log(&mut self, msg: SendableString) {
         use io::{Writer, WriterUtil};
 
         if !should_log_console() {
             return;
         }
 
         let s: &str = match msg {
-            SendStrOwned(ref s) => {
+            OwnedString(ref s) => {
                 let slc: &str = *s;
                 slc
             },
-            SendStrStatic(s) => s,
+            StaticString(s) => s,
         };
 
         // Truncate the string