google_hash 0.8.1 → 0.8.2

data/ext/{sparsehash-1.8.1 → sparsehash-2.0.2}/src/libc_allocator_with_realloc_test.cc

@@ -1,10 +1,10 @@
 // Copyright (c) 2010, 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,16 +28,18 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Guilin Chen
 
-#include "config.h"
-#include <google/sparsehash/libc_allocator_with_realloc.h>
+#include <sparsehash/internal/sparseconfig.h>
+#include <config.h>
+#include <sparsehash/internal/libc_allocator_with_realloc.h>
 #include <stdlib.h>
-#include <iostream>
 #include <string>
 #include <vector>
+#include <iostream>
+#include "testutil.h"
 
 using std::cerr;
+using std::cout;
 using std::string;
 using std::basic_string;
 using std::char_traits;
@@ -46,14 +48,6 @@ using GOOGLE_NAMESPACE::libc_allocator_with_realloc;
 
 #define arraysize(a)  ( sizeof(a) / sizeof(*(a)) )
 
-#define EXPECT_EQ(a, b)  do {                                           \
-  if ((a) != (b)) {                                                     \
-    cerr << "Check failed: EXPECTED: " << #a << " == " << #b << ", "    \
-         << "ACTUAL: " << a << " != " << b << "\n";                     \
-    exit(1);                                                            \
-  }                                                                     \
-} while (0)
-
 namespace {
 
 typedef libc_allocator_with_realloc<int> int_alloc;
@@ -64,8 +58,7 @@ typedef basic_string<char, char_traits<char>,
                      libc_allocator_with_realloc<char> > cstring;
 typedef vector<cstring, libc_allocator_with_realloc<cstring> > cstring_vector;
 
-
-void TestAllocate() {
+TEST(LibcAllocatorWithReallocTest, Allocate) {
   int_alloc alloc;
   intp_alloc palloc;
 
@@ -92,7 +85,7 @@ void TestAllocate() {
   alloc.deallocate(p, 1024);
 }
 
-void TestSTL() {
+TEST(LibcAllocatorWithReallocTest, TestSTL) {
   // Test strings copied from base/arena_unittest.cc
   static const char* test_strings[] = {
     "aback", "abaft", "abandon", "abandoned", "abandoning",
@@ -120,10 +113,10 @@ void TestSTL() {
 
 }  // namespace
 
-int main() {
-  TestAllocate();
-  TestSTL();
-
-  cerr << "PASS\n";
+int main(int, char **) {
+  // All the work is done in the static constructors.  If they don't
+  // die, the tests have all passed.
+  cout << "PASS\n";
   return 0;
 }
+

data/ext/sparsehash-2.0.2/src/simple_compat_test.cc

@@ -0,0 +1,106 @@
+// Copyright (c) 2007, 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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * 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
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ---
+//
+// This tests mostly that we can #include the files correctly
+// and have them work.  It is like simple_test.cc but uses the
+// compatibility #include directory (google/) rather than the
+// canonical one (sparsehash/).  This unittest purposefully does
+// not #include <config.h>; it's meant to emulate what a 'regular
+// install' of sparsehash would be able to see.
+
+#include <stdio.h>
+#include <google/sparse_hash_set>
+#include <google/sparse_hash_map>
+#include <google/dense_hash_set>
+#include <google/dense_hash_map>
+#include <google/template_util.h>
+#include <google/type_traits.h>
+
+#define CHECK_IFF(cond, when) do {                                      \
+  if (when) {                                                           \
+    if (!(cond)) {                                                      \
+      puts("ERROR: " #cond " failed when " #when " is true\n");         \
+      exit(1);                                                          \
+    }                                                                   \
+  } else {                                                              \
+    if (cond) {                                                         \
+      puts("ERROR: " #cond " succeeded when " #when " is false\n");     \
+      exit(1);                                                          \
+    }                                                                   \
+  }                                                                     \
+} while (0)
+
+int main(int argc, char**) {
+  // Run with an argument to get verbose output
+  const bool verbose = argc > 1;
+
+  google::sparse_hash_set<int> sset;
+  google::sparse_hash_map<int, int> smap;
+  google::dense_hash_set<int> dset;
+  google::dense_hash_map<int, int> dmap;
+  dset.set_empty_key(-1);
+  dmap.set_empty_key(-1);
+
+  for (int i = 0; i < 100; i += 10) {   // go by tens
+    sset.insert(i);
+    smap[i] = i+1;
+    dset.insert(i + 5);
+    dmap[i+5] = i+6;
+  }
+
+  if (verbose) {
+    for (google::sparse_hash_set<int>::const_iterator it = sset.begin();
+         it != sset.end(); ++it)
+      printf("sset: %d\n", *it);
+    for (google::sparse_hash_map<int,int>::const_iterator it = smap.begin();
+         it != smap.end(); ++it)
+      printf("smap: %d -> %d\n", it->first, it->second);
+    for (google::dense_hash_set<int>::const_iterator it = dset.begin();
+         it != dset.end(); ++it)
+      printf("dset: %d\n", *it);
+    for (google::dense_hash_map<int,int>::const_iterator it = dmap.begin();
+         it != dmap.end(); ++it)
+      printf("dmap: %d -> %d\n", it->first, it->second);
+  }
+
+  for (int i = 0; i < 100; i++) {
+    CHECK_IFF(sset.find(i) != sset.end(), (i % 10) == 0);
+    CHECK_IFF(smap.find(i) != smap.end(), (i % 10) == 0);
+    CHECK_IFF(smap.find(i) != smap.end() && smap.find(i)->second == i+1,
+              (i % 10) == 0);
+    CHECK_IFF(dset.find(i) != dset.end(), (i % 10) == 5);
+    CHECK_IFF(dmap.find(i) != dmap.end(), (i % 10) == 5);
+    CHECK_IFF(dmap.find(i) != dmap.end() && dmap.find(i)->second == i+1,
+              (i % 10) == 5);
+  }
+  printf("PASS\n");
+  return 0;
+}

data/ext/{sparsehash-1.8.1 → sparsehash-2.0.2}/src/simple_test.cc

@@ -28,18 +28,21 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Craig Silverstein
 //
 // This tests mostly that we can #include the files correctly
 // and have them work.  This unittest purposefully does not
 // #include <config.h>; it's meant to emulate what a 'regular
 // install' of sparsehash would be able to see.
 
+#include <sparsehash/internal/sparseconfig.h>
+#include <config.h>
 #include <stdio.h>
-#include <google/sparse_hash_set>
-#include <google/sparse_hash_map>
-#include <google/dense_hash_set>
-#include <google/dense_hash_map>
+#include <sparsehash/sparse_hash_set>
+#include <sparsehash/sparse_hash_map>
+#include <sparsehash/dense_hash_set>
+#include <sparsehash/dense_hash_map>
+#include <sparsehash/template_util.h>
+#include <sparsehash/type_traits.h>
 
 #define CHECK_IFF(cond, when) do {                                      \
   if (when) {                                                           \

data/ext/{sparsehash-1.8.1/src/google → sparsehash-2.0.2/src/sparsehash}/dense_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 densehashtable.h, just
 // like sgi stl's stl_hash_map is a very thin wrapper over
@@ -97,35 +96,31 @@
 #ifndef _DENSE_HASH_MAP_H_
 #define _DENSE_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/densehashtable.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/densehashtable.h>        // IWYU pragma: export
+#include <sparsehash/internal/libc_allocator_with_realloc.h>
+#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 dense_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
@@ -133,9 +128,15 @@ class dense_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 dense_hashtable<pair<const Key, T>, Key, HashFcn, SelectKey,
+  typedef dense_hashtable<std::pair<const Key, T>, Key, HashFcn, SelectKey,
                           SetKey, EqualKey, Alloc> ht;
   ht rep;
 
@@ -260,26 +261,34 @@ class dense_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<T>(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; }
 
+  // Insertion routines
+  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 and empty routines
   // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
@@ -307,11 +316,45 @@ class dense_hash_map {
   bool operator!=(const dense_hash_map& hs) const    { return rep != hs.rep; }
 
 
-  // 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); }
+  // I/O -- this is an add-on for writing hash map to disk
+  //
+  // 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.
+  template <typename ValueSerializer, typename INPUT>
+  bool unserialize(ValueSerializer serializer, INPUT* fp) {
+    return rep.unserialize(serializer, fp);
+  }
 };
 
 // We need a global swap as well

data/ext/{sparsehash-1.8.1/src/google → sparsehash-2.0.2/src/sparsehash}/dense_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 densehashtable.h, just
 // like sgi stl's stl_hash_set is a very thin wrapper over
@@ -101,30 +100,25 @@
 #ifndef _DENSE_HASH_SET_H_
 #define _DENSE_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/densehashtable.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/densehashtable.h>        // IWYU pragma: export
+#include <sparsehash/internal/libc_allocator_with_realloc.h>
+#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 dense_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 {
@@ -251,22 +245,26 @@ class dense_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 and empty routines
   // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
@@ -291,10 +289,42 @@ class dense_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.
+  template <typename ValueSerializer, typename INPUT>
+  bool unserialize(ValueSerializer serializer, INPUT* fp) {
+    return rep.unserialize(serializer, fp);
+  }
 };
 
 template <class Val, class HashFcn, class EqualKey, class Alloc>