Skip to content

Commit af8b4fc

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

File tree

3 files changed

+66
-57
lines changed

3 files changed

+66
-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

+49-40
Original file line numberDiff line numberDiff line change
@@ -140,9 +140,18 @@ impl Atom {
140140
unsafe fn unpack(&self) -> UnpackedAtom {
141141
UnpackedAtom::from_packed(self.data)
142142
}
143+
}
144+
145+
impl<'a> From<&'a String> for Atom {
146+
#[inline]
147+
fn from(s: &String) -> Atom {
148+
Atom::from(&**s)
149+
}
150+
}
143151

152+
impl<'a> From<&'a str> for Atom {
144153
#[inline]
145-
pub fn from_slice(string_to_add: &str) -> Atom {
154+
fn from(string_to_add: &str) -> Atom {
146155
let unpacked = match STATIC_ATOM_SET.get_index_or_hash(string_to_add) {
147156
Ok(id) => Static(id as u32),
148157
Err(hash) => {
@@ -283,7 +292,7 @@ impl Serialize for Atom {
283292
impl Deserialize for Atom {
284293
fn deserialize<D>(deserializer: &mut D) -> Result<Atom,D::Error> where D: Deserializer {
285294
let string: String = try!(Deserialize::deserialize(deserializer));
286-
Ok(Atom::from_slice(&*string))
295+
Ok(Atom::from(&*string))
287296
}
288297
}
289298

@@ -299,27 +308,27 @@ mod tests {
299308

300309
#[test]
301310
fn test_as_slice() {
302-
let s0 = Atom::from_slice("");
311+
let s0 = Atom::from("");
303312
assert!(s0.as_ref() == "");
304313

305-
let s1 = Atom::from_slice("class");
314+
let s1 = Atom::from("class");
306315
assert!(s1.as_ref() == "class");
307316

308-
let i0 = Atom::from_slice("blah");
317+
let i0 = Atom::from("blah");
309318
assert!(i0.as_ref() == "blah");
310319

311-
let s0 = Atom::from_slice("BLAH");
320+
let s0 = Atom::from("BLAH");
312321
assert!(s0.as_ref() == "BLAH");
313322

314-
let d0 = Atom::from_slice("zzzzzzzzzz");
323+
let d0 = Atom::from("zzzzzzzzzz");
315324
assert!(d0.as_ref() == "zzzzzzzzzz");
316325

317-
let d1 = Atom::from_slice("ZZZZZZZZZZ");
326+
let d1 = Atom::from("ZZZZZZZZZZ");
318327
assert!(d1.as_ref() == "ZZZZZZZZZZ");
319328
}
320329

321330
macro_rules! unpacks_to (($e:expr, $t:pat) => (
322-
match unsafe { Atom::from_slice($e).unpack() } {
331+
match unsafe { Atom::from($e).unpack() } {
323332
$t => (),
324333
_ => panic!("atom has wrong type"),
325334
}
@@ -343,17 +352,17 @@ mod tests {
343352

344353
#[test]
345354
fn test_equality() {
346-
let s0 = Atom::from_slice("fn");
347-
let s1 = Atom::from_slice("fn");
348-
let s2 = Atom::from_slice("loop");
355+
let s0 = Atom::from("fn");
356+
let s1 = Atom::from("fn");
357+
let s2 = Atom::from("loop");
349358

350-
let i0 = Atom::from_slice("blah");
351-
let i1 = Atom::from_slice("blah");
352-
let i2 = Atom::from_slice("blah2");
359+
let i0 = Atom::from("blah");
360+
let i1 = Atom::from("blah");
361+
let i2 = Atom::from("blah2");
353362

354-
let d0 = Atom::from_slice("zzzzzzzz");
355-
let d1 = Atom::from_slice("zzzzzzzz");
356-
let d2 = Atom::from_slice("zzzzzzzzz");
363+
let d0 = Atom::from("zzzzzzzz");
364+
let d1 = Atom::from("zzzzzzzz");
365+
let d2 = Atom::from("zzzzzzzzz");
357366

358367
assert!(s0 == s1);
359368
assert!(s0 != s2);
@@ -372,9 +381,9 @@ mod tests {
372381
#[test]
373382
fn ord() {
374383
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)));
384+
assert_eq!(x < y, Atom::from(x) < Atom::from(y));
385+
assert_eq!(x.cmp(y), Atom::from(x).cmp(&Atom::from(y)));
386+
assert_eq!(x.partial_cmp(y), Atom::from(x).partial_cmp(&Atom::from(y)));
378387
}
379388

380389
check("a", "body");
@@ -390,17 +399,17 @@ mod tests {
390399

391400
#[test]
392401
fn clone() {
393-
let s0 = Atom::from_slice("fn");
402+
let s0 = Atom::from("fn");
394403
let s1 = s0.clone();
395-
let s2 = Atom::from_slice("loop");
404+
let s2 = Atom::from("loop");
396405

397-
let i0 = Atom::from_slice("blah");
406+
let i0 = Atom::from("blah");
398407
let i1 = i0.clone();
399-
let i2 = Atom::from_slice("blah2");
408+
let i2 = Atom::from("blah2");
400409

401-
let d0 = Atom::from_slice("zzzzzzzz");
410+
let d0 = Atom::from("zzzzzzzz");
402411
let d1 = d0.clone();
403-
let d2 = Atom::from_slice("zzzzzzzzz");
412+
let d2 = Atom::from("zzzzzzzzz");
404413

405414
assert!(s0 == s1);
406415
assert!(s0 != s2);
@@ -429,12 +438,12 @@ mod tests {
429438
#[test]
430439
fn repr() {
431440
fn check(s: &str, data: u64) {
432-
assert_eq_fmt!("0x{:016X}", Atom::from_slice(s).data, data);
441+
assert_eq_fmt!("0x{:016X}", Atom::from(s).data, data);
433442
}
434443

435444
fn check_static(s: &str, x: Atom) {
436445
use string_cache_shared::STATIC_ATOM_SET;
437-
assert_eq_fmt!("0x{:016X}", x.data, Atom::from_slice(s).data);
446+
assert_eq_fmt!("0x{:016X}", x.data, Atom::from(s).data);
438447
assert_eq!(0x2, x.data & 0xFFFF_FFFF);
439448
// The index is unspecified by phf.
440449
assert!((x.data >> 32) <= STATIC_ATOM_SET.iter().len() as u64);
@@ -455,7 +464,7 @@ mod tests {
455464
check("xyzzy01", 0x3130_797A_7A79_7871);
456465

457466
// 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);
467+
assert_eq!(0x00, Atom::from("a dynamic string").data & 0xf);
459468
}
460469

461470
#[test]
@@ -470,34 +479,34 @@ mod tests {
470479
fn test_threads() {
471480
for _ in 0_u32..100 {
472481
thread::spawn(move || {
473-
let _ = Atom::from_slice("a dynamic string");
474-
let _ = Atom::from_slice("another string");
482+
let _ = Atom::from("a dynamic string");
483+
let _ = Atom::from("another string");
475484
});
476485
}
477486
}
478487

479488
#[test]
480489
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"));
490+
assert_eq!(atom!(body), Atom::from("body"));
491+
assert_eq!(atom!("body"), Atom::from("body"));
492+
assert_eq!(atom!("font-weight"), Atom::from("font-weight"));
484493
}
485494

486495
#[test]
487496
fn match_atom() {
488-
assert_eq!(2, match Atom::from_slice("head") {
497+
assert_eq!(2, match Atom::from("head") {
489498
atom!(br) => 1,
490499
atom!(html) | atom!(head) => 2,
491500
_ => 3,
492501
});
493502

494-
assert_eq!(3, match Atom::from_slice("body") {
503+
assert_eq!(3, match Atom::from("body") {
495504
atom!(br) => 1,
496505
atom!(html) | atom!(head) => 2,
497506
_ => 3,
498507
});
499508

500-
assert_eq!(3, match Atom::from_slice("zzzzzz") {
509+
assert_eq!(3, match Atom::from("zzzzzz") {
501510
atom!(br) => 1,
502511
atom!(html) | atom!(head) => 2,
503512
_ => 3,
@@ -507,14 +516,14 @@ mod tests {
507516
#[test]
508517
fn ensure_deref() {
509518
// Ensure we can Deref to a &str
510-
let atom = Atom::from_slice("foobar");
519+
let atom = Atom::from("foobar");
511520
let _: &str = &atom;
512521
}
513522

514523
#[test]
515524
fn ensure_as_ref() {
516525
// Ensure we can as_ref to a &str
517-
let atom = Atom::from_slice("foobar");
526+
let atom = Atom::from("foobar");
518527
let _: &str = atom.as_ref();
519528
}
520529

‎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)