Remove Atom::as_slice in favor of Deref and AsRef

SimonSapin · SimonSapin · commit de5ea4deeedc · 2015-11-19T20:23:46.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 
 name = "string_cache"
-version = "0.1.17"
+version = "0.2.0"
 authors = [ "The Servo Project Developers" ]
 description = "A string interning library for Rust, developed as part of the Servo project."
 license = "MIT / Apache-2.0"
diff --git a/examples/summarize-events/src/main.rs b/examples/summarize-events/src/main.rs
@@ -84,7 +84,7 @@ fn main() {
 
                     // FIXME: We really shouldn't be allowed to do this. It's a memory-safety
                     // hazard; the field is only public for the atom!() macro.
-                    _ => Atom { data: ev.id }.as_slice().to_string(),
+                    _ => Atom { data: ev.id }.to_string(),
                 };
 
                 match summary.entry(string) {
diff --git a/src/atom/bench.rs b/src/atom/bench.rs
@@ -79,20 +79,20 @@ macro_rules! bench_one (
     (intern $x:expr, $_y:expr) => (
         #[bench]
         fn intern(b: &mut Bencher) {
-            let x = $x.as_slice().to_string();
+            let x = $x.to_string();
             b.iter(|| {
                 black_box(Atom::from_slice(&x));
             });
         }
     );
 
-    (as_slice $x:expr, $_y:expr) => (
+    (as_ref $x:expr, $_y:expr) => (
         #[bench]
-        fn as_slice_x_1000(b: &mut Bencher) {
+        fn as_ref_x_1000(b: &mut Bencher) {
             let x = $x;
             b.iter(|| {
                 for _ in 0..1000 {
-                    black_box(x.as_slice());
+                    black_box(x.as_ref());
                 }
             });
         }
@@ -156,22 +156,22 @@ bench_all!([eq ne lt clone_string] for medium_string = "xyzzy01", "xyzzy02");
 bench_all!([eq ne lt clone_string]
     for longer_string = super::longer_dynamic_a, super::longer_dynamic_b);
 
-bench_all!([eq ne intern as_slice clone is_static lt]
+bench_all!([eq ne intern as_ref clone is_static lt]
     for static_atom = atom!(a), atom!(b));
 
-bench_all!([intern as_slice clone is_inline]
+bench_all!([intern as_ref clone is_inline]
     for short_inline_atom = mk("e"), mk("f"));
 
-bench_all!([eq ne intern as_slice clone is_inline lt]
+bench_all!([eq ne intern as_ref clone is_inline lt]
     for medium_inline_atom = mk("xyzzy01"), mk("xyzzy02"));
 
-bench_all!([intern as_slice clone is_dynamic]
+bench_all!([intern as_ref clone is_dynamic]
     for min_dynamic_atom = mk("xyzzy001"), mk("xyzzy002"));
 
-bench_all!([eq ne intern as_slice clone is_dynamic lt]
+bench_all!([eq ne intern as_ref clone is_dynamic lt]
     for longer_dynamic_atom = mk(super::longer_dynamic_a), mk(super::longer_dynamic_b));
 
-bench_all!([intern as_slice clone is_static]
+bench_all!([intern as_ref clone is_static]
     for static_at_runtime = mk("a"), mk("b"));
 
 bench_all!([ne lt x_static y_inline]
diff --git a/src/atom/mod.rs b/src/atom/mod.rs
@@ -161,23 +161,6 @@ impl Atom {
         log!(Event::Intern(data));
         Atom { data: data }
     }
-
-    #[inline]
-    pub fn as_slice<'t>(&'t self) -> &'t str {
-        unsafe {
-            match self.unpack() {
-                Inline(..) => {
-                    let buf = string_cache_shared::inline_orig_bytes(&self.data);
-                    str::from_utf8(buf).unwrap()
-                },
-                Static(idx) => STATIC_ATOM_SET.index(idx).expect("bad static atom"),
-                Dynamic(entry) => {
-                    let entry = entry as *mut StringCacheEntry;
-                    &(*entry).string
-                }
-            }
-        }
-    }
 }
 
 impl Clone for Atom {
@@ -226,7 +209,19 @@ impl ops::Deref for Atom {
 
     #[inline]
     fn deref(&self) -> &str {
-        self.as_slice()
+        unsafe {
+            match self.unpack() {
+                Inline(..) => {
+                    let buf = string_cache_shared::inline_orig_bytes(&self.data);
+                    str::from_utf8(buf).unwrap()
+                },
+                Static(idx) => STATIC_ATOM_SET.index(idx).expect("bad static atom"),
+                Dynamic(entry) => {
+                    let entry = entry as *mut StringCacheEntry;
+                    &(*entry).string
+                }
+            }
+        }
     }
 }
 
@@ -248,7 +243,7 @@ impl fmt::Debug for Atom {
             }
         };
 
-        write!(f, "Atom('{}' type={})", self.as_slice(), ty_str)
+        write!(f, "Atom('{}' type={})", &*self, ty_str)
     }
 }
 
@@ -258,7 +253,7 @@ impl PartialOrd for Atom {
         if self.data == other.data {
             return Some(Equal);
         }
-        self.as_slice().partial_cmp(other.as_slice())
+        self.as_ref().partial_cmp(other.as_ref())
     }
 }
 
@@ -268,7 +263,7 @@ impl Ord for Atom {
         if self.data == other.data {
             return Equal;
         }
-        self.as_slice().cmp(other.as_slice())
+        self.as_ref().cmp(other.as_ref())
     }
 }
 
@@ -305,22 +300,22 @@ mod tests {
     #[test]
     fn test_as_slice() {
         let s0 = Atom::from_slice("");
-        assert!(s0.as_slice() == "");
+        assert!(s0.as_ref() == "");
 
         let s1 = Atom::from_slice("class");
-        assert!(s1.as_slice() == "class");
+        assert!(s1.as_ref() == "class");
 
         let i0 = Atom::from_slice("blah");
-        assert!(i0.as_slice() == "blah");
+        assert!(i0.as_ref() == "blah");
 
         let s0 = Atom::from_slice("BLAH");
-        assert!(s0.as_slice() == "BLAH");
+        assert!(s0.as_ref() == "BLAH");
 
         let d0 = Atom::from_slice("zzzzzzzzzz");
-        assert!(d0.as_slice() == "zzzzzzzzzz");
+        assert!(d0.as_ref() == "zzzzzzzzzz");
 
         let d1 = Atom::from_slice("ZZZZZZZZZZ");
-        assert!(d1.as_slice() == "ZZZZZZZZZZ");
+        assert!(d1.as_ref() == "ZZZZZZZZZZ");
     }
 
     macro_rules! unpacks_to (($e:expr, $t:pat) => (
