Skip to content

Commit d9f3133

Browse files
SimonSapinSimonSapin
committed
Replace Atom::from_slice with From trait impls.
1 parent de5ea4d commit d9f3133

File tree

3 files changed

+59
-57
lines changed

3 files changed

+59
-57
lines changed

‎src/atom/bench.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ use test::{Bencher, black_box};
3232

3333
// Just shorthand
3434
fn mk(x: &str) -> Atom {
35-
Atom::from_slice(x)
35+
Atom::from(x)
3636
}
3737

3838
macro_rules! check_type (($name:ident, $x:expr, $p:pat) => (
@@ -81,7 +81,7 @@ macro_rules! bench_one (
8181
fn intern(b: &mut Bencher) {
8282
let x = $x.to_string();
8383
b.iter(|| {
84-
black_box(Atom::from_slice(&x));
84+
black_box(Atom::from(&*x));
8585
});
8686
}
8787
);
@@ -205,7 +205,7 @@ macro_rules! bench_rand ( ($name:ident, $len:expr) => (
205205
*n = (*n % 0x40) + 0x20;
206206
}
207207
let s = str::from_utf8(&buf[..]).unwrap();
208-
black_box(Atom::from_slice(s));
208+
black_box(Atom::from(s));
209209
});
210210
}
211211
));

‎src/atom/mod.rs

+42-40
Original file line numberDiff line numberDiff line change
@@ -140,9 +140,11 @@ impl Atom {
140140
unsafe fn unpack(&self) -> UnpackedAtom {
141141
UnpackedAtom::from_packed(self.data)
142142
}
143+
}
143144

145+
impl<'a> From<&'a str> for Atom {
144146
#[inline]
145-
pub fn from_slice(string_to_add: &str) -> Atom {
147+
fn from(string_to_add: &str) -> Atom {
146148
let unpacked = match STATIC_ATOM_SET.get_index_or_hash(string_to_add) {
147149
Ok(id) => Static(id as u32),
148150
Err(hash) => {
@@ -283,7 +285,7 @@ impl Serialize for Atom {
283285
impl Deserialize for Atom {
284286
fn deserialize<D>(deserializer: &mut D) -> Result<Atom,D::Error> where D: Deserializer {
285287
let string: String = try!(Deserialize::deserialize(deserializer));
286-
Ok(Atom::from_slice(&*string))
288+
Ok(Atom::from(&*string))
287289
}
288290
}
289291

@@ -299,27 +301,27 @@ mod tests {
299301

300302
#[test]
301303
fn test_as_slice() {
302-
let s0 = Atom::from_slice("");
304+
let s0 = Atom::from("");
303305
assert!(s0.as_ref() == "");
304306

305-
let s1 = Atom::from_slice("class");
307+
let s1 = Atom::from("class");
306308
assert!(s1.as_ref() == "class");
307309

308-
let i0 = Atom::from_slice("blah");
310+
let i0 = Atom::from("blah");
309311
assert!(i0.as_ref() == "blah");
310312

311-
let s0 = Atom::from_slice("BLAH");
313+
let s0 = Atom::from("BLAH");
312314
assert!(s0.as_ref() == "BLAH");
313315

314-
let d0 = Atom::from_slice("zzzzzzzzzz");
316+
let d0 = Atom::from("zzzzzzzzzz");
315317
assert!(d0.as_ref() == "zzzzzzzzzz");
316318

317-
let d1 = Atom::from_slice("ZZZZZZZZZZ");
319+
let d1 = Atom::from("ZZZZZZZZZZ");
318320
assert!(d1.as_ref() == "ZZZZZZZZZZ");
319321
}
320322

321323
macro_rules! unpacks_to (($e:expr, $t:pat) => (
322-
match unsafe { Atom::from_slice($e).unpack() } {
324+
match unsafe { Atom::from($e).unpack() } {
323325
$t => (),
324326
_ => panic!("atom has wrong type"),
325327
}
@@ -343,17 +345,17 @@ mod tests {
343345

344346
#[test]
345347
fn test_equality() {
346-
let s0 = Atom::from_slice("fn");
347-
let s1 = Atom::from_slice("fn");
348-
let s2 = Atom::from_slice("loop");
348+
let s0 = Atom::from("fn");
349+
let s1 = Atom::from("fn");
350+
let s2 = Atom::from("loop");
349351

350-
let i0 = Atom::from_slice("blah");
351-
let i1 = Atom::from_slice("blah");
352-
let i2 = Atom::from_slice("blah2");
352+
let i0 = Atom::from("blah");
353+
let i1 = Atom::from("blah");
354+
let i2 = Atom::from("blah2");
353355

354-
let d0 = Atom::from_slice("zzzzzzzz");
355-
let d1 = Atom::from_slice("zzzzzzzz");
356-
let d2 = Atom::from_slice("zzzzzzzzz");
356+
let d0 = Atom::from("zzzzzzzz");
357+
let d1 = Atom::from("zzzzzzzz");
358+
let d2 = Atom::from("zzzzzzzzz");
357359

358360
assert!(s0 == s1);
359361
assert!(s0 != s2);
@@ -372,9 +374,9 @@ mod tests {
372374
#[test]
373375
fn ord() {
374376
fn check(x: &str, y: &str) {
375-
assert_eq!(x < y, Atom::from_slice(x) < Atom::from_slice(y));
376-
assert_eq!(x.cmp(y), Atom::from_slice(x).cmp(&Atom::from_slice(y)));
377-
assert_eq!(x.partial_cmp(y), Atom::from_slice(x).partial_cmp(&Atom::from_slice(y)));
377+
assert_eq!(x < y, Atom::from(x) < Atom::from(y));
378+
assert_eq!(x.cmp(y), Atom::from(x).cmp(&Atom::from(y)));
379+
assert_eq!(x.partial_cmp(y), Atom::from(x).partial_cmp(&Atom::from(y)));
378380
}
379381

380382
check("a", "body");
@@ -390,17 +392,17 @@ mod tests {
390392

391393
#[test]
392394
fn clone() {
393-
let s0 = Atom::from_slice("fn");
395+
let s0 = Atom::from("fn");
394396
let s1 = s0.clone();
395-
let s2 = Atom::from_slice("loop");
397+
let s2 = Atom::from("loop");
396398

397-
let i0 = Atom::from_slice("blah");
399+
let i0 = Atom::from("blah");
398400
let i1 = i0.clone();
399-
let i2 = Atom::from_slice("blah2");
401+
let i2 = Atom::from("blah2");
400402

401-
let d0 = Atom::from_slice("zzzzzzzz");
403+
let d0 = Atom::from("zzzzzzzz");
402404
let d1 = d0.clone();
403-
let d2 = Atom::from_slice("zzzzzzzzz");
405+
let d2 = Atom::from("zzzzzzzzz");
404406

405407
assert!(s0 == s1);
406408
assert!(s0 != s2);
@@ -429,12 +431,12 @@ mod tests {
429431
#[test]
430432
fn repr() {
431433
fn check(s: &str, data: u64) {
432-
assert_eq_fmt!("0x{:016X}", Atom::from_slice(s).data, data);
434+
assert_eq_fmt!("0x{:016X}", Atom::from(s).data, data);
433435
}
434436

435437
fn check_static(s: &str, x: Atom) {
436438
use string_cache_shared::STATIC_ATOM_SET;
437-
assert_eq_fmt!("0x{:016X}", x.data, Atom::from_slice(s).data);
439+
assert_eq_fmt!("0x{:016X}", x.data, Atom::from(s).data);
438440
assert_eq!(0x2, x.data & 0xFFFF_FFFF);
439441
// The index is unspecified by phf.
440442
assert!((x.data >> 32) <= STATIC_ATOM_SET.iter().len() as u64);
@@ -455,7 +457,7 @@ mod tests {
455457
check("xyzzy01", 0x3130_797A_7A79_7871);
456458

457459
// Dynamic atoms. This is a pointer so we can't verify every bit.
458-
assert_eq!(0x00, Atom::from_slice("a dynamic string").data & 0xf);
460+
assert_eq!(0x00, Atom::from("a dynamic string").data & 0xf);
459461
}
460462

461463
#[test]
@@ -470,34 +472,34 @@ mod tests {
470472
fn test_threads() {
471473
for _ in 0_u32..100 {
472474
thread::spawn(move || {
473-
let _ = Atom::from_slice("a dynamic string");
474-
let _ = Atom::from_slice("another string");
475+
let _ = Atom::from("a dynamic string");
476+
let _ = Atom::from("another string");
475477
});
476478
}
477479
}
478480

479481
#[test]
480482
fn atom_macro() {
481-
assert_eq!(atom!(body), Atom::from_slice("body"));
482-
assert_eq!(atom!("body"), Atom::from_slice("body"));
483-
assert_eq!(atom!("font-weight"), Atom::from_slice("font-weight"));
483+
assert_eq!(atom!(body), Atom::from("body"));
484+
assert_eq!(atom!("body"), Atom::from("body"));
485+
assert_eq!(atom!("font-weight"), Atom::from("font-weight"));
484486
}
485487

486488
#[test]
487489
fn match_atom() {
488-
assert_eq!(2, match Atom::from_slice("head") {
490+
assert_eq!(2, match Atom::from("head") {
489491
atom!(br) => 1,
490492
atom!(html) | atom!(head) => 2,
491493
_ => 3,
492494
});
493495

494-
assert_eq!(3, match Atom::from_slice("body") {
496+
assert_eq!(3, match Atom::from("body") {
495497
atom!(br) => 1,
496498
atom!(html) | atom!(head) => 2,
497499
_ => 3,
498500
});
499501

500-
assert_eq!(3, match Atom::from_slice("zzzzzz") {
502+
assert_eq!(3, match Atom::from("zzzzzz") {
501503
atom!(br) => 1,
502504
atom!(html) | atom!(head) => 2,
503505
_ => 3,
@@ -507,14 +509,14 @@ mod tests {
507509
#[test]
508510
fn ensure_deref() {
509511
// Ensure we can Deref to a &str
510-
let atom = Atom::from_slice("foobar");
512+
let atom = Atom::from("foobar");
511513
let _: &str = &atom;
512514
}
513515

514516
#[test]
515517
fn ensure_as_ref() {
516518
// Ensure we can as_ref to a &str
517-
let atom = Atom::from_slice("foobar");
519+
let atom = Atom::from("foobar");
518520
let _: &str = atom.as_ref();
519521
}
520522

‎src/namespace.rs

+14-14
Original file line numberDiff line numberDiff line change
@@ -42,27 +42,27 @@ mod tests {
4242

4343
#[test]
4444
fn ns_macro() {
45-
assert_eq!(ns!(""), Namespace(Atom::from_slice("")));
45+
assert_eq!(ns!(""), Namespace(Atom::from("")));
4646

47-
assert_eq!(ns!(html), Namespace(Atom::from_slice("http://www.w3.org/1999/xhtml")));
48-
assert_eq!(ns!(xml), Namespace(Atom::from_slice("http://www.w3.org/XML/1998/namespace")));
49-
assert_eq!(ns!(xmlns), Namespace(Atom::from_slice("http://www.w3.org/2000/xmlns/")));
50-
assert_eq!(ns!(xlink), Namespace(Atom::from_slice("http://www.w3.org/1999/xlink")));
51-
assert_eq!(ns!(svg), Namespace(Atom::from_slice("http://www.w3.org/2000/svg")));
52-
assert_eq!(ns!(mathml), Namespace(Atom::from_slice("http://www.w3.org/1998/Math/MathML")));
47+
assert_eq!(ns!(html), Namespace(Atom::from("http://www.w3.org/1999/xhtml")));
48+
assert_eq!(ns!(xml), Namespace(Atom::from("http://www.w3.org/XML/1998/namespace")));
49+
assert_eq!(ns!(xmlns), Namespace(Atom::from("http://www.w3.org/2000/xmlns/")));
50+
assert_eq!(ns!(xlink), Namespace(Atom::from("http://www.w3.org/1999/xlink")));
51+
assert_eq!(ns!(svg), Namespace(Atom::from("http://www.w3.org/2000/svg")));
52+
assert_eq!(ns!(mathml), Namespace(Atom::from("http://www.w3.org/1998/Math/MathML")));
5353

54-
assert_eq!(ns!(HtMl), Namespace(Atom::from_slice("http://www.w3.org/1999/xhtml")));
55-
assert_eq!(ns!(xMl), Namespace(Atom::from_slice("http://www.w3.org/XML/1998/namespace")));
56-
assert_eq!(ns!(XmLnS), Namespace(Atom::from_slice("http://www.w3.org/2000/xmlns/")));
57-
assert_eq!(ns!(xLiNk), Namespace(Atom::from_slice("http://www.w3.org/1999/xlink")));
58-
assert_eq!(ns!(SvG), Namespace(Atom::from_slice("http://www.w3.org/2000/svg")));
59-
assert_eq!(ns!(mAtHmL), Namespace(Atom::from_slice("http://www.w3.org/1998/Math/MathML")));
54+
assert_eq!(ns!(HtMl), Namespace(Atom::from("http://www.w3.org/1999/xhtml")));
55+
assert_eq!(ns!(xMl), Namespace(Atom::from("http://www.w3.org/XML/1998/namespace")));
56+
assert_eq!(ns!(XmLnS), Namespace(Atom::from("http://www.w3.org/2000/xmlns/")));
57+
assert_eq!(ns!(xLiNk), Namespace(Atom::from("http://www.w3.org/1999/xlink")));
58+
assert_eq!(ns!(SvG), Namespace(Atom::from("http://www.w3.org/2000/svg")));
59+
assert_eq!(ns!(mAtHmL), Namespace(Atom::from("http://www.w3.org/1998/Math/MathML")));
6060
}
6161

6262
#[test]
6363
fn qualname() {
6464
assert_eq!(QualName::new(ns!(""), atom!("")),
65-
QualName { ns: ns!(""), local: Atom::from_slice("") });
65+
QualName { ns: ns!(""), local: Atom::from("") });
6666
assert_eq!(QualName::new(ns!(XML), atom!(base)),
6767
QualName { ns: ns!(XML), local: atom!(base) });
6868
}

0 commit comments

Comments
 (0)