From f01488236a8e944f1b12b4bc441d55c10fc47aa1 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Fri, 20 Feb 2015 08:45:11 -0800 Subject: [PATCH] Fix for upstream changes --- phf/src/map.rs | 14 +++++++------- phf/src/ordered_map.rs | 18 +++++++++--------- phf/src/ordered_set.rs | 8 ++++---- phf/src/set.rs | 6 +++--- phf_shared/src/lib.rs | 6 +++--- 5 files changed, 26 insertions(+), 26 deletions(-) diff --git a/phf/src/map.rs b/phf/src/map.rs index afb1ee7d..43963ddb 100644 --- a/phf/src/map.rs +++ b/phf/src/map.rs @@ -1,6 +1,6 @@ //! An immutable map constructed at compile time. use std::prelude::v1::*; -use std::borrow::BorrowFrom; +use std::borrow::Borrow; use std::ops::Index; use std::slice; use std::fmt; @@ -55,7 +55,7 @@ impl fmt::Debug for Map where K: fmt::Debug, V: fmt::Debug { } } -impl Index for Map where T: Eq + PhfHash + BorrowFrom { +impl Index for Map where T: Eq + PhfHash, K: Borrow { type Output = V; fn index(&self, k: &T) -> &V { @@ -75,12 +75,12 @@ impl Map { } /// Determines if `key` is in the `Map`. - pub fn contains_key(&self, key: &T) -> bool where T: Eq + PhfHash + BorrowFrom { + pub fn contains_key(&self, key: &T) -> bool where T: Eq + PhfHash, K: Borrow { self.get(key).is_some() } /// Returns a reference to the value that `key` maps to. - pub fn get(&self, key: &T) -> Option<&V> where T: Eq + PhfHash + BorrowFrom { + pub fn get(&self, key: &T) -> Option<&V> where T: Eq + PhfHash, K: Borrow { self.get_entry(key).map(|e| e.1) } @@ -88,18 +88,18 @@ impl Map { /// key. /// /// This can be useful for interning schemes. - pub fn get_key(&self, key: &T) -> Option<&K> where T: Eq + PhfHash + BorrowFrom { + pub fn get_key(&self, key: &T) -> Option<&K> where T: Eq + PhfHash, K: Borrow { self.get_entry(key).map(|e| e.0) } /// Like `get`, but returns both the key and the value. pub fn get_entry(&self, key: &T) -> Option<(&K, &V)> - where T: Eq + PhfHash + BorrowFrom { + where T: Eq + PhfHash, K: Borrow { let (g, f1, f2) = key.phf_hash(self.key); let (d1, d2) = self.disps[(g % (self.disps.len() as u32)) as usize]; let entry = &self.entries[(phf_shared::displace(f1, f2, d1, d2) % (self.entries.len() as u32)) as usize]; - let b: &T = BorrowFrom::borrow_from(&entry.0); + let b: &T = entry.0.borrow(); if b == key { Some((&entry.0, &entry.1)) } else { diff --git a/phf/src/ordered_map.rs b/phf/src/ordered_map.rs index b0dc621b..1fd3d94c 100644 --- a/phf/src/ordered_map.rs +++ b/phf/src/ordered_map.rs @@ -1,6 +1,6 @@ //! An order-preserving immutable map constructed at compile time. use std::prelude::v1::*; -use std::borrow::BorrowFrom; +use std::borrow::Borrow; use std::iter::{IntoIterator, RandomAccessIterator}; use std::ops::Index; use std::fmt; @@ -61,7 +61,7 @@ impl fmt::Debug for OrderedMap where K: fmt::Debug, V: fmt::Debug { } } -impl Index for OrderedMap where T: Eq + PhfHash + BorrowFrom { +impl Index for OrderedMap where T: Eq + PhfHash, K: Borrow { type Output = V; fn index(&self, k: &T) -> &V { @@ -81,7 +81,7 @@ impl OrderedMap { } /// Returns a reference to the value that `key` maps to. - pub fn get(&self, key: &T) -> Option<&V> where T: Eq + PhfHash + BorrowFrom { + pub fn get(&self, key: &T) -> Option<&V> where T: Eq + PhfHash, K: Borrow { self.get_entry(key).map(|e| e.1) } @@ -89,36 +89,36 @@ impl OrderedMap { /// key. /// /// This can be useful for interning schemes. - pub fn get_key(&self, key: &T) -> Option<&K> where T: Eq + PhfHash + BorrowFrom { + pub fn get_key(&self, key: &T) -> Option<&K> where T: Eq + PhfHash, K: Borrow { self.get_entry(key).map(|e| e.0) } /// Determines if `key` is in the `Map`. - pub fn contains_key(&self, key: &T) -> bool where T: Eq + PhfHash + BorrowFrom { + pub fn contains_key(&self, key: &T) -> bool where T: Eq + PhfHash, K: Borrow { self.get(key).is_some() } /// Returns the index of the key within the list used to initialize /// the ordered map. pub fn get_index(&self, key: &T) -> Option - where T: Eq + PhfHash + BorrowFrom { + where T: Eq + PhfHash, K: Borrow { self.get_internal(key).map(|(i, _)| i) } /// Like `get`, but returns both the key and the value. pub fn get_entry(&self, key: &T) -> Option<(&K, &V)> - where T: Eq + PhfHash + BorrowFrom { + where T: Eq + PhfHash, K: Borrow { self.get_internal(key).map(|(_, e)| e) } fn get_internal(&self, key: &T) -> Option<(usize, (&K, &V))> - where T: Eq + PhfHash + BorrowFrom { + where T: Eq + PhfHash, K: Borrow { let (g, f1, f2) = key.phf_hash(self.key); let (d1, d2) = self.disps[(g % (self.disps.len() as u32)) as usize]; let idx = self.idxs[(phf_shared::displace(f1, f2, d1, d2) % (self.idxs.len() as u32)) as usize]; let entry = &self.entries[idx]; - let b: &T = BorrowFrom::borrow_from(&entry.0); + let b: &T = entry.0.borrow(); if b == key { Some((idx, (&entry.0, &entry.1))) } else { diff --git a/phf/src/ordered_set.rs b/phf/src/ordered_set.rs index 273c8b1f..3b83b7e0 100644 --- a/phf/src/ordered_set.rs +++ b/phf/src/ordered_set.rs @@ -1,6 +1,6 @@ //! An order-preserving immutable set constructed at compile time. use std::prelude::v1::*; -use std::borrow::BorrowFrom; +use std::borrow::Borrow; use std::iter::{IntoIterator, RandomAccessIterator}; use std::fmt; use ordered_map; @@ -67,19 +67,19 @@ impl OrderedSet { /// key. /// /// This can be useful for interning schemes. - pub fn get_key(&self, key: &U) -> Option<&T> where U: Eq + PhfHash + BorrowFrom { + pub fn get_key(&self, key: &U) -> Option<&T> where U: Eq + PhfHash, T: Borrow { self.map.get_key(key) } /// Returns the index of the key within the list used to initialize /// the ordered set. pub fn get_index(&self, key: &U) -> Option - where U: Eq + PhfHash + BorrowFrom { + where U: Eq + PhfHash, T: Borrow { self.map.get_index(key) } /// Returns true if `value` is in the `Set`. - pub fn contains(&self, value: &U) -> bool where U: Eq + PhfHash + BorrowFrom { + pub fn contains(&self, value: &U) -> bool where U: Eq + PhfHash, T: Borrow { self.map.contains_key(value) } diff --git a/phf/src/set.rs b/phf/src/set.rs index 8ea49682..0cb26ede 100644 --- a/phf/src/set.rs +++ b/phf/src/set.rs @@ -1,6 +1,6 @@ //! An immutable set constructed at compile time. use std::prelude::v1::*; -use std::borrow::BorrowFrom; +use std::borrow::Borrow; use std::iter::IntoIterator; use std::fmt; @@ -66,12 +66,12 @@ impl Set { /// key. /// /// This can be useful for interning schemes. - pub fn get_key(&self, key: &U) -> Option<&T> where U: Eq + PhfHash + BorrowFrom { + pub fn get_key(&self, key: &U) -> Option<&T> where U: Eq + PhfHash, T: Borrow { self.map.get_key(key) } /// Returns true if `value` is in the `Set`. - pub fn contains(&self, value: &U) -> bool where U: Eq + PhfHash + BorrowFrom { + pub fn contains(&self, value: &U) -> bool where U: Eq + PhfHash, T: Borrow { self.map.contains_key(value) } diff --git a/phf_shared/src/lib.rs b/phf_shared/src/lib.rs index 7e5c2706..38764561 100644 --- a/phf_shared/src/lib.rs +++ b/phf_shared/src/lib.rs @@ -8,7 +8,7 @@ extern crate core; use std::slice::AsSlice; use std::str::StrExt; -use std::hash::{Writer, Hasher, Hash, SipHasher}; +use std::hash::{Hasher, Hash, SipHasher}; #[cfg(feature = "core")] mod std { @@ -61,7 +61,7 @@ impl PhfHash for [u8] { #[inline] fn phf_hash(&self, seed: u64) -> (u32, u32, u32) { let mut state = SipHasher::new_with_keys(seed, 0); - state.write(self); + Hasher::write(&mut state, self); split(state.finish()) } } @@ -97,7 +97,7 @@ macro_rules! array_impl( #[inline] fn phf_hash(&self, seed: u64) -> (u32, u32, u32) { let mut hasher = SipHasher::new_with_keys(seed, 0); - hasher.write(self.as_slice()); + Hasher::write(&mut hasher, self); split(hasher.finish()) } }