Introduce a Slice abstraction for buffers

This will allow for dynamic creation of PHF data structures.

phf/src/lib.rs

@@ -13,6 +13,8 @@ extern crate std as core;
 
 extern crate phf_shared;
 
+use core::ops::Deref;
+
 pub use phf_shared::PhfHash;
 #[doc(inline)]
 pub use map::Map;
@@ -27,3 +29,26 @@ pub mod map;
 pub mod set;
 pub mod ordered_map;
 pub mod ordered_set;
+
+// WARNING: this is not considered part of phf's public API and is subject to
+// change at any time.
+//
+// Basically Cow, but with the Owned version conditionally compiled
+#[doc(hidden)]
+pub enum Slice<T: 'static> {
+    Static(&'static [T]),
+    #[cfg(not(feature = "core"))]
+    Dynamic(Vec<T>),
+}
+
+impl<T> Deref for Slice<T> {
+    type Target = [T];
+
+    fn deref(&self) -> &[T] {
+        match *self {
+            Slice::Static(t) => t,
+            #[cfg(not(feature = "core"))]
+            Slice::Dynamic(ref t) => t,
+        }
+    }
+}

phf/src/map.rs

@@ -4,8 +4,8 @@ use core::ops::Index;
 use core::slice;
 use core::fmt;
 use core::iter::IntoIterator;
-use PhfHash;
-use phf_shared;
+use phf_shared::{self, PhfHash};
+use Slice;
 
 /// An immutable map constructed at compile time.
 ///
@@ -18,9 +18,9 @@ pub struct Map<K: 'static, V: 'static> {
     #[doc(hidden)]
     pub key: u64,
     #[doc(hidden)]
-    pub disps: &'static [(u32, u32)],
+    pub disps: Slice<(u32, u32)>,
     #[doc(hidden)]
-    pub entries: &'static [(K, V)],
+    pub entries: Slice<(K, V)>,
 }
 
 impl<K, V> fmt::Debug for Map<K, V> where K: fmt::Debug, V: fmt::Debug {
@@ -81,7 +81,7 @@ impl<K, V> Map<K, V> {
               K: Borrow<T>
     {
         let hash = phf_shared::hash(key, self.key);
-        let index = phf_shared::get_index(hash, self.disps, self.entries.len());
+        let index = phf_shared::get_index(hash, &*self.disps, self.entries.len());
         let entry = &self.entries[index as usize];
         let b: &T = entry.0.borrow();
         if b == key {

phf/src/ordered_map.rs

@@ -4,9 +4,9 @@ use core::iter::IntoIterator;
 use core::ops::Index;
 use core::fmt;
 use core::slice;
+use phf_shared::{self, PhfHash};
 
-use PhfHash;
-use phf_shared;
+use Slice;
 
 /// An order-preserving immutable map constructed at compile time.
 ///
@@ -22,11 +22,11 @@ pub struct OrderedMap<K: 'static, V: 'static> {
     #[doc(hidden)]
     pub key: u64,
     #[doc(hidden)]
-    pub disps: &'static [(u32, u32)],
+    pub disps: Slice<(u32, u32)>,
     #[doc(hidden)]
-    pub idxs: &'static [usize],
+    pub idxs: Slice<usize>,
     #[doc(hidden)]
-    pub entries: &'static [(K, V)],
+    pub entries: Slice<(K, V)>,
 }
 
 impl<K, V> fmt::Debug for OrderedMap<K, V> where K: fmt::Debug, V: fmt::Debug {
@@ -109,7 +109,7 @@ impl<K, V> OrderedMap<K, V> {
               K: Borrow<T>
     {
         let hash = phf_shared::hash(key, self.key);
-        let idx_index = phf_shared::get_index(hash, self.disps, self.idxs.len());
+        let idx_index = phf_shared::get_index(hash, &*self.disps, self.idxs.len());
         let idx = self.idxs[idx_index as usize];
         let entry = &self.entries[idx];
 

phf_codegen/src/lib.rs

@@ -142,7 +142,7 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> Map<K> {
         try!(write!(w,
                     "::phf::Map {{
     key: {},
-    disps: &[",
+    disps: ::phf::Slice::Static(&[",
                     state.key));
         for &(d1, d2) in &state.disps {
             try!(write!(w,
@@ -153,8 +153,8 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> Map<K> {
         }
         try!(write!(w,
                     "
-    ],
-    entries: &["));
+    ]),
+    entries: ::phf::Slice::Static(&["));
         for &idx in &state.map {
             try!(write!(w,
                         "
@@ -164,7 +164,7 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> Map<K> {
         }
         write!(w,
                "
-    ]
+    ]),
 }}")
     }
 }
@@ -241,7 +241,7 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> OrderedMap<K> {
         try!(write!(w,
                     "::phf::OrderedMap {{
     key: {},
-    disps: &[",
+    disps: ::phf::Slice::Static(&[",
                     state.key));
         for &(d1, d2) in &state.disps {
             try!(write!(w,
@@ -252,8 +252,8 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> OrderedMap<K> {
         }
         try!(write!(w,
                     "
-    ],
-    idxs: &["));
+    ]),
+    idxs: ::phf::Slice::Static(&["));
         for &idx in &state.map {
             try!(write!(w,
                         "
@@ -262,8 +262,8 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> OrderedMap<K> {
         }
         try!(write!(w,
                     "
-    ],
-    entries: &["));
+    ]),
+    entries: ::phf::Slice::Static(&["));
         for (key, value) in self.keys.iter().zip(self.values.iter()) {
             try!(write!(w,
                         "
@@ -273,7 +273,7 @@ impl<K: Hash+PhfHash+Eq+fmt::Debug> OrderedMap<K> {
         }
         write!(w,
                "
-    ]
+    ]),
 }}")
     }
 }

phf_macros/src/util.rs

@@ -100,8 +100,8 @@ pub fn create_map(cx: &mut ExtCtxt,
     let key = state.key;
     MacEager::expr(quote_expr!(cx, ::phf::Map {
         key: $key,
-        disps: &$disps,
-        entries: &$entries,
+        disps: ::phf::Slice::Static(&$disps),
+        entries: ::phf::Slice::Static(&$entries),
     }))
 }
 
@@ -138,9 +138,9 @@ pub fn create_ordered_map(cx: &mut ExtCtxt,
     let key = state.key;
     MacEager::expr(quote_expr!(cx, ::phf::OrderedMap {
         key: $key,
-        disps: &$disps,
-        idxs: &$idxs,
-        entries: &$entries,
+        disps: ::phf::Slice::Static(&$disps),
+        idxs: ::phf::Slice::Static(&$idxs),
+        entries: ::phf::Slice::Static(&$entries),
     }))
 }