google_hash 0.6.2 → 0.7.0

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/google-sparsehash.sln

@@ -7,7 +7,15 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sparsetable_unittest", "vsp
 	ProjectSection(ProjectDependencies) = postProject
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hashtable_unittest", "vsprojects\hashtable_unittest\hashtable_unittest.vcproj", "{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hashtable_test", "vsprojects\hashtable_test\hashtable_test.vcproj", "{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simple_test", "vsprojects\simple_test\simple_test.vcproj", "{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0538}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libc_allocator_with_realloc_test", "vsprojects\libc_allocator_with_realloc_test\libc_allocator_with_realloc_test.vcproj", "{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0539}"
 	ProjectSection(ProjectDependencies) = postProject
 	EndProjectSection
 EndProject
@@ -35,6 +43,14 @@ Global
 		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Debug.Build.0 = Debug|Win32
 		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Release.ActiveCfg = Release|Win32
 		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Release.Build.0 = Release|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0538}.Debug.ActiveCfg = Debug|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0538}.Debug.Build.0 = Debug|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0538}.Release.ActiveCfg = Release|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0538}.Release.Build.0 = Release|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0539}.Debug.ActiveCfg = Debug|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0539}.Debug.Build.0 = Debug|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0539}.Release.ActiveCfg = Release|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0539}.Release.Build.0 = Release|Win32
 		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Debug.ActiveCfg = Debug|Win32
 		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Debug.Build.0 = Debug|Win32
 		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Release.ActiveCfg = Release|Win32

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/packages/deb/changelog

@@ -1,3 +1,27 @@
+sparsehash (1.8.1-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Google Inc. <opensource@google.com>  Thu, 29 Jul 2010 15:01:29 -0700
+
+sparsehash (1.8-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Google Inc. <opensource@google.com>  Thu, 29 Jul 2010 09:53:26 -0700
+
+sparsehash (1.7-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Google Inc. <opensource@google.com>  Wed, 31 Mar 2010 12:32:03 -0700
+
+sparsehash (1.6-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Google Inc. <opensource@google.com>  Fri, 08 Jan 2010 14:47:55 -0800
+
 sparsehash (1.5.2-1) unstable; urgency=low
 
   * New upstream release.

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/packages/deb/control

@@ -1,7 +1,7 @@
 Source: sparsehash
 Section: libdevel
 Priority: optional
-Maintainer: Google Inc. <opensource@google.com>
+Maintainer: Google Inc. <google-sparsehash@googlegroups.com>
 Build-Depends: debhelper (>= 4.0.0)
 Standards-Version: 3.6.1
 

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/packages/rpm/rpm.spec

@@ -10,7 +10,7 @@ Group: Development/Libraries
 URL: http://code.google.com/p/google-sparsehash
 License: BSD
 Vendor: Google
-Packager: Google <opensource@google.com>
+Packager: Google <google-sparsehash@googlegroups.com>
 Source: http://%{NAME}.googlecode.com/files/%{NAME}-%{VERSION}.tar.gz
 Distribution: Redhat 7 and above.
 Buildroot: %{_tmppath}/%{name}-root

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/src/config.h.in

@@ -102,6 +102,9 @@
 /* Define to the one symbol short name of this package. */
 #undef PACKAGE_TARNAME
 
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
 

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/src/google/dense_hash_map

@@ -42,12 +42,20 @@
 //
 //   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.
 //
-// Otherwise your program will die in mysterious ways.
+// Otherwise your program will die in mysterious ways.  (Note if you
+// use the constructor that takes an InputIterator range, you pass in
+// the empty key in the constructor, rather than after.  As a result,
+// this constructor differs from the standard STL version.)
 //
 // In other respects, we adhere mostly to the STL semantics for
-// hash-map.  One important exception is that insert() invalidates
-// iterators entirely.  On the plus side, though, erase() doesn't
-// invalidate iterators at all, or even change the ordering of elements.
+// hash-map.  One important exception is that insert() may invalidate
+// iterators entirely -- STL semantics are that insert() may reorder
+// iterators, but they all still refer to something valid in the
+// hashtable.  Not so for us.  Likewise, insert() may invalidate
+// pointers into the hashtable.  (Whether insert invalidates iterators
+// and pointers depends on whether it results in a hashtable resize).
+// On the plus side, delete() doesn't invalidate iterators or pointers
+// at all, or even change the ordering of elements.
 //
 // Here are a few "power user" tips:
 //
@@ -67,18 +75,19 @@
 //         Setting the minimum load factor to 0.0 guarantees that
 //         the hash table will never shrink.
 //
-// Guide to what kind of hash_map to use:
-//   (1) dense_hash_map: fastest, uses the most memory
+// Roughly speaking:
+//   (1) dense_hash_map: fastest, uses the most memory unless entries are small
 //   (2) sparse_hash_map: slowest, uses the least memory
-//   (3) hash_map (STL): in the middle
+//   (3) hash_map / unordered_map (STL): in the middle
+//
 // Typically I use sparse_hash_map when I care about space and/or when
 // I need to save the hashtable on disk.  I use hash_map otherwise.  I
 // don't personally use dense_hash_set ever; some people use it for
 // small sets with lots of lookups.
 //
-// - dense_hash_map has, typically, a factor of 2 memory overhead (if your
-//   data takes up X bytes, the hash_map uses X more bytes in overhead).
-// - sparse_hash_map has about 2 bits overhead per entry.
+// - dense_hash_map has, typically, about 78% memory overhead (if your
+//   data takes up X bytes, the hash_map uses .78X more bytes in overhead).
+// - sparse_hash_map has about 4 bits overhead per entry.
 // - sparse_hash_map can be 3-7 times slower than the others for lookup and,
 //   especially, inserts.  See time_hash_map.cc for details.
 //
@@ -95,6 +104,7 @@
 #include <memory>                    // for alloc<>
 #include <utility>                   // for pair<>
 #include HASH_FUN_H                  // defined in config.h
+#include <google/sparsehash/libc_allocator_with_realloc.h>
 #include <google/sparsehash/densehashtable.h>
 
 
@@ -105,7 +115,7 @@ using STL_NAMESPACE::pair;
 template <class Key, class T,
           class HashFcn = SPARSEHASH_HASH<Key>,   // defined in sparseconfig.h
           class EqualKey = STL_NAMESPACE::equal_to<Key>,
-          class Alloc = STL_NAMESPACE::allocator<T> >
+          class Alloc = libc_allocator_with_realloc<pair<const Key, T> > >
 class dense_hash_map {
  private:
   // Apparently select1st is not stl-standard, so we define our own
@@ -125,8 +135,8 @@ class dense_hash_map {
   };
 
   // The actual data
-  typedef dense_hashtable<pair<const Key, T>, Key, HashFcn,
-                          SelectKey, SetKey, EqualKey, Alloc> ht;
+  typedef dense_hashtable<pair<const Key, T>, Key, HashFcn, SelectKey,
+                          SetKey, EqualKey, Alloc> ht;
   ht rep;
 
  public:
@@ -164,7 +174,7 @@ class dense_hash_map {
   const_local_iterator end(size_type i) const    { return rep.end(i); }
 
   // Accessor functions
-  // TODO(csilvers): implement Alloc get_allocator() const;
+  allocator_type get_allocator() const           { return rep.get_allocator(); }
   hasher hash_funct() const                      { return rep.hash_funct(); }
   hasher hash_function() const                   { return hash_funct(); }
   key_equal key_eq() const                       { return rep.key_eq(); }
@@ -173,15 +183,20 @@ class dense_hash_map {
   // Constructors
   explicit dense_hash_map(size_type expected_max_items_in_table = 0,
                           const hasher& hf = hasher(),
-                          const key_equal& eql = key_equal())
-    : rep(expected_max_items_in_table, hf, eql) { }
+                          const key_equal& eql = key_equal(),
+                          const allocator_type& alloc = allocator_type())
+    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
+  }
 
   template <class InputIterator>
   dense_hash_map(InputIterator f, InputIterator l,
+                 const key_type& empty_key_val,
                  size_type expected_max_items_in_table = 0,
                  const hasher& hf = hasher(),
-                 const key_equal& eql = key_equal())
-    : rep(expected_max_items_in_table, hf, eql) {
+                 const key_equal& eql = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
+    set_empty_key(empty_key_val);
     rep.insert(f, l);
   }
   // We use the default copy constructor
@@ -231,7 +246,7 @@ class dense_hash_map {
   }
   // Deprecated; use min_load_factor() or max_load_factor() instead.
   void set_resizing_parameters(float shrink, float grow) {
-    return rep.set_resizing_parameters(shrink, grow);
+    rep.set_resizing_parameters(shrink, grow);
   }
 
   void resize(size_type hint)         { rep.resize(hint); }
@@ -242,12 +257,10 @@ class dense_hash_map {
   const_iterator find(const key_type& key) const     { return rep.find(key); }
 
   data_type& operator[](const key_type& key) {       // This is our value-add!
-    iterator it = find(key);
-    if (it != end()) {
-      return it->second;
-    } else {
-      return insert(value_type(key, data_type())).first->second;
-    }
+    // If key is in the hashtable, returns find(key)->second,
+    // otherwise returns insert(value_type(key, T()).first->second.
+    // Note it does not create an empty T unless the find fails.
+    return rep.template find_or_insert<T>(key);
   }
 
   size_type count(const key_type& key) const         { return rep.count(key); }
@@ -275,10 +288,13 @@ class dense_hash_map {
   void set_empty_key(const key_type& key)   {           // YOU MUST CALL THIS!
     rep.set_empty_key(value_type(key, data_type()));    // rep wants a value
   }
-  void set_deleted_key(const key_type& key)   {
-    rep.set_deleted_key(key);
+  key_type empty_key() const {
+    return rep.empty_key().first;                       // rep returns a value
   }
+
+  void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
   void clear_deleted_key()                    { rep.clear_deleted_key(); }
+  key_type deleted_key() const                { return rep.deleted_key(); }
 
   // These are standard
   size_type erase(const key_type& key)               { return rep.erase(key); }

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/src/google/dense_hash_set

@@ -46,12 +46,20 @@
 //
 //   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.
 //
-// Otherwise your program will die in mysterious ways.
+// Otherwise your program will die in mysterious ways.  (Note if you
+// use the constructor that takes an InputIterator range, you pass in
+// the empty key in the constructor, rather than after.  As a result,
+// this constructor differs from the standard STL version.)
 //
 // In other respects, we adhere mostly to the STL semantics for
-// hash-set.  One important exception is that insert() invalidates
-// iterators entirely.  On the plus side, though, erase() doesn't
-// invalidate iterators at all, or even change the ordering of elements.
+// hash-map.  One important exception is that insert() may invalidate
+// iterators entirely -- STL semantics are that insert() may reorder
+// iterators, but they all still refer to something valid in the
+// hashtable.  Not so for us.  Likewise, insert() may invalidate
+// pointers into the hashtable.  (Whether insert invalidates iterators
+// and pointers depends on whether it results in a hashtable resize).
+// On the plus side, delete() doesn't invalidate iterators or pointers
+// at all, or even change the ordering of elements.
 //
 // Here are a few "power user" tips:
 //
@@ -71,19 +79,20 @@
 //         Setting the minimum load factor to 0.0 guarantees that
 //         the hash table will never shrink.
 //
-// Guide to what kind of hash_set to use:
-//   (1) dense_hash_set: fastest, uses the most memory
+// Roughly speaking:
+//   (1) dense_hash_set: fastest, uses the most memory unless entries are small
 //   (2) sparse_hash_set: slowest, uses the least memory
-//   (3) hash_set (STL): in the middle
+//   (3) hash_set / unordered_set (STL): in the middle
+//
 // Typically I use sparse_hash_set when I care about space and/or when
 // I need to save the hashtable on disk.  I use hash_set otherwise.  I
 // don't personally use dense_hash_set ever; some people use it for
 // small sets with lots of lookups.
 //
-// - dense_hash_set has, typically, a factor of 2 memory overhead (if your
-//   data takes up X bytes, the hash_set uses X more bytes in overhead).
-// - sparse_hash_set has about 2 bits overhead per entry.
-// - sparse_hash_map can be 3-7 times slower than the others for lookup and,
+// - dense_hash_set has, typically, about 78% memory overhead (if your
+//   data takes up X bytes, the hash_set uses .78X more bytes in overhead).
+// - sparse_hash_set has about 4 bits overhead per entry.
+// - sparse_hash_set can be 3-7 times slower than the others for lookup and,
 //   especially, inserts.  See time_hash_map.cc for details.
 //
 // See /usr/(local/)?doc/sparsehash-*/dense_hash_set.html
@@ -99,6 +108,7 @@
 #include <memory>                    // for alloc<>
 #include <utility>                   // for pair<>
 #include HASH_FUN_H                  // defined in config.h
+#include <google/sparsehash/libc_allocator_with_realloc.h>
 #include <google/sparsehash/densehashtable.h>
 
 
@@ -109,7 +119,7 @@ using STL_NAMESPACE::pair;
 template <class Value,
           class HashFcn = SPARSEHASH_HASH<Value>,  // defined in sparseconfig.h
           class EqualKey = STL_NAMESPACE::equal_to<Value>, 
-          class Alloc = STL_NAMESPACE::allocator<Value> >
+          class Alloc = libc_allocator_with_realloc<Value> >
 class dense_hash_set {
  private:
   // Apparently identity is not stl-standard, so we define our own
@@ -124,8 +134,8 @@ class dense_hash_set {
   };
 
   // The actual data
-  typedef dense_hashtable<Value, Value, HashFcn,
-                          Identity, SetKey, EqualKey, Alloc> ht;
+  typedef dense_hashtable<Value, Value, HashFcn, Identity, SetKey,
+                          EqualKey, Alloc> ht;
   ht rep;
 
  public:
@@ -158,22 +168,29 @@ class dense_hash_set {
 
 
   // Accessor functions
+  allocator_type get_allocator() const    { return rep.get_allocator(); }
   hasher hash_funct() const               { return rep.hash_funct(); }
+  hasher hash_function() const            { return hash_funct(); }  // tr1 name
   key_equal key_eq() const                { return rep.key_eq(); }
 
 
   // Constructors
   explicit dense_hash_set(size_type expected_max_items_in_table = 0,
                           const hasher& hf = hasher(),
-                          const key_equal& eql = key_equal())
-    : rep(expected_max_items_in_table, hf, eql) { }
+                          const key_equal& eql = key_equal(),
+                          const allocator_type& alloc = allocator_type())
+      : rep(expected_max_items_in_table, hf, eql, Identity(), SetKey(), alloc) {
+  }
 
   template <class InputIterator>
   dense_hash_set(InputIterator f, InputIterator l,
+                 const key_type& empty_key_val,
                  size_type expected_max_items_in_table = 0,
                  const hasher& hf = hasher(),
-                 const key_equal& eql = key_equal())
-      : rep(expected_max_items_in_table, hf, eql) {
+                 const key_equal& eql = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+      : rep(expected_max_items_in_table, hf, eql, Identity(), SetKey(), alloc) {
+    set_empty_key(empty_key_val);
     rep.insert(f, l);
   }
   // We use the default copy constructor
@@ -223,7 +240,7 @@ class dense_hash_set {
   }
   // Deprecated; use min_load_factor() or max_load_factor() instead.
   void set_resizing_parameters(float shrink, float grow) {
-    return rep.set_resizing_parameters(shrink, grow);
+    rep.set_resizing_parameters(shrink, grow);
   }
 
   void resize(size_type hint)         { rep.resize(hint); }
@@ -238,6 +255,7 @@ class dense_hash_set {
     return rep.equal_range(key);
   }
 
+
   // Insertion routines
   pair<iterator, bool> insert(const value_type& obj) {
     pair<typename ht::iterator, bool> p = rep.insert(obj);
@@ -255,8 +273,11 @@ class dense_hash_set {
   // value to identify deleted and empty buckets.  You can change the
   // deleted key as time goes on, or get rid of it entirely to be insert-only.
   void set_empty_key(const key_type& key)     { rep.set_empty_key(key); }
+  key_type empty_key() const                  { return rep.empty_key(); }
+
   void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
   void clear_deleted_key()                    { rep.clear_deleted_key(); }
+  key_type deleted_key() const                { return rep.deleted_key(); }
 
   // These are standard
   size_type erase(const key_type& key)               { return rep.erase(key); }

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/src/google/sparse_hash_map

@@ -37,9 +37,14 @@
 // (it only has a key and a value).
 //
 // We adhere mostly to the STL semantics for hash-map.  One important
-// exception is that insert() invalidates iterators entirely.  On the
-// plus side, though, delete() doesn't invalidate iterators at all, or
-// even change the ordering of elements.
+// exception is that insert() may invalidate iterators entirely -- STL
+// semantics are that insert() may reorder iterators, but they all
+// still refer to something valid in the hashtable.  Not so for us.
+// Likewise, insert() may invalidate pointers into the hashtable.
+// (Whether insert invalidates iterators and pointers depends on
+// whether it results in a hashtable resize).  On the plus side,
+// delete() doesn't invalidate iterators or pointers at all, or even
+// change the ordering of elements.
 //
 // Here are a few "power user" tips:
 //
@@ -58,18 +63,19 @@
 //         Setting the minimum load factor to 0.0 guarantees that
 //         the hash table will never shrink.
 //
-// Guide to what kind of hash_map to use:
-//   (1) dense_hash_map: fastest, uses the most memory
+// Roughly speaking:
+//   (1) dense_hash_map: fastest, uses the most memory unless entries are small
 //   (2) sparse_hash_map: slowest, uses the least memory
 //   (3) hash_map / unordered_map (STL): in the middle
+//
 // Typically I use sparse_hash_map when I care about space and/or when
 // I need to save the hashtable on disk.  I use hash_map otherwise.  I
 // don't personally use dense_hash_map ever; some people use it for
 // small maps with lots of lookups.
 //
-// - dense_hash_map has, typically, a factor of 2 memory overhead (if your
-//   data takes up X bytes, the hash_map uses X more bytes in overhead).
-// - sparse_hash_map has about 2 bits overhead per entry.
+// - dense_hash_map has, typically, about 78% memory overhead (if your
+//   data takes up X bytes, the hash_map uses .78X more bytes in overhead).
+// - sparse_hash_map has about 4 bits overhead per entry.
 // - sparse_hash_map can be 3-7 times slower than the others for lookup and,
 //   especially, inserts.  See time_hash_map.cc for details.
 //
@@ -86,6 +92,7 @@
 #include <memory>                    // for alloc<>
 #include <utility>                   // for pair<>
 #include HASH_FUN_H                  // defined in config.h
+#include <google/sparsehash/libc_allocator_with_realloc.h>
 #include <google/sparsehash/sparsehashtable.h>
 
 
@@ -96,7 +103,7 @@ using STL_NAMESPACE::pair;
 template <class Key, class T,
           class HashFcn = SPARSEHASH_HASH<Key>,   // defined in sparseconfig.h
           class EqualKey = STL_NAMESPACE::equal_to<Key>,
-          class Alloc = STL_NAMESPACE::allocator<T> >
+          class Alloc = libc_allocator_with_realloc<pair<const Key, T> > >
 class sparse_hash_map {
  private:
   // Apparently select1st is not stl-standard, so we define our own
@@ -116,8 +123,8 @@ class sparse_hash_map {
   };
 
   // The actual data
-  typedef sparse_hashtable<pair<const Key, T>, Key, HashFcn,
-                           SelectKey, SetKey, EqualKey, Alloc> ht;
+  typedef sparse_hashtable<pair<const Key, T>, Key, HashFcn, SelectKey,
+                           SetKey, EqualKey, Alloc> ht;
   ht rep;
 
  public:
@@ -154,7 +161,7 @@ class sparse_hash_map {
   const_local_iterator end(size_type i) const    { return rep.end(i); }
 
   // Accessor functions
-  // TODO(csilvers): implement Alloc get_allocator() const;
+  allocator_type get_allocator() const           { return rep.get_allocator(); }
   hasher hash_funct() const                      { return rep.hash_funct(); }
   hasher hash_function() const                   { return hash_funct(); }
   key_equal key_eq() const                       { return rep.key_eq(); }
@@ -163,15 +170,18 @@ class sparse_hash_map {
   // Constructors
   explicit sparse_hash_map(size_type expected_max_items_in_table = 0,
                            const hasher& hf = hasher(),
-                           const key_equal& eql = key_equal())
-    : rep(expected_max_items_in_table, hf, eql) { }
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& alloc = allocator_type())
+    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
+  }
 
   template <class InputIterator>
   sparse_hash_map(InputIterator f, InputIterator l,
                   size_type expected_max_items_in_table = 0,
                   const hasher& hf = hasher(),
-                  const key_equal& eql = key_equal())
-    : rep(expected_max_items_in_table, hf, eql) {
+                  const key_equal& eql = key_equal(),
+                  const allocator_type& alloc = allocator_type())
+    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
     rep.insert(f, l);
   }
   // We use the default copy constructor
@@ -218,7 +228,7 @@ class sparse_hash_map {
   }
   // Deprecated; use min_load_factor() or max_load_factor() instead.
   void set_resizing_parameters(float shrink, float grow) {
-    return rep.set_resizing_parameters(shrink, grow);
+    rep.set_resizing_parameters(shrink, grow);
   }
 
   void resize(size_type hint)         { rep.resize(hint); }
@@ -229,12 +239,10 @@ class sparse_hash_map {
   const_iterator find(const key_type& key) const     { return rep.find(key); }
 
   data_type& operator[](const key_type& key) {       // This is our value-add!
-    iterator it = find(key);
-    if (it != end()) {
-      return it->second;
-    } else {
-      return insert(value_type(key, data_type())).first->second;
-    }
+    // If key is in the hashtable, returns find(key)->second,
+    // otherwise returns insert(value_type(key, T()).first->second.
+    // Note it does not create an empty T unless the find fails.
+    return rep.template find_or_insert<data_type>(key);
   }
 
   size_type count(const key_type& key) const         { return rep.count(key); }
@@ -263,6 +271,7 @@ class sparse_hash_map {
     rep.set_deleted_key(key);
   }
   void clear_deleted_key()                    { rep.clear_deleted_key(); }
+  key_type deleted_key() const                { return rep.deleted_key(); }
 
   // These are standard
   size_type erase(const key_type& key)               { return rep.erase(key); }