From b2f23b8a672af52c55ba17e45319d8a7463eb5d4 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Tue, 29 Aug 2017 15:47:21 -0700
Subject: [PATCH] Add fake fallible HashMap shim over stdlib

---
 src/fake.rs | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs  |  2 ++
 2 files changed, 85 insertions(+)
 create mode 100644 src/fake.rs

diff --git a/src/fake.rs b/src/fake.rs
new file mode 100644
index 00000000000..203fdb3423a
--- /dev/null
+++ b/src/fake.rs
@@ -0,0 +1,83 @@
+//! This module contains shims around the stdlib HashMap
+//! that add fallible methods
+//!
+//! These methods are a lie. They are not actually fallible. This is just to make
+//! it smooth to switch between hashmap impls in a codebase.
+
+use std::hash::{BuildHasher, Hash};
+use std::collections::HashMap as StdMap;
+use std::ops::{Deref, DerefMut};
+
+pub use std::collections::hash_map::{Entry, RandomState};
+
+pub struct HashMap<K, V, S = RandomState>(StdMap<K, V, S>);
+
+impl<K, V, S> Deref for HashMap<K, V, S> {
+    type Target = StdMap<K, V, S>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    } 
+}
+
+impl<K, V, S> DerefMut for HashMap<K, V, S> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    } 
+}
+
+impl<K: Hash + Eq, V> HashMap<K, V, RandomState> {
+
+    #[inline]
+    pub fn new() -> HashMap<K, V, RandomState> {
+        HashMap(StdMap::new())
+    }
+
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> HashMap<K, V, RandomState> {
+        HashMap(StdMap::with_capacity(capacity))
+    }
+
+    #[inline]
+    pub fn with_capacity_fallible(capacity: usize) -> Result<HashMap<K, V, RandomState>, ()> {
+        Ok(HashMap(StdMap::with_capacity(capacity)))
+    }
+}
+
+
+impl<K, V, S> HashMap<K, V, S>
+    where K: Eq + Hash,
+          S: BuildHasher
+{
+    #[inline]
+    pub fn with_hasher_fallible(hash_builder: S) -> Result<HashMap<K, V, S>, ()> {
+        Ok(HashMap(StdMap::with_hasher(hash_builder)))
+    }
+
+    #[inline]
+    pub fn with_capacity_and_hasher_fallible(capacity: usize, hash_builder: S) -> Result<HashMap<K, V, S>, ()> {
+        Ok(HashMap(StdMap::with_capacity_and_hasher(capacity, hash_builder)))
+    }
+
+    pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S> {
+        HashMap(StdMap::with_capacity_and_hasher(capacity, hash_builder))
+    }
+
+
+    #[inline]
+    pub fn reserve_fallible(&mut self, additional: usize) -> Result<(), ()> {
+        Ok(self.reserve(additional))
+    }
+
+    pub fn shrink_to_fit_fallible(&mut self) -> Result<(), ()> {
+        Ok(self.shrink_to_fit())
+    }
+
+    pub fn entry_fallible(&mut self, key: K) -> Result<Entry<K, V>, ()> {
+        Ok(self.entry(key))
+    }
+
+    #[inline]
+    pub fn insert_fallible(&mut self, k: K, v: V) -> Result<Option<V>, ()> {
+        Ok(self.insert(k, v))
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index db12c725f5d..3cbab53a950 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,6 +6,8 @@ mod alloc;
 pub mod hash_map;
 pub mod hash_set;
 
+pub mod fake;
+
 trait Recover<Q: ?Sized> {
     type Key;