Auto merge of #229 - cole-miller:try-insert-no-grow, r=Amanieu

Add `try_insert_no_grow` method on `RawTable`

This is my attempt to answer the need described in #224 by adding a method on `RawTable`:

```rust
impl<T> RawTable<T, Global> {
    pub fn try_insert_no_grow(&mut self, hash: u64, value: T) -> Result<Bucket<T>, T>;
}
```

This method follows the logic of `RawTable::insert`, but if the table would need to grow to accomodate the new element it "signals" by returning `Err(value)` instead of performing the reallocation and insertion.

Marked as draft for now because

- I'm not sure whether there's a better way to achieve this (advice welcome)
- some tests are probably needed
- there's an unused warning (despite the `pub`) that I haven't figured out how to get rid of

Author: bors

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## Added
+- Added safe `try_insert_no_grow` method to `RawTable`. (#229)
+
 ## Changed
 - The minimum Rust version has been bumped to 1.49.0. (#230)
 

src/raw/mod.rs

@@ -1013,6 +1013,31 @@ impl<T, A: Allocator + Clone> RawTable<T, A> {
         }
     }
 
+    /// Attempts to insert a new element without growing the table and return its raw bucket.
+    ///
+    /// Returns an `Err` containing the given element if inserting it would require growing the
+    /// table.
+    ///
+    /// This does not check if the given element already exists in the table.
+    #[cfg(feature = "raw")]
+    #[cfg_attr(feature = "inline-more", inline)]
+    pub fn try_insert_no_grow(&mut self, hash: u64, value: T) -> Result<Bucket<T>, T> {
+        unsafe {
+            let index = self.find_insert_slot(hash);
+            let old_ctrl = *self.ctrl(index);
+            if unlikely(self.growth_left == 0 && special_is_empty(old_ctrl)) {
+                Err(value)
+            } else {
+                let bucket = self.bucket(index);
+                self.growth_left -= special_is_empty(old_ctrl) as usize;
+                self.set_ctrl(index, h2(hash));
+                bucket.write(value);
+                self.items += 1;
+                Ok(bucket)
+            }
+        }
+    }
+
     /// Inserts a new element into the table, and returns a mutable reference to it.
     ///
     /// This does not check if the given element already exists in the table.