Add an SendStr type

A SendStr is a string that can hold either a ~str or a &'static str.
This can be useful as an optimization when an allocation is sometimes needed but the common case is statically known.

Possible use cases include Maps with both static and owned keys, or propagating error messages across task boundaries.

SendStr implements most basic traits in a way that hides the fact that it is an enum; in particular things like order and equality are only determined by the content of the wrapped strings.

Replaced std::rt:logging::SendableString with SendStr
Added tests for using an SendStr as key in Hash- and Treemaps

2 files changed, 153 insertions, 0 deletions

diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs
new file mode 100644
index 00000000000..a33cb99682b
--- /dev/null
+++ b/src/test/run-pass/send_str_hashmap.rs
@@ -0,0 +1,80 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::clone::{Clone, DeepClone};
+use std::cmp::{TotalEq, Ord, TotalOrd, Equiv};
+use std::cmp::Equal;
+use std::container::{Container, Map, MutableMap};
+use std::default::Default;
+use std::send_str::{SendStr, SendStrOwned, SendStrStatic};
+use std::str::Str;
+use std::to_str::ToStr;
+use std::hashmap::HashMap;
+use std::option::Some;
+
+fn main() {
+    let mut map: HashMap<SendStr, uint> = HashMap::new();
+    assert!(map.insert(SendStrStatic("foo"), 42));
+    assert!(!map.insert(SendStrOwned(~"foo"), 42));
+    assert!(!map.insert(SendStrStatic("foo"), 42));
+    assert!(!map.insert(SendStrOwned(~"foo"), 42));
+
+    assert!(!map.insert(SendStrStatic("foo"), 43));
+    assert!(!map.insert(SendStrOwned(~"foo"), 44));
+    assert!(!map.insert(SendStrStatic("foo"), 45));
+    assert!(!map.insert(SendStrOwned(~"foo"), 46));
+
+    let v = 46;
+
+    assert_eq!(map.find(&SendStrOwned(~"foo")), Some(&v));
+    assert_eq!(map.find(&SendStrStatic("foo")), Some(&v));
+
+    let (a, b, c, d) = (50, 51, 52, 53);
+
+    assert!(map.insert(SendStrStatic("abc"), a));
+    assert!(map.insert(SendStrOwned(~"bcd"), b));
+    assert!(map.insert(SendStrStatic("cde"), c));
+    assert!(map.insert(SendStrOwned(~"def"), d));
+
+    assert!(!map.insert(SendStrStatic("abc"), a));
+    assert!(!map.insert(SendStrOwned(~"bcd"), b));
+    assert!(!map.insert(SendStrStatic("cde"), c));
+    assert!(!map.insert(SendStrOwned(~"def"), d));
+
+    assert!(!map.insert(SendStrOwned(~"abc"), a));
+    assert!(!map.insert(SendStrStatic("bcd"), b));
+    assert!(!map.insert(SendStrOwned(~"cde"), c));
+    assert!(!map.insert(SendStrStatic("def"), d));
+
+    assert_eq!(map.find_equiv(&("abc")), Some(&a));
+    assert_eq!(map.find_equiv(&("bcd")), Some(&b));
+    assert_eq!(map.find_equiv(&("cde")), Some(&c));
+    assert_eq!(map.find_equiv(&("def")), Some(&d));
+
+    assert_eq!(map.find_equiv(&(~"abc")), Some(&a));
+    assert_eq!(map.find_equiv(&(~"bcd")), Some(&b));
+    assert_eq!(map.find_equiv(&(~"cde")), Some(&c));
+    assert_eq!(map.find_equiv(&(~"def")), Some(&d));
+
+    assert_eq!(map.find_equiv(&(@"abc")), Some(&a));
+    assert_eq!(map.find_equiv(&(@"bcd")), Some(&b));
+    assert_eq!(map.find_equiv(&(@"cde")), Some(&c));
+    assert_eq!(map.find_equiv(&(@"def")), Some(&d));
+
+    assert_eq!(map.find_equiv(&SendStrStatic("abc")), Some(&a));
+    assert_eq!(map.find_equiv(&SendStrStatic("bcd")), Some(&b));
+    assert_eq!(map.find_equiv(&SendStrStatic("cde")), Some(&c));
+    assert_eq!(map.find_equiv(&SendStrStatic("def")), Some(&d));
+
+    assert_eq!(map.find_equiv(&SendStrOwned(~"abc")), Some(&a));
+    assert_eq!(map.find_equiv(&SendStrOwned(~"bcd")), Some(&b));
+    assert_eq!(map.find_equiv(&SendStrOwned(~"cde")), Some(&c));
+    assert_eq!(map.find_equiv(&SendStrOwned(~"def")), Some(&d));
+}
diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs
new file mode 100644
index 00000000000..d3af1360b4b
--- /dev/null
+++ b/src/test/run-pass/send_str_treemap.rs
@@ -0,0 +1,73 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern mod extra;
+
+use std::clone::{Clone, DeepClone};
+use std::cmp::{TotalEq, Ord, TotalOrd, Equiv};
+use std::cmp::Equal;
+use std::container::{Container, Map, MutableMap};
+use std::default::Default;
+use std::send_str::{SendStr, SendStrOwned, SendStrStatic};
+use std::str::Str;
+use std::to_str::ToStr;
+use extra::treemap::TreeMap;
+use std::option::Some;
+
+fn main() {
+    let mut map: TreeMap<SendStr, uint> = TreeMap::new();
+    assert!(map.insert(SendStrStatic("foo"), 42));
+    assert!(!map.insert(SendStrOwned(~"foo"), 42));
+    assert!(!map.insert(SendStrStatic("foo"), 42));
+    assert!(!map.insert(SendStrOwned(~"foo"), 42));
+
+    assert!(!map.insert(SendStrStatic("foo"), 43));
+    assert!(!map.insert(SendStrOwned(~"foo"), 44));
+    assert!(!map.insert(SendStrStatic("foo"), 45));
+    assert!(!map.insert(SendStrOwned(~"foo"), 46));
+
+    let v = 46;
+
+    assert_eq!(map.find(&SendStrOwned(~"foo")), Some(&v));
+    assert_eq!(map.find(&SendStrStatic("foo")), Some(&v));
+
+    let (a, b, c, d) = (50, 51, 52, 53);
+
+    assert!(map.insert(SendStrStatic("abc"), a));
+    assert!(map.insert(SendStrOwned(~"bcd"), b));
+    assert!(map.insert(SendStrStatic("cde"), c));
+    assert!(map.insert(SendStrOwned(~"def"), d));
+
+    assert!(!map.insert(SendStrStatic("abc"), a));
+    assert!(!map.insert(SendStrOwned(~"bcd"), b));
+    assert!(!map.insert(SendStrStatic("cde"), c));
+    assert!(!map.insert(SendStrOwned(~"def"), d));
+
+    assert!(!map.insert(SendStrOwned(~"abc"), a));
+    assert!(!map.insert(SendStrStatic("bcd"), b));
+    assert!(!map.insert(SendStrOwned(~"cde"), c));
+    assert!(!map.insert(SendStrStatic("def"), d));
+
+    assert_eq!(map.find(&SendStrStatic("abc")), Some(&a));
+    assert_eq!(map.find(&SendStrStatic("bcd")), Some(&b));
+    assert_eq!(map.find(&SendStrStatic("cde")), Some(&c));
+    assert_eq!(map.find(&SendStrStatic("def")), Some(&d));
+
+    assert_eq!(map.find(&SendStrOwned(~"abc")), Some(&a));
+    assert_eq!(map.find(&SendStrOwned(~"bcd")), Some(&b));
+    assert_eq!(map.find(&SendStrOwned(~"cde")), Some(&c));
+    assert_eq!(map.find(&SendStrOwned(~"def")), Some(&d));
+
+    assert!(map.pop(&SendStrStatic("foo")).is_some());
+    assert_eq!(map.move_iter().map(|(k, v)| k.to_str() + v.to_str())
+                              .to_owned_vec()
+                              .concat(),
+               ~"abc50bcd51cde52def53");
+}