google_hash 0.8.1 → 0.8.2

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

@@ -1,10 +1,10 @@
 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ -14,7 +14,7 @@
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -28,7 +28,6 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Craig Silverstein
 //
 // This is just a very thin wrapper over sparsehashtable.h, just
 // like sgi stl's stl_hash_map is a very thin wrapper over
@@ -85,35 +84,31 @@
 #ifndef _SPARSE_HASH_MAP_H_
 #define _SPARSE_HASH_MAP_H_
 
-#include <google/sparsehash/sparseconfig.h>
-#include <stdio.h>                   // for FILE * in read()/write()
-#include <algorithm>                 // for the default template args
-#include <functional>                // for equal_to
-#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>
-
-
+#include <sparsehash/internal/sparseconfig.h>
+#include <algorithm>                        // needed by stl_alloc
+#include <functional>                       // for equal_to<>, select1st<>, etc
+#include <memory>                           // for alloc
+#include <utility>                          // for pair<>
+#include <sparsehash/internal/libc_allocator_with_realloc.h>
+#include <sparsehash/internal/sparsehashtable.h>       // IWYU pragma: export
+#include HASH_FUN_H                 // for hash<>
 _START_GOOGLE_NAMESPACE_
 
-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 = libc_allocator_with_realloc<pair<const Key, T> > >
+          class EqualKey = std::equal_to<Key>,
+          class Alloc = libc_allocator_with_realloc<std::pair<const Key, T> > >
 class sparse_hash_map {
  private:
   // Apparently select1st is not stl-standard, so we define our own
   struct SelectKey {
-    const Key& operator()(const pair<const Key, T>& p) const {
+    typedef const Key& result_type;
+    const Key& operator()(const std::pair<const Key, T>& p) const {
       return p.first;
     }
   };
   struct SetKey {
-    void operator()(pair<const Key, T>* value, const Key& new_key) const {
+    void operator()(std::pair<const Key, T>* value, const Key& new_key) const {
       *const_cast<Key*>(&value->first) = new_key;
       // It would be nice to clear the rest of value here as well, in
       // case it's taking up a lot of memory.  We do this by clearing
@@ -121,9 +116,15 @@ class sparse_hash_map {
       value->second = T();
     }
   };
+  // For operator[].
+  struct DefaultValue {
+    std::pair<const Key, T> operator()(const Key& key) {
+      return std::make_pair(key, T());
+    }
+  };
 
   // The actual data
-  typedef sparse_hashtable<pair<const Key, T>, Key, HashFcn, SelectKey,
+  typedef sparse_hashtable<std::pair<const Key, T>, Key, HashFcn, SelectKey,
                            SetKey, EqualKey, Alloc> ht;
   ht rep;
 
@@ -242,26 +243,33 @@ class sparse_hash_map {
     // 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);
+    return rep.template find_or_insert<DefaultValue>(key).second;
   }
 
   size_type count(const key_type& key) const         { return rep.count(key); }
 
-  pair<iterator, iterator> equal_range(const key_type& key) {
+  std::pair<iterator, iterator> equal_range(const key_type& key) {
     return rep.equal_range(key);
   }
-  pair<const_iterator, const_iterator> equal_range(const key_type& key) const {
+  std::pair<const_iterator, const_iterator> equal_range(const key_type& key)
+      const {
     return rep.equal_range(key);
   }
 
   // Insertion routines
-  pair<iterator, bool> insert(const value_type& obj) { return rep.insert(obj); }
-  template <class InputIterator>
-  void insert(InputIterator f, InputIterator l)      { rep.insert(f, l); }
-  void insert(const_iterator f, const_iterator l)    { rep.insert(f, l); }
-  // required for std::insert_iterator; the passed-in iterator is ignored
-  iterator insert(iterator, const value_type& obj)   { return insert(obj).first; }
-
+  std::pair<iterator, bool> insert(const value_type& obj) {
+    return rep.insert(obj);
+  }
+  template <class InputIterator> void insert(InputIterator f, InputIterator l) {
+    rep.insert(f, l);
+  }
+  void insert(const_iterator f, const_iterator l) {
+    rep.insert(f, l);
+  }
+  // Required for std::insert_iterator; the passed-in iterator is ignored.
+  iterator insert(iterator, const value_type& obj) {
+    return insert(obj).first;
+  }
 
   // Deletion routines
   // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
@@ -285,10 +293,62 @@ class sparse_hash_map {
 
 
   // I/O -- this is an add-on for writing metainformation to disk
-  bool write_metadata(FILE *fp)       { return rep.write_metadata(fp); }
-  bool read_metadata(FILE *fp)        { return rep.read_metadata(fp); }
-  bool write_nopointer_data(FILE *fp) { return rep.write_nopointer_data(fp); }
-  bool read_nopointer_data(FILE *fp)  { return rep.read_nopointer_data(fp); }
+  //
+  // For maximum flexibility, this does not assume a particular
+  // file type (though it will probably be a FILE *).  We just pass
+  // the fp through to rep.
+
+  // If your keys and values are simple enough, you can pass this
+  // serializer to serialize()/unserialize().  "Simple enough" means
+  // value_type is a POD type that contains no pointers.  Note,
+  // however, we don't try to normalize endianness.
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+
+  // serializer: a class providing operator()(OUTPUT*, const value_type&)
+  //    (writing value_type to OUTPUT).  You can specify a
+  //    NopointerSerializer object if appropriate (see above).
+  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
+  //    pointer to a class providing size_t Write(const void*, size_t),
+  //    which writes a buffer into a stream (which fp presumably
+  //    owns) and returns the number of bytes successfully written.
+  //    Note basic_ostream<not_char> is not currently supported.
+  template <typename ValueSerializer, typename OUTPUT>
+  bool serialize(ValueSerializer serializer, OUTPUT* fp) {
+    return rep.serialize(serializer, fp);
+  }
+
+  // serializer: a functor providing operator()(INPUT*, value_type*)
+  //    (reading from INPUT and into value_type).  You can specify a
+  //    NopointerSerializer object if appropriate (see above).
+  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
+  //    pointer to a class providing size_t Read(void*, size_t),
+  //    which reads into a buffer from a stream (which fp presumably
+  //    owns) and returns the number of bytes successfully read.
+  //    Note basic_istream<not_char> is not currently supported.
+  // NOTE: Since value_type is std::pair<const Key, T>, ValueSerializer
+  // may need to do a const cast in order to fill in the key.
+  // NOTE: if Key or T are not POD types, the serializer MUST use
+  // placement-new to initialize their values, rather than a normal
+  // equals-assignment or similar.  (The value_type* passed into the
+  // serializer points to garbage memory.)
+  template <typename ValueSerializer, typename INPUT>
+  bool unserialize(ValueSerializer serializer, INPUT* fp) {
+    return rep.unserialize(serializer, fp);
+  }
+
+  // The four methods below are DEPRECATED.
+  // Use serialize() and unserialize() for new code.
+  template <typename OUTPUT>
+  bool write_metadata(OUTPUT *fp)       { return rep.write_metadata(fp); }
+
+  template <typename INPUT>
+  bool read_metadata(INPUT *fp)         { return rep.read_metadata(fp); }
+
+  template <typename OUTPUT>
+  bool write_nopointer_data(OUTPUT *fp) { return rep.write_nopointer_data(fp); }
+
+  template <typename INPUT>
+  bool read_nopointer_data(INPUT *fp)   { return rep.read_nopointer_data(fp); }
 };
 
 // We need a global swap as well

data/ext/{sparsehash-1.8.1/src/google → sparsehash-2.0.2/src/sparsehash}/sparse_hash_set

@@ -1,10 +1,10 @@
 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ -14,7 +14,7 @@
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -28,7 +28,6 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Craig Silverstein
 //
 // This is just a very thin wrapper over sparsehashtable.h, just
 // like sgi stl's stl_hash_set is a very thin wrapper over
@@ -89,29 +88,26 @@
 #ifndef _SPARSE_HASH_SET_H_
 #define _SPARSE_HASH_SET_H_
 
-#include <google/sparsehash/sparseconfig.h>
-#include <stdio.h>                    // for FILE * in read()/write()
-#include <algorithm>                  // for the default template args
-#include <functional>                // for equal_to
-#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>
+#include <sparsehash/internal/sparseconfig.h>
+#include <algorithm>                       // needed by stl_alloc
+#include <functional>                      // for equal_to<>
+#include <memory>                          // for alloc (which we don't use)
+#include <utility>                         // for pair<>
+#include <sparsehash/internal/libc_allocator_with_realloc.h>
+#include <sparsehash/internal/sparsehashtable.h>      // IWYU pragma: export
+#include HASH_FUN_H                // for hash<>
 
 _START_GOOGLE_NAMESPACE_
 
-using STL_NAMESPACE::pair;
-
 template <class Value,
-          class HashFcn = SPARSEHASH_HASH<Value>,  // defined in sparseconfig.h
-          class EqualKey = STL_NAMESPACE::equal_to<Value>,
+          class HashFcn = SPARSEHASH_HASH<Value>,   // defined in sparseconfig.h
+          class EqualKey = std::equal_to<Value>,
           class Alloc = libc_allocator_with_realloc<Value> >
 class sparse_hash_set {
  private:
   // Apparently identity is not stl-standard, so we define our own
   struct Identity {
-    Value& operator()(Value& v) const { return v; }
+    typedef const Value& result_type;
     const Value& operator()(const Value& v) const { return v; }
   };
   struct SetKey {
@@ -232,21 +228,26 @@ class sparse_hash_set {
 
   size_type count(const key_type& key) const         { return rep.count(key); }
 
-  pair<iterator, iterator> equal_range(const key_type& key) const {
+  std::pair<iterator, iterator> equal_range(const key_type& key) const {
     return rep.equal_range(key);
   }
 
+
   // Insertion routines
-  pair<iterator, bool> insert(const value_type& obj) {
-    pair<typename ht::iterator, bool> p = rep.insert(obj);
-    return pair<iterator, bool>(p.first, p.second);   // const to non-const
+  std::pair<iterator, bool> insert(const value_type& obj) {
+    std::pair<typename ht::iterator, bool> p = rep.insert(obj);
+    return std::pair<iterator, bool>(p.first, p.second);   // const to non-const
+  }
+  template <class InputIterator> void insert(InputIterator f, InputIterator l) {
+    rep.insert(f, l);
+  }
+  void insert(const_iterator f, const_iterator l) {
+    rep.insert(f, l);
+  }
+  // Required for std::insert_iterator; the passed-in iterator is ignored.
+  iterator insert(iterator, const value_type& obj)   {
+    return insert(obj).first;
   }
-  template <class InputIterator>
-  void insert(InputIterator f, InputIterator l)      { rep.insert(f, l); }
-  void insert(const_iterator f, const_iterator l)    { rep.insert(f, l); }
-  // required for std::insert_iterator; the passed-in iterator is ignored
-  iterator insert(iterator, const value_type& obj)   { return insert(obj).first; }
-
 
   // Deletion routines
   // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
@@ -268,10 +269,62 @@ class sparse_hash_set {
 
 
   // I/O -- this is an add-on for writing metainformation to disk
-  bool write_metadata(FILE *fp)       { return rep.write_metadata(fp); }
-  bool read_metadata(FILE *fp)        { return rep.read_metadata(fp); }
-  bool write_nopointer_data(FILE *fp) { return rep.write_nopointer_data(fp); }
-  bool read_nopointer_data(FILE *fp)  { return rep.read_nopointer_data(fp); }
+  //
+  // For maximum flexibility, this does not assume a particular
+  // file type (though it will probably be a FILE *).  We just pass
+  // the fp through to rep.
+
+  // If your keys and values are simple enough, you can pass this
+  // serializer to serialize()/unserialize().  "Simple enough" means
+  // value_type is a POD type that contains no pointers.  Note,
+  // however, we don't try to normalize endianness.
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+
+  // serializer: a class providing operator()(OUTPUT*, const value_type&)
+  //    (writing value_type to OUTPUT).  You can specify a
+  //    NopointerSerializer object if appropriate (see above).
+  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
+  //    pointer to a class providing size_t Write(const void*, size_t),
+  //    which writes a buffer into a stream (which fp presumably
+  //    owns) and returns the number of bytes successfully written.
+  //    Note basic_ostream<not_char> is not currently supported.
+  template <typename ValueSerializer, typename OUTPUT>
+  bool serialize(ValueSerializer serializer, OUTPUT* fp) {
+    return rep.serialize(serializer, fp);
+  }
+
+  // serializer: a functor providing operator()(INPUT*, value_type*)
+  //    (reading from INPUT and into value_type).  You can specify a
+  //    NopointerSerializer object if appropriate (see above).
+  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
+  //    pointer to a class providing size_t Read(void*, size_t),
+  //    which reads into a buffer from a stream (which fp presumably
+  //    owns) and returns the number of bytes successfully read.
+  //    Note basic_istream<not_char> is not currently supported.
+  // NOTE: Since value_type is const Key, ValueSerializer
+  // may need to do a const cast in order to fill in the key.
+  // NOTE: if Key is not a POD type, the serializer MUST use
+  // placement-new to initialize its value, rather than a normal
+  // equals-assignment or similar.  (The value_type* passed into
+  // the serializer points to garbage memory.)
+  template <typename ValueSerializer, typename INPUT>
+  bool unserialize(ValueSerializer serializer, INPUT* fp) {
+    return rep.unserialize(serializer, fp);
+  }
+
+  // The four methods below are DEPRECATED.
+  // Use serialize() and unserialize() for new code.
+  template <typename OUTPUT>
+  bool write_metadata(OUTPUT *fp)       { return rep.write_metadata(fp); }
+
+  template <typename INPUT>
+  bool read_metadata(INPUT *fp)         { return rep.read_metadata(fp); }
+
+  template <typename OUTPUT>
+  bool write_nopointer_data(OUTPUT *fp) { return rep.write_nopointer_data(fp); }
+
+  template <typename INPUT>
+  bool read_nopointer_data(INPUT *fp)   { return rep.read_nopointer_data(fp); }
 };
 
 template <class Val, class HashFcn, class EqualKey, class Alloc>

data/ext/{sparsehash-1.8.1/src/google → sparsehash-2.0.2/src/sparsehash}/sparsetable

@@ -1,10 +1,10 @@
 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ -14,7 +14,7 @@
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -28,7 +28,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Craig Silverstein
+//
 //
 // A sparsetable is a random container that implements a sparse array,
 // that is, an array that uses very little memory to store unassigned
@@ -50,39 +50,203 @@
 // because of this container's memory economy, each insert and delete
 // causes a memory reallocation.
 //
-// See doc/sparsetable.html for information about how to use this class.
+// NOTE: You should not test(), get(), or set() any index that is
+// greater than sparsetable.size().  If you need to do that, call
+// resize() first.
+//
+// --- Template parameters
+// PARAMETER   DESCRIPTION                           DEFAULT
+// T           The value of the array: the type of   --
+//             object that is stored in the array.
+//
+// GROUP_SIZE  How large each "group" in the table   48
+//             is (see below).  Larger values use
+//             a little less memory but cause most
+//             operations to be a little slower
+//
+// Alloc:      Allocator to use to allocate memory.  libc_allocator_with_realloc
+//
+// --- Model of
+// Random Access Container
+//
+// --- Type requirements
+// T must be Copy Constructible. It need not be Assignable.
+//
+// --- Public base classes
+// None.
+//
+// --- Members
+// Type members
+//
+// MEMBER           WHERE DEFINED DESCRIPTION
+// value_type       container     The type of object, T, stored in the array
+// allocator_type   container     Allocator to use
+// pointer          container     Pointer to p
+// const_pointer    container     Const pointer to p
+// reference        container     Reference to t
+// const_reference  container     Const reference to t
+// size_type        container     An unsigned integral type
+// difference_type  container     A signed integral type
+// iterator [*]     container     Iterator used to iterate over a sparsetable
+// const_iterator   container     Const iterator used to iterate over a table
+// reverse_iterator reversible    Iterator used to iterate backwards over
+//                  container     a sparsetable
+// const_reverse_iterator   reversible container   Guess
+// nonempty_iterator [+]           sparsetable     Iterates over assigned
+//                                                 array elements only
+// const_nonempty_iterator         sparsetable     Iterates over assigned
+//                                                 array elements only
+// reverse_nonempty_iterator       sparsetable     Iterates backwards over
+//                                                 assigned array elements only
+// const_reverse_nonempty_iterator sparsetable     Iterates backwards over
+//                                                 assigned array elements only
+//
+// [*] All iterators are const in a sparsetable (though nonempty_iterators
+//     may not be).  Use get() and set() to assign values, not iterators.
+//
+// [+] iterators are random-access iterators.  nonempty_iterators are
+//     bidirectional iterators.
 
-#ifndef _SPARSETABLE_H_
-#define _SPARSETABLE_H_
+// Iterator members
+// MEMBER              WHERE DEFINED  DESCRIPTION
+//
+// iterator begin()    container      An iterator to the beginning of the table
+// iterator end()      container      An iterator to the end of the table
+// const_iterator      container      A const_iterator pointing to the
+//   begin() const                    beginning of a sparsetable
+// const_iterator      container      A const_iterator pointing to the
+//   end() const                      end of a sparsetable
+//
+// reverse_iterator          reversable     Points to beginning of a reversed
+//   rbegin()                container      sparsetable
+// reverse_iterator          reversable     Points to end of a reversed table
+//   rend()                  container
+// const_reverse_iterator    reversable     Points to beginning of a
+//   rbegin() const          container      reversed sparsetable
+// const_reverse_iterator    reversable     Points to end of a reversed table
+//   rend() const            container
+//
+// nonempty_iterator         sparsetable    Points to first assigned element
+//    begin()                               of a sparsetable
+// nonempty_iterator         sparsetable    Points past last assigned element
+//    end()                                 of a sparsetable
+// const_nonempty_iterator   sparsetable    Points to first assigned element
+//    begin() const                         of a sparsetable
+// const_nonempty_iterator   sparsetable    Points past last assigned element
+//    end() const                           of a sparsetable
+//
+// reverse_nonempty_iterator sparsetable    Points to first assigned element
+//    begin()                               of a reversed sparsetable
+// reverse_nonempty_iterator sparsetable    Points past last assigned element
+//    end()                                 of a reversed sparsetable
+// const_reverse_nonempty_iterator sparsetable    Points to first assigned
+//    begin() const                               elt of a reversed sparsetable
+// const_reverse_nonempty_iterator sparsetable    Points past last assigned
+//    end() const                                 elt of a reversed sparsetable
+//
+//
+// Other members
+// MEMBER                      WHERE DEFINED  DESCRIPTION
+// sparsetable()               sparsetable    A table of size 0; must resize()
+//                                            before using.
+// sparsetable(size_type size) sparsetable    A table of size size.  All
+//                                            indices are unassigned.
+// sparsetable(
+//    const sparsetable &tbl)  sparsetable    Copy constructor
+// ~sparsetable()              sparsetable    The destructor
+// sparsetable &operator=(     sparsetable    The assignment operator
+//    const sparsetable &tbl)
+//
+// void resize(size_type size) sparsetable    Grow or shrink a table to
+//                                            have size indices [*]
+//
+// void swap(sparsetable &x)   sparsetable    Swap two sparsetables
+// void swap(sparsetable &x,   sparsetable    Swap two sparsetables
+//           sparsetable &y)                  (global, not member, function)
+//
+// size_type size() const      sparsetable    Number of "buckets" in the table
+// size_type max_size() const  sparsetable    Max allowed size of a sparsetable
+// bool empty() const          sparsetable    true if size() == 0
+// size_type num_nonempty() const  sparsetable  Number of assigned "buckets"
+//
+// const_reference get(        sparsetable    Value at index i, or default
+//    size_type i) const                      value if i is unassigned
+// const_reference operator[]( sparsetable    Identical to get(i) [+]
+//    difference_type i) const
+// reference set(size_type i,  sparsetable    Set element at index i to
+//    const_reference val)                    be a copy of val
+// bool test(size_type i)      sparsetable    True if element at index i
+//    const                                   has been assigned to
+// bool test(iterator pos)     sparsetable    True if element pointed to
+//    const                                   by pos has been assigned to
+// void erase(iterator pos)    sparsetable    Set element pointed to by
+//                                            pos to be unassigned [!]
+// void erase(size_type i)     sparsetable    Set element i to be unassigned
+// void erase(iterator start,  sparsetable    Erases all elements between
+//            iterator end)                   start and end
+// void clear()                sparsetable    Erases all elements in the table
+//
+// I/O versions exist for both FILE* and for File* (Google2-style files):
+// bool write_metadata(FILE *fp) sparsetable  Writes a sparsetable to the
+// bool write_metadata(File *fp)              given file.  true if write
+//                                            completes successfully
+// bool read_metadata(FILE *fp) sparsetable   Replaces sparsetable with
+// bool read_metadata(File *fp)               version read from fp.  true
+//                                            if read completes sucessfully
+// bool write_nopointer_data(FILE *fp)        Read/write the data stored in
+// bool read_nopointer_data(FILE*fp)          the table, if it's simple
+//
+// bool operator==(            forward        Tests two tables for equality.
+//    const sparsetable &t1,   container      This is a global function,
+//    const sparsetable &t2)                  not a member function.
+// bool operator<(             forward        Lexicographical comparison.
+//    const sparsetable &t1,   container      This is a global function,
+//    const sparsetable &t2)                  not a member function.
+//
+// [*] If you shrink a sparsetable using resize(), assigned elements
+// past the end of the table are removed using erase().  If you grow
+// a sparsetable, new unassigned indices are created.
+//
+// [+] Note that operator[] returns a const reference.  You must use
+// set() to change the value of a table element.
+//
+// [!] Unassignment also calls the destructor.
+//
+// Iterators are invalidated whenever an item is inserted or
+// deleted (ie set() or erase() is used) or when the size of
+// the table changes (ie resize() or clear() is used).
+//
+// See doc/sparsetable.html for more information about how to use this class.
+
+// Note: this uses STL style for naming, rather than Google naming.
+// That's because this is an STL-y container
+
+#ifndef UTIL_GTL_SPARSETABLE_H_
+#define UTIL_GTL_SPARSETABLE_H_
 
-#include <google/sparsehash/sparseconfig.h>
+#include <sparsehash/internal/sparseconfig.h>
 #include <stdlib.h>             // for malloc/free
 #include <stdio.h>              // to read/write tables
+#include <string.h>             // for memcpy
 #ifdef HAVE_STDINT_H
-#include <stdint.h>             // the normal place uint16_t is defined
+#include <stdint.h>         // the normal place uint16_t is defined
 #endif
 #ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>          // the normal place u_int16_t is defined
+#include <sys/types.h>      // the normal place u_int16_t is defined
 #endif
 #ifdef HAVE_INTTYPES_H
-#include <inttypes.h>           // a third place for uint16_t or u_int16_t
+#include <inttypes.h>       // a third place for uint16_t or u_int16_t
 #endif
 #include <assert.h>             // for bounds checking
 #include <iterator>             // to define reverse_iterator for me
 #include <algorithm>            // equal, lexicographical_compare, swap,...
-#include <memory>               // uninitialized_copy
+#include <memory>               // uninitialized_copy, uninitialized_fill
 #include <vector>               // a sparsetable is a vector of groups
-#include <google/sparsehash/libc_allocator_with_realloc.h>
-#include <google/type_traits.h> // for true_type, integral_constant, etc.
-
-#if STDC_HEADERS
-#include <string.h>             // for memcpy
-#else
-#if !HAVE_MEMCPY
-#define memcpy(d, s, n)   bcopy ((s), (d), (n))
-#endif
-#endif
+#include <sparsehash/type_traits.h>
+#include <sparsehash/internal/hashtable-common.h>
+#include <sparsehash/internal/libc_allocator_with_realloc.h>
 
+// A lot of work to get a type that's guaranteed to be 16 bits...
 #ifndef HAVE_U_INT16_T
 # if defined HAVE_UINT16_T
     typedef uint16_t u_int16_t;    // true on solaris, possibly other C99 libc's
@@ -98,8 +262,15 @@
 
 _START_GOOGLE_NAMESPACE_
 
-using STL_NAMESPACE::vector;
-using STL_NAMESPACE::uninitialized_copy;
+namespace base {   // just to make google->opensource transition easier
+using GOOGLE_NAMESPACE::true_type;
+using GOOGLE_NAMESPACE::false_type;
+using GOOGLE_NAMESPACE::integral_constant;
+using GOOGLE_NAMESPACE::has_trivial_copy;
+using GOOGLE_NAMESPACE::has_trivial_destructor;
+using GOOGLE_NAMESPACE::is_same;
+}
+
 
 // The smaller this is, the faster lookup is (because the group bitmap is
 // smaller) and the faster insert is, because there's less to move.
@@ -108,6 +279,11 @@ using STL_NAMESPACE::uninitialized_copy;
 static const u_int16_t DEFAULT_SPARSEGROUP_SIZE = 48;   // fits in 1.5 words
 
 
+// Our iterator as simple as iterators can be: basically it's just
+// the index into our table.  Dereference, the only complicated
+// thing, we punt to the table class.  This just goes to show how
+// much machinery STL requires to do even the most trivial tasks.
+//
 // A NOTE ON ASSIGNING:
 // A sparse table does not actually allocate memory for entries
 // that are not filled.  Because of this, it becomes complicated
@@ -157,7 +333,7 @@ class table_iterator {
  public:
   typedef table_iterator iterator;
 
-  typedef STL_NAMESPACE::random_access_iterator_tag iterator_category;
+  typedef std::random_access_iterator_tag iterator_category;
   typedef typename tabletype::value_type value_type;
   typedef typename tabletype::difference_type difference_type;
   typedef typename tabletype::size_type size_type;
@@ -240,7 +416,7 @@ class const_table_iterator {
   typedef table_iterator<tabletype> iterator;
   typedef const_table_iterator const_iterator;
 
-  typedef STL_NAMESPACE::random_access_iterator_tag iterator_category;
+  typedef std::random_access_iterator_tag iterator_category;
   typedef typename tabletype::value_type value_type;
   typedef typename tabletype::difference_type difference_type;
   typedef typename tabletype::size_type size_type;
@@ -351,7 +527,7 @@ class two_d_iterator {
  public:
   typedef two_d_iterator iterator;
 
-  typedef STL_NAMESPACE::bidirectional_iterator_tag iterator_category;
+  typedef std::bidirectional_iterator_tag iterator_category;
   // apparently some versions of VC++ have trouble with two ::'s in a typename
   typedef typename containertype::value_type _tmp_vt;
   typedef typename _tmp_vt::value_type value_type;
@@ -442,7 +618,7 @@ class const_two_d_iterator {
  public:
   typedef const_two_d_iterator iterator;
 
-  typedef STL_NAMESPACE::bidirectional_iterator_tag iterator_category;
+  typedef std::bidirectional_iterator_tag iterator_category;
   // apparently some versions of VC++ have trouble with two ::'s in a typename
   typedef typename containertype::value_type _tmp_vt;
   typedef typename _tmp_vt::value_type value_type;
@@ -529,7 +705,7 @@ class destructive_two_d_iterator {
  public:
   typedef destructive_two_d_iterator iterator;
 
-  typedef STL_NAMESPACE::input_iterator_tag iterator_category;
+  typedef std::input_iterator_tag iterator_category;
   // apparently some versions of VC++ have trouble with two ::'s in a typename
   typedef typename containertype::value_type _tmp_vt;
   typedef typename _tmp_vt::value_type value_type;
@@ -623,22 +799,6 @@ class destructive_two_d_iterator {
 // the array (from 1 .. # of non-empty buckets in the group) is
 // called its "offset."
 
-// The weird mod in the offset is entirely to quiet compiler warnings
-// as is the cast to int after doing the "x mod 256"
-#define PUT_(take_from, offset)  do {                                          \
-  if (putc(static_cast<int>(((take_from) >> ((offset) % (sizeof(take_from)*8)))\
-                             % 256), fp)                                       \
-      == EOF)                                                                  \
-    return false;                                                              \
-} while (0)
-
-#define GET_(add_to, offset)  do {                                            \
-  if ((x=getc(fp)) == EOF)                                                    \
-    return false;                                                             \
-  else                                                                        \
-    add_to |= (static_cast<size_type>(x) << ((offset) % (sizeof(add_to)*8))); \
-} while (0)
-
 template <class T, u_int16_t GROUP_SIZE, class Alloc>
 class sparsegroup {
  private:
@@ -660,15 +820,15 @@ class sparsegroup {
       element_adaptor;
   typedef u_int16_t size_type;                  // max # of buckets
   typedef int16_t difference_type;
-  typedef STL_NAMESPACE::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef STL_NAMESPACE::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;   // from iterator.h
 
   // These are our special iterators, that go over non-empty buckets in a
   // group.  These aren't const-only because you can change non-empty bcks.
   typedef pointer nonempty_iterator;
   typedef const_pointer const_nonempty_iterator;
-  typedef STL_NAMESPACE::reverse_iterator<nonempty_iterator> reverse_nonempty_iterator;
-  typedef STL_NAMESPACE::reverse_iterator<const_nonempty_iterator> const_reverse_nonempty_iterator;
+  typedef std::reverse_iterator<nonempty_iterator> reverse_nonempty_iterator;
+  typedef std::reverse_iterator<const_nonempty_iterator> const_reverse_nonempty_iterator;
 
   // Iterator functions
   iterator begin()                      { return iterator(this, 0); }
@@ -683,8 +843,12 @@ class sparsegroup {
   // We'll have versions for our special non-empty iterator too
   nonempty_iterator nonempty_begin()             { return group; }
   const_nonempty_iterator nonempty_begin() const { return group; }
-  nonempty_iterator nonempty_end()               { return group + num_buckets; }
-  const_nonempty_iterator nonempty_end() const   { return group + num_buckets; }
+  nonempty_iterator nonempty_end() {
+    return group + settings.num_buckets;
+  }
+  const_nonempty_iterator nonempty_end() const {
+    return group + settings.num_buckets;
+  }
   reverse_nonempty_iterator nonempty_rbegin() {
     return reverse_nonempty_iterator(nonempty_end());
   }
@@ -716,13 +880,12 @@ class sparsegroup {
   void bmclear(size_type i)        { bitmap[charbit(i)] &= ~modbit(i); }
 
   pointer allocate_group(size_type n) {
-    pointer retval = allocator.allocate(n);
+    pointer retval = settings.allocate(n);
     if (retval == NULL) {
       // We really should use PRIuS here, but I don't want to have to add
       // a whole new configure option, with concomitant macro namespace
       // pollution, just to print this (unlikely) error message.  So I cast.
-      fprintf(stderr, "sparsehash: FATAL ERROR: "
-              "failed to allocate %lu groups\n",
+      fprintf(stderr, "sparsehash FATAL ERROR: failed to allocate %lu groups\n",
               static_cast<unsigned long>(n));
       exit(1);
     }
@@ -731,26 +894,17 @@ class sparsegroup {
 
   void free_group() {
     if (!group)  return;
-    pointer end_it = group + num_buckets;
+    pointer end_it = group + settings.num_buckets;
     for (pointer p = group; p != end_it; ++p)
       p->~value_type();
-    allocator.deallocate(group, num_buckets);
+    settings.deallocate(group, settings.num_buckets);
     group = NULL;
   }
 
- public:                         // get_iter() in sparsetable needs it
-  // We need a small function that tells us how many set bits there are
-  // in positions 0..i-1 of the bitmap.  It uses a big table.
-  // We make it static so templates don't allocate lots of these tables.
-  // There are lots of ways to do this calculation (called 'popcount').
-  // The 8-bit table lookup is one of the fastest, though this
-  // implementation suffers from not doing any loop unrolling.  See, eg,
-  //   http://www.dalkescientific.com/writings/diary/archive/2008/07/03/hakmem_and_other_popcounts.html
-  //   http://gurmeetsingh.wordpress.com/2008/08/05/fast-bit-counting-routines/
-  static size_type pos_to_offset(const unsigned char *bm, size_type pos) {
+  static size_type bits_in_char(unsigned char c) {
     // We could make these ints.  The tradeoff is size (eg does it overwhelm
-    // the cache?) vs efficiency in referencing sub-word-sized array elements
-    static const char bits_in[256] = {      // # of bits set in one char
+    // the cache?) vs efficiency in referencing sub-word-sized array elements.
+    static const char bits_in[256] = {
       0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
@@ -768,30 +922,77 @@ class sparsegroup {
       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
       4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
     };
+    return bits_in[c];
+  }
+
+ public:                         // get_iter() in sparsetable needs it
+  // We need a small function that tells us how many set bits there are
+  // in positions 0..i-1 of the bitmap.  It uses a big table.
+  // We make it static so templates don't allocate lots of these tables.
+  // There are lots of ways to do this calculation (called 'popcount').
+  // The 8-bit table lookup is one of the fastest, though this
+  // implementation suffers from not doing any loop unrolling.  See, eg,
+  //   http://www.dalkescientific.com/writings/diary/archive/2008/07/03/hakmem_and_other_popcounts.html
+  //   http://gurmeetsingh.wordpress.com/2008/08/05/fast-bit-counting-routines/
+  static size_type pos_to_offset(const unsigned char *bm, size_type pos) {
     size_type retval = 0;
 
     // [Note: condition pos > 8 is an optimization; convince yourself we
     // give exactly the same result as if we had pos >= 8 here instead.]
-    for ( ; pos > 8; pos -= 8 )                    // bm[0..pos/8-1]
-      retval += bits_in[*bm++];                    // chars we want *all* bits in
-    return retval + bits_in[*bm & ((1 << pos)-1)]; // the char that includes pos
+    for ( ; pos > 8; pos -= 8 )                   // bm[0..pos/8-1]
+      retval += bits_in_char(*bm++);              // chars we want *all* bits in
+    return retval + bits_in_char(*bm & ((1 << pos)-1));    // char including pos
   }
 
-  size_type pos_to_offset(size_type pos) const {   // not static but still const
+  size_type pos_to_offset(size_type pos) const {  // not static but still const
     return pos_to_offset(bitmap, pos);
   }
 
+  // Returns the (logical) position in the bm[] array, i, such that
+  // bm[i] is the offset-th set bit in the array.  It is the inverse
+  // of pos_to_offset.  get_pos() uses this function to find the index
+  // of an nonempty_iterator in the table.  Bit-twiddling from
+  // http://hackersdelight.org/basics.pdf
+  static size_type offset_to_pos(const unsigned char *bm, size_type offset) {
+    size_type retval = 0;
+    // This is sizeof(this->bitmap).
+    const size_type group_size = (GROUP_SIZE-1) / 8 + 1;
+    for (size_type i = 0; i < group_size; i++) {   // forward scan
+      const size_type pop_count = bits_in_char(*bm);
+      if (pop_count > offset) {
+        unsigned char last_bm = *bm;
+        for (; offset > 0; offset--) {
+          last_bm &= (last_bm-1);  // remove right-most set bit
+        }
+        // Clear all bits to the left of the rightmost bit (the &),
+        // and then clear the rightmost bit but set all bits to the
+        // right of it (the -1).
+        last_bm = (last_bm & -last_bm) - 1;
+        retval += bits_in_char(last_bm);
+        return retval;
+      }
+      offset -= pop_count;
+      retval += 8;
+      bm++;
+    }
+    return retval;
+  }
+
+  size_type offset_to_pos(size_type offset) const {
+    return offset_to_pos(bitmap, offset);
+  }
+
 
  public:
   // Constructors -- default and copy -- and destructor
-  sparsegroup(allocator_type& a) : allocator(a), group(0), num_buckets(0) {
+  explicit sparsegroup(allocator_type& a) :
+      group(0), settings(alloc_impl<value_alloc_type>(a)) {
     memset(bitmap, 0, sizeof(bitmap));
   }
-  sparsegroup(const sparsegroup& x)
-      : allocator(x.allocator), group(0), num_buckets(x.num_buckets) {
-    if ( num_buckets ) {
-      group = allocate_group(x.num_buckets);
-      uninitialized_copy(x.group, x.group + x.num_buckets, group);
+  sparsegroup(const sparsegroup& x) : group(0), settings(x.settings) {
+    if ( settings.num_buckets ) {
+      group = allocate_group(x.settings.num_buckets);
+      std::uninitialized_copy(x.group, x.group + x.settings.num_buckets, group);
     }
     memcpy(bitmap, x.bitmap, sizeof(bitmap));
   }
@@ -802,25 +1003,25 @@ class sparsegroup {
   // copy constructor.
   sparsegroup &operator=(const sparsegroup& x) {
     if ( &x == this ) return *this;                    // x = x
-    if ( x.num_buckets == 0 ) {
+    if ( x.settings.num_buckets == 0 ) {
       free_group();
     } else {
-      pointer p = allocate_group(x.num_buckets);
-      uninitialized_copy(x.group, x.group + x.num_buckets, p);
+      pointer p = allocate_group(x.settings.num_buckets);
+      std::uninitialized_copy(x.group, x.group + x.settings.num_buckets, p);
       free_group();
       group = p;
     }
     memcpy(bitmap, x.bitmap, sizeof(bitmap));
-    num_buckets = x.num_buckets;
+    settings.num_buckets = x.settings.num_buckets;
     return *this;
   }
 
   // Many STL algorithms use swap instead of copy constructors
   void swap(sparsegroup& x) {
-    STL_NAMESPACE::swap(group, x.group);
+    std::swap(group, x.group);                // defined in <algorithm>
     for ( int i = 0; i < sizeof(bitmap) / sizeof(*bitmap); ++i )
-      STL_NAMESPACE::swap(bitmap[i], x.bitmap[i]);  // swap not defined on arrays
-    STL_NAMESPACE::swap(num_buckets, x.num_buckets);
+      std::swap(bitmap[i], x.bitmap[i]);      // swap not defined on arrays
+    std::swap(settings.num_buckets, x.settings.num_buckets);
     // we purposefully don't swap the allocator, which may not be swap-able
   }
 
@@ -828,7 +1029,7 @@ class sparsegroup {
   void clear() {
     free_group();
     memset(bitmap, 0, sizeof(bitmap));
-    num_buckets = 0;
+    settings.num_buckets = 0;
   }
 
   // Functions that tell you about size.  Alas, these aren't so useful
@@ -837,7 +1038,7 @@ class sparsegroup {
   size_type max_size() const       { return GROUP_SIZE; }
   bool empty() const               { return false; }
   // We also may want to know how many *used* buckets there are
-  size_type num_nonempty() const   { return num_buckets; }
+  size_type num_nonempty() const   { return settings.num_buckets; }
 
 
   // get()/set() are explicitly const/non-const.  You can use [] if
@@ -882,21 +1083,22 @@ class sparsegroup {
   // But there's no way to capture that using type_traits, so we
   // pretend that move(x, y) is equivalent to "x.~T(); new(x) T(y);"
   // which is pretty much correct, if a bit conservative.)
-  void set_aux(size_type offset, true_type) {
-    group = allocator.realloc_or_die(group, num_buckets+1);
+  void set_aux(size_type offset, base::true_type) {
+    group = settings.realloc_or_die(group, settings.num_buckets+1);
     // This is equivalent to memmove(), but faster on my Intel P4,
     // at least with gcc4.1 -O2 / glibc 2.3.6.
-    for (size_type i = num_buckets; i > offset; --i)
+    for (size_type i = settings.num_buckets; i > offset; --i)
       memcpy(group + i, group + i-1, sizeof(*group));
   }
 
   // Create space at group[offset], without special assumptions about value_type
   // and allocator_type.
-  void set_aux(size_type offset, false_type) {
+  void set_aux(size_type offset, base::false_type) {
     // This is valid because 0 <= offset <= num_buckets
-    pointer p = allocate_group(num_buckets + 1);
-    uninitialized_copy(group, group + offset, p);
-    uninitialized_copy(group + offset, group + num_buckets, p + offset + 1);
+    pointer p = allocate_group(settings.num_buckets + 1);
+    std::uninitialized_copy(group, group + offset, p);
+    std::uninitialized_copy(group + offset, group + settings.num_buckets,
+                            p + offset + 1);
     free_group();
     group = p;
   }
@@ -911,14 +1113,15 @@ class sparsegroup {
       // Delete the old value, which we're replacing with the new one
       group[offset].~value_type();
     } else {
-      typedef integral_constant<bool,
-          (has_trivial_copy<value_type>::value &&
-           has_trivial_destructor<value_type>::value &&
-           is_same<allocator_type,
-                   libc_allocator_with_realloc<value_type> >::value)>
+      typedef base::integral_constant<bool,
+          (base::has_trivial_copy<value_type>::value &&
+           base::has_trivial_destructor<value_type>::value &&
+           base::is_same<
+               allocator_type,
+               libc_allocator_with_realloc<value_type> >::value)>
           realloc_and_memmove_ok; // we pretend mv(x,y) == "x.~T(); new(x) T(y)"
       set_aux(offset, realloc_and_memmove_ok());
-      ++num_buckets;
+      ++settings.num_buckets;
       bmset(i);
     }
     // This does the actual inserting.  Since we made the array using
@@ -943,25 +1146,26 @@ class sparsegroup {
   // there's no way to capture that using type_traits, so we pretend
   // that move(x, y) is equivalent to ""x.~T(); new(x) T(y);"
   // which is pretty much correct, if a bit conservative.)
-  void erase_aux(size_type offset, true_type) {
+  void erase_aux(size_type offset, base::true_type) {
     // This isn't technically necessary, since we know we have a
     // trivial destructor, but is a cheap way to get a bit more safety.
     group[offset].~value_type();
     // This is equivalent to memmove(), but faster on my Intel P4,
     // at lesat with gcc4.1 -O2 / glibc 2.3.6.
-    assert(num_buckets > 0);
-    for (size_type i = offset; i < num_buckets-1; ++i)
+    assert(settings.num_buckets > 0);
+    for (size_type i = offset; i < settings.num_buckets-1; ++i)
       memcpy(group + i, group + i+1, sizeof(*group));  // hopefully inlined!
-    group = allocator.realloc_or_die(group, num_buckets-1);
+    group = settings.realloc_or_die(group, settings.num_buckets-1);
   }
 
   // Shrink the array, without any special assumptions about value_type and
   // allocator_type.
-  void erase_aux(size_type offset, false_type) {
+  void erase_aux(size_type offset, base::false_type) {
     // This is valid because 0 <= offset < num_buckets. Note the inequality.
-    pointer p = allocate_group(num_buckets - 1);
-    uninitialized_copy(group, group + offset, p);
-    uninitialized_copy(group + offset + 1, group + num_buckets, p + offset);
+    pointer p = allocate_group(settings.num_buckets - 1);
+    std::uninitialized_copy(group, group + offset, p);
+    std::uninitialized_copy(group + offset + 1, group + settings.num_buckets,
+                            p + offset);
     free_group();
     group = p;
   }
@@ -972,22 +1176,22 @@ class sparsegroup {
   // TODO(austern): Make this exception safe: handle exceptions from
   // value_type's copy constructor.
   void erase(size_type i) {
-    if ( bmtest(i) ) {                          // trivial to erase empty bucket
+    if ( bmtest(i) ) {                         // trivial to erase empty bucket
       size_type offset = pos_to_offset(bitmap,i); // where we'll find (or insert)
-      if ( num_buckets == 1 ) {
+      if ( settings.num_buckets == 1 ) {
         free_group();
         group = NULL;
       } else {
-        typedef integral_constant<bool,
-            (has_trivial_copy<value_type>::value &&
-             has_trivial_destructor<value_type>::value &&
-             is_same<
+        typedef base::integral_constant<bool,
+            (base::has_trivial_copy<value_type>::value &&
+             base::has_trivial_destructor<value_type>::value &&
+             base::is_same<
                  allocator_type,
                  libc_allocator_with_realloc<value_type> >::value)>
             realloc_and_memmove_ok; // pretend mv(x,y) == "x.~T(); new(x) T(y)"
         erase_aux(offset, realloc_and_memmove_ok());
       }
-      --num_buckets;
+      --settings.num_buckets;
       bmclear(i);
     }
   }
@@ -1008,64 +1212,68 @@ class sparsegroup {
   // We support reading and writing groups to disk.  We don't store
   // the actual array contents (which we don't know how to store),
   // just the bitmap and size.  Meant to be used with table I/O.
-  // Returns true if all was ok
-  bool write_metadata(FILE *fp) const {
-    assert(sizeof(num_buckets) == 2);     // we explicitly set to u_int16_t
-    PUT_(num_buckets, 8);
-    PUT_(num_buckets, 0);
-    if ( !fwrite(bitmap, sizeof(bitmap), 1, fp) )  return false;
+
+  template <typename OUTPUT> bool write_metadata(OUTPUT *fp) const {
+    // we explicitly set to u_int16_t
+    assert(sizeof(settings.num_buckets) == 2);
+    if ( !sparsehash_internal::write_bigendian_number(fp, settings.num_buckets,
+                                                      2) )
+      return false;
+    if ( !sparsehash_internal::write_data(fp, bitmap, sizeof(bitmap)) )
+      return false;
     return true;
   }
 
-  // Reading destroys the old group contents!  Returns true if all was ok
-  bool read_metadata(FILE *fp) {
+  // Reading destroys the old group contents!  Returns true if all was ok.
+  template <typename INPUT> bool read_metadata(INPUT *fp) {
     clear();
-
-    int x;          // the GET_ macro requires an 'int x' to be defined
-    GET_(num_buckets, 8);
-    GET_(num_buckets, 0);
-
-    if ( !fread(bitmap, sizeof(bitmap), 1, fp) )  return false;
-
+    if ( !sparsehash_internal::read_bigendian_number(fp, &settings.num_buckets,
+                                                     2) )
+      return false;
+    if ( !sparsehash_internal::read_data(fp, bitmap, sizeof(bitmap)) )
+      return false;
     // We'll allocate the space, but we won't fill it: it will be
     // left as uninitialized raw memory.
-    group = allocate_group(num_buckets);
+    group = allocate_group(settings.num_buckets);
     return true;
   }
 
+  // Again, only meaningful if value_type is a POD.
+  template <typename INPUT> bool read_nopointer_data(INPUT *fp) {
+     for ( nonempty_iterator it = nonempty_begin();
+           it != nonempty_end(); ++it ) {
+       if ( !sparsehash_internal::read_data(fp, &(*it), sizeof(*it)) )
+         return false;
+     }
+     return true;
+  }
+
   // If your keys and values are simple enough, we can write them
   // to disk for you.  "simple enough" means POD and no pointers.
-  // However, we don't try to normalize endianness
-  bool write_nopointer_data(FILE *fp) const {
+  // However, we don't try to normalize endianness.
+  template <typename OUTPUT> bool write_nopointer_data(OUTPUT *fp) const {
     for ( const_nonempty_iterator it = nonempty_begin();
           it != nonempty_end(); ++it ) {
-      if ( !fwrite(&*it, sizeof(*it), 1, fp) )  return false;
-    }
-    return true;
-  }
-
-  // When reading, we have to override the potential const-ness of *it.
-  // Again, only meaningful if value_type is a POD.
-  bool read_nopointer_data(FILE *fp) {
-    for ( nonempty_iterator it = nonempty_begin();
-          it != nonempty_end(); ++it ) {
-      if ( !fread(reinterpret_cast<void*>(&(*it)), sizeof(*it), 1, fp) )
+      if ( !sparsehash_internal::write_data(fp, &(*it), sizeof(*it)) )
         return false;
     }
     return true;
   }
 
-  // Comparisons.  Note the comparisons are pretty arbitrary: we
-  // compare values of the first index that isn't equal (using default
+
+  // Comparisons.  We only need to define == and < -- we get
+  // != > <= >= via relops.h (which we happily included above).
+  // Note the comparisons are pretty arbitrary: we compare
+  // values of the first index that isn't equal (using default
   // value for empty buckets).
   bool operator==(const sparsegroup& x) const {
-    return ( num_buckets == x.num_buckets &&
+    return ( settings.num_buckets == x.settings.num_buckets &&
              memcmp(bitmap, x.bitmap, sizeof(bitmap)) == 0 &&
-             STL_NAMESPACE::equal(begin(), end(), x.begin()) ); // from algorithm
+             std::equal(begin(), end(), x.begin()) );    // from <algorithm>
   }
-  bool operator<(const sparsegroup& x) const {      // also from algorithm
-    return STL_NAMESPACE::lexicographical_compare(begin(), end(), 
-                                                  x.begin(), x.end());
+
+  bool operator<(const sparsegroup& x) const {      // also from <algorithm>
+    return std::lexicographical_compare(begin(), end(), x.begin(), x.end());
   }
   bool operator!=(const sparsegroup& x) const { return !(*this == x); }
   bool operator<=(const sparsegroup& x) const { return !(x < *this); }
@@ -1084,9 +1292,9 @@ class sparsegroup {
 
     // realloc_or_die should only be used when using the default
     // allocator (libc_allocator_with_realloc).
-    pointer realloc_or_die(pointer ptr, size_type n) {
+    pointer realloc_or_die(pointer /*ptr*/, size_type /*n*/) {
       fprintf(stderr, "realloc_or_die is only supported for "
-                      "libc_allocator_with_realloc");
+                      "libc_allocator_with_realloc\n");
       exit(1);
       return NULL;
     }
@@ -1107,23 +1315,32 @@ class sparsegroup {
     pointer realloc_or_die(pointer ptr, size_type n) {
       pointer retval = this->reallocate(ptr, n);
       if (retval == NULL) {
-        // We really should use PRIuS here, but I don't want to have to add
-        // a whole new configure option, with concomitant macro namespace
-        // pollution, just to print this (unlikely) error message.  So I cast.
         fprintf(stderr, "sparsehash: FATAL ERROR: failed to reallocate "
-                "%lu elements for ptr %p",
-                static_cast<unsigned long>(n), ptr);
+                "%lu elements for ptr %p", static_cast<unsigned long>(n), ptr);
         exit(1);
       }
       return retval;
     }
   };
 
+  // Package allocator with num_buckets to eliminate memory needed for the
+  // zero-size allocator.
+  // If new fields are added to this class, we should add them to
+  // operator= and swap.
+  class Settings : public alloc_impl<value_alloc_type> {
+   public:
+    Settings(const alloc_impl<value_alloc_type>& a, u_int16_t n = 0)
+        : alloc_impl<value_alloc_type>(a), num_buckets(n) { }
+    Settings(const Settings& s)
+        : alloc_impl<value_alloc_type>(s), num_buckets(s.num_buckets) { }
+
+    u_int16_t num_buckets;                    // limits GROUP_SIZE to 64K
+  };
+
   // The actual data
-  alloc_impl<value_alloc_type> allocator;       // allocator for memory
-  pointer group;                                // (small) array of T's
-  unsigned char bitmap[(GROUP_SIZE-1)/8 + 1];   // fancy math is so we round up
-  size_type num_buckets;                        // limits GROUP_SIZE to 64K
+  pointer group;                              // (small) array of T's
+  Settings settings;                          // allocator and num_buckets
+  unsigned char bitmap[(GROUP_SIZE-1)/8 + 1]; // fancy math is so we round up
 };
 
 // We need a global swap as well
@@ -1159,26 +1376,26 @@ class sparsetable {
       const_iterator;
   typedef table_element_adaptor<sparsetable<T, GROUP_SIZE, Alloc> >
       element_adaptor;
-  typedef STL_NAMESPACE::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef STL_NAMESPACE::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;   // from iterator.h
 
   // These are our special iterators, that go over non-empty buckets in a
   // table.  These aren't const only because you can change non-empty bcks.
-  typedef two_d_iterator< vector< sparsegroup<value_type, GROUP_SIZE,
-                                              value_alloc_type>,
+  typedef two_d_iterator< std::vector< sparsegroup<value_type, GROUP_SIZE,
+                                                   value_alloc_type>,
                                   vector_alloc> >
      nonempty_iterator;
-  typedef const_two_d_iterator< vector< sparsegroup<value_type,
-                                                    GROUP_SIZE,
-                                                    value_alloc_type>,
+  typedef const_two_d_iterator< std::vector< sparsegroup<value_type,
+                                                         GROUP_SIZE,
+                                                         value_alloc_type>,
                                         vector_alloc> >
      const_nonempty_iterator;
-  typedef STL_NAMESPACE::reverse_iterator<nonempty_iterator> reverse_nonempty_iterator;
-  typedef STL_NAMESPACE::reverse_iterator<const_nonempty_iterator> const_reverse_nonempty_iterator;
+  typedef std::reverse_iterator<nonempty_iterator> reverse_nonempty_iterator;
+  typedef std::reverse_iterator<const_nonempty_iterator> const_reverse_nonempty_iterator;
   // Another special iterator: it frees memory as it iterates (used to resize)
-  typedef destructive_two_d_iterator< vector< sparsegroup<value_type,
-                                                          GROUP_SIZE,
-                                                          value_alloc_type>,
+  typedef destructive_two_d_iterator< std::vector< sparsegroup<value_type,
+                                                               GROUP_SIZE,
+                                                               value_alloc_type>,
                                               vector_alloc> >
      destructive_iterator;
 
@@ -1225,7 +1442,7 @@ class sparsetable {
   }
 
   typedef sparsegroup<value_type, GROUP_SIZE, allocator_type> group_type;
-  typedef vector<group_type, vector_alloc > group_vector_type;
+  typedef std::vector<group_type, vector_alloc > group_vector_type;
 
   typedef typename group_vector_type::reference GroupsReference;
   typedef typename group_vector_type::const_reference GroupsConstReference;
@@ -1252,19 +1469,18 @@ class sparsetable {
 
  public:
   // Constructors -- default, normal (when you specify size), and copy
-  sparsetable(size_type sz = 0, Alloc alloc = Alloc())
-      : groups(vector_alloc(alloc)),
-        table_size(sz), num_buckets(0), allocator(alloc) {
-    groups.resize(num_groups(sz), group_type(allocator));
+  explicit sparsetable(size_type sz = 0, Alloc alloc = Alloc())
+      : groups(vector_alloc(alloc)), settings(alloc, sz) {
+    groups.resize(num_groups(sz), group_type(settings));
   }
   // We can get away with using the default copy constructor,
   // and default destructor, and hence the default operator=.  Huzzah!
 
   // Many STL algorithms use swap instead of copy constructors
   void swap(sparsetable& x) {
-    STL_NAMESPACE::swap(groups, x.groups);
-    STL_NAMESPACE::swap(table_size, x.table_size);
-    STL_NAMESPACE::swap(num_buckets, x.num_buckets);
+    std::swap(groups, x.groups);              // defined in stl_algobase.h
+    std::swap(settings.table_size, x.settings.table_size);
+    std::swap(settings.num_buckets, x.settings.num_buckets);
   }
 
   // It's always nice to be able to clear a table without deallocating it
@@ -1273,41 +1489,45 @@ class sparsetable {
     for ( group = groups.begin(); group != groups.end(); ++group ) {
       group->clear();
     }
-    num_buckets = 0;
+    settings.num_buckets = 0;
   }
 
   // ACCESSOR FUNCTIONS for the things we templatize on, basically
-  allocator_type get_allocator() const    { return allocator; }
+  allocator_type get_allocator() const {
+    return allocator_type(settings);
+  }
 
 
   // Functions that tell you about size.
   // NOTE: empty() is non-intuitive!  It does not tell you the number
   // of not-empty buckets (use num_nonempty() for that).  Instead
   // it says whether you've allocated any buckets or not.
-  size_type size() const           { return table_size; }
-  size_type max_size() const       { return allocator.max_size(); }
-  bool empty() const               { return table_size == 0; }
+  size_type size() const           { return settings.table_size; }
+  size_type max_size() const       { return settings.max_size(); }
+  bool empty() const               { return settings.table_size == 0; }
   // We also may want to know how many *used* buckets there are
-  size_type num_nonempty() const   { return num_buckets; }
+  size_type num_nonempty() const   { return settings.num_buckets; }
 
   // OK, we'll let you resize one of these puppies
   void resize(size_type new_size) {
-    groups.resize(num_groups(new_size), group_type(allocator));
-    if ( new_size < table_size) {   // lower num_buckets, clear last group
+    groups.resize(num_groups(new_size), group_type(settings));
+    if ( new_size < settings.table_size) {
+      // lower num_buckets, clear last group
       if ( pos_in_group(new_size) > 0 )     // need to clear inside last group
         groups.back().erase(groups.back().begin() + pos_in_group(new_size),
                             groups.back().end());
-      num_buckets = 0;                       // refigure # of used buckets
+      settings.num_buckets = 0;                   // refigure # of used buckets
       GroupsConstIterator group;
       for ( group = groups.begin(); group != groups.end(); ++group )
-        num_buckets += group->num_nonempty();
+        settings.num_buckets += group->num_nonempty();
     }
-    table_size = new_size;
+    settings.table_size = new_size;
   }
 
 
   // We let you see if a bucket is non-empty without retrieving it
   bool test(size_type i) const {
+    assert(i < settings.table_size);
     return which_group(i).test(pos_in_group(i));
   }
   bool test(iterator pos) const {
@@ -1320,7 +1540,7 @@ class sparsetable {
   // We only return const_references because it's really hard to
   // return something settable for empty buckets.  Use set() instead.
   const_reference get(size_type i) const {
-    assert(i < table_size);
+    assert(i < settings.table_size);
     return which_group(i).get(pos_in_group(i));
   }
 
@@ -1328,17 +1548,17 @@ class sparsetable {
   // This is used by sparse_hashtable to get an element from the table
   // when we know it exists (because the caller has called test(i)).
   const_reference unsafe_get(size_type i) const {
-    assert(i < table_size);
+    assert(i < settings.table_size);
     assert(test(i));
     return which_group(i).unsafe_get(pos_in_group(i));
   }
 
   // TODO(csilvers): make protected + friend element_adaptor
   reference mutating_get(size_type i) {    // fills bucket i before getting
-    assert(i < table_size);
-    size_type old_numbuckets = which_group(i).num_nonempty();
+    assert(i < settings.table_size);
+    typename group_type::size_type old_numbuckets = which_group(i).num_nonempty();
     reference retval = which_group(i).mutating_get(pos_in_group(i));
-    num_buckets += which_group(i).num_nonempty() - old_numbuckets;
+    settings.num_buckets += which_group(i).num_nonempty() - old_numbuckets;
     return retval;
   }
 
@@ -1370,24 +1590,33 @@ class sparsetable {
        groups[group_num(i)].pos_to_offset(pos_in_group(i))));
   }
 
+  // And the reverse transformation.
+  size_type get_pos(const const_nonempty_iterator it) const {
+    difference_type current_row = it.row_current - it.row_begin;
+    difference_type current_col = (it.col_current -
+                                   groups[current_row].nonempty_begin());
+    return ((current_row * GROUP_SIZE) +
+            groups[current_row].offset_to_pos(current_col));
+  }
+
 
   // This returns a reference to the inserted item (which is a copy of val)
   // The trick is to figure out whether we're replacing or inserting anew
   reference set(size_type i, const_reference val) {
-    assert(i < table_size);
-    size_type old_numbuckets = which_group(i).num_nonempty();
+    assert(i < settings.table_size);
+    typename group_type::size_type old_numbuckets = which_group(i).num_nonempty();
     reference retval = which_group(i).set(pos_in_group(i), val);
-    num_buckets += which_group(i).num_nonempty() - old_numbuckets;
+    settings.num_buckets += which_group(i).num_nonempty() - old_numbuckets;
     return retval;
   }
 
   // This takes the specified elements out of the table.  This is
   // "undefining", rather than "clearing".
   void erase(size_type i) {
-    assert(i < table_size);
-    size_type old_numbuckets = which_group(i).num_nonempty();
+    assert(i < settings.table_size);
+    typename group_type::size_type old_numbuckets = which_group(i).num_nonempty();
     which_group(i).erase(pos_in_group(i));
-    num_buckets += which_group(i).num_nonempty() - old_numbuckets;
+    settings.num_buckets += which_group(i).num_nonempty() - old_numbuckets;
   }
 
   void erase(iterator pos) {
@@ -1408,7 +1637,8 @@ class sparsetable {
 
  private:
   // Every time the disk format changes, this should probably change too
-  static const unsigned long MAGIC_NUMBER = 0x24687531;
+  typedef unsigned long MagicNumberType;
+  static const MagicNumberType MAGIC_NUMBER = 0x24687531;
 
   // Old versions of this code write all data in 32 bits.  We need to
   // support these files as well as having support for 64-bit systems.
@@ -1418,57 +1648,42 @@ class sparsetable {
   // causes us to mis-read old-version code that stores exactly
   // 0xFFFFFFF, but I don't think that is likely to have happened for
   // these particular values.
-  static bool write_32_or_64(FILE* fp, size_type value) {
+  template <typename OUTPUT, typename IntType>
+  static bool write_32_or_64(OUTPUT* fp, IntType value) {
     if ( value < 0xFFFFFFFFULL ) {        // fits in 4 bytes
-      PUT_(value, 24);
-      PUT_(value, 16);
-      PUT_(value, 8);
-      PUT_(value, 0);
-    } else if ( value == 0xFFFFFFFFUL ) {   // special case in 32bit systems
-      PUT_(0xFF, 0); PUT_(0xFF, 0); PUT_(0xFF, 0); PUT_(0xFF, 0);  // marker
-      PUT_(0, 0); PUT_(0, 0); PUT_(0, 0); PUT_(0, 0);
-      PUT_(0xFF, 0); PUT_(0xFF, 0); PUT_(0xFF, 0); PUT_(0xFF, 0);
+      if ( !sparsehash_internal::write_bigendian_number(fp, value, 4) )
+        return false;
     } else {
-      PUT_(0xFF, 0); PUT_(0xFF, 0); PUT_(0xFF, 0); PUT_(0xFF, 0);  // marker
-      PUT_(value, 56);
-      PUT_(value, 48);
-      PUT_(value, 40);
-      PUT_(value, 32);
-      PUT_(value, 24);
-      PUT_(value, 16);
-      PUT_(value, 8);
-      PUT_(value, 0);
+      if ( !sparsehash_internal::write_bigendian_number(fp, 0xFFFFFFFFUL, 4) )
+        return false;
+      if ( !sparsehash_internal::write_bigendian_number(fp, value, 8) )
+        return false;
     }
     return true;
   }
 
-  static bool read_32_or_64(FILE* fp, size_type *value) {  // reads into value
-    size_type first4 = 0;
-    int x;
-    GET_(first4, 24);
-    GET_(first4, 16);
-    GET_(first4, 8);
-    GET_(first4, 0);
+  template <typename INPUT, typename IntType>
+  static bool read_32_or_64(INPUT* fp, IntType *value) {  // reads into value
+    MagicNumberType first4 = 0;   // a convenient 32-bit unsigned type
+    if ( !sparsehash_internal::read_bigendian_number(fp, &first4, 4) )
+      return false;
     if ( first4 < 0xFFFFFFFFULL ) {
       *value = first4;
     } else {
-      GET_(*value, 56);
-      GET_(*value, 48);
-      GET_(*value, 40);
-      GET_(*value, 32);
-      GET_(*value, 24);
-      GET_(*value, 16);
-      GET_(*value, 8);
-      GET_(*value, 0);
+      if ( !sparsehash_internal::read_bigendian_number(fp, value, 8) )
+        return false;
     }
     return true;
   }
 
  public:
-  bool write_metadata(FILE *fp) const {
+  // read/write_metadata() and read_write/nopointer_data() are DEPRECATED.
+  // Use serialize() and unserialize(), below, for new code.
+
+  template <typename OUTPUT> bool write_metadata(OUTPUT *fp) const {
     if ( !write_32_or_64(fp, MAGIC_NUMBER) )  return false;
-    if ( !write_32_or_64(fp, table_size) )  return false;
-    if ( !write_32_or_64(fp, num_buckets) )  return false;
+    if ( !write_32_or_64(fp, settings.table_size) )  return false;
+    if ( !write_32_or_64(fp, settings.num_buckets) )  return false;
 
     GroupsConstIterator group;
     for ( group = groups.begin(); group != groups.end(); ++group )
@@ -1477,7 +1692,7 @@ class sparsetable {
   }
 
   // Reading destroys the old table contents!  Returns true if read ok.
-  bool read_metadata(FILE *fp) {
+  template <typename INPUT> bool read_metadata(INPUT *fp) {
     size_type magic_read = 0;
     if ( !read_32_or_64(fp, &magic_read) )  return false;
     if ( magic_read != MAGIC_NUMBER ) {
@@ -1485,10 +1700,10 @@ class sparsetable {
       return false;
     }
 
-    if ( !read_32_or_64(fp, &table_size) )  return false;
-    if ( !read_32_or_64(fp, &num_buckets) )  return false;
+    if ( !read_32_or_64(fp, &settings.table_size) )  return false;
+    if ( !read_32_or_64(fp, &settings.num_buckets) )  return false;
 
-    resize(table_size);                            // so the vector's sized ok
+    resize(settings.table_size);                    // so the vector's sized ok
     GroupsIterator group;
     for ( group = groups.begin(); group != groups.end(); ++group )
       if ( group->read_metadata(fp) == false )  return false;
@@ -1517,17 +1732,50 @@ class sparsetable {
     return true;
   }
 
+  // INPUT and OUTPUT must be either a FILE, *or* a C++ stream
+  //    (istream, ostream, etc) *or* a class providing
+  //    Read(void*, size_t) and Write(const void*, size_t)
+  //    (respectively), which writes a buffer into a stream
+  //    (which the INPUT/OUTPUT instance presumably owns).
+
+  typedef sparsehash_internal::pod_serializer<value_type> NopointerSerializer;
+
+  // ValueSerializer: a functor.  operator()(OUTPUT*, const value_type&)
+  template <typename ValueSerializer, typename OUTPUT>
+  bool serialize(ValueSerializer serializer, OUTPUT *fp) {
+    if ( !write_metadata(fp) )
+      return false;
+    for ( const_nonempty_iterator it = nonempty_begin();
+          it != nonempty_end(); ++it ) {
+      if ( !serializer(fp, *it) )  return false;
+    }
+    return true;
+  }
+
+  // ValueSerializer: a functor.  operator()(INPUT*, value_type*)
+  template <typename ValueSerializer, typename INPUT>
+  bool unserialize(ValueSerializer serializer, INPUT *fp) {
+    clear();
+    if ( !read_metadata(fp) )
+      return false;
+    for ( nonempty_iterator it = nonempty_begin();
+          it != nonempty_end(); ++it ) {
+      if ( !serializer(fp, &*it) )  return false;
+    }
+    return true;
+  }
+
   // Comparisons.  Note the comparisons are pretty arbitrary: we
   // compare values of the first index that isn't equal (using default
   // value for empty buckets).
   bool operator==(const sparsetable& x) const {
-    return ( table_size == x.table_size &&
-             num_buckets == x.num_buckets &&
+    return ( settings.table_size == x.settings.table_size &&
+             settings.num_buckets == x.settings.num_buckets &&
              groups == x.groups );
   }
-  bool operator<(const sparsetable& x) const {      // also from algobase.h
-    return STL_NAMESPACE::lexicographical_compare(begin(), end(), 
-                                                  x.begin(), x.end());
+
+  bool operator<(const sparsetable& x) const {
+    return std::lexicographical_compare(begin(), end(), x.begin(), x.end());
   }
   bool operator!=(const sparsetable& x) const { return !(*this == x); }
   bool operator<=(const sparsetable& x) const { return !(x < *this); }
@@ -1536,11 +1784,28 @@ class sparsetable {
 
 
  private:
+  // Package allocator with table_size and num_buckets to eliminate memory
+  // needed for the zero-size allocator.
+  // If new fields are added to this class, we should add them to
+  // operator= and swap.
+  class Settings : public allocator_type {
+   public:
+    typedef typename allocator_type::size_type size_type;
+
+    Settings(const allocator_type& a, size_type sz = 0, size_type n = 0)
+        : allocator_type(a), table_size(sz), num_buckets(n) { }
+
+    Settings(const Settings& s)
+        : allocator_type(s),
+          table_size(s.table_size), num_buckets(s.num_buckets) { }
+
+    size_type table_size;          // how many buckets they want
+    size_type num_buckets;         // number of non-empty buckets
+  };
+
   // The actual data
-  group_vector_type groups;      // our list of groups
-  size_type table_size;          // how many buckets they want
-  size_type num_buckets;         // number of non-empty buckets
-  allocator_type allocator;      // just passed in to sparsegroup
+  group_vector_type groups;        // our list of groups
+  Settings settings;               // allocator, table size, buckets
 };
 
 // We need a global swap as well
@@ -1550,9 +1815,6 @@ inline void swap(sparsetable<T,GROUP_SIZE,Alloc> &x,
   x.swap(y);
 }
 
-#undef GET_
-#undef PUT_
-
 _END_GOOGLE_NAMESPACE_
 
-#endif
+#endif  // UTIL_GTL_SPARSETABLE_H_