google_hash 0.6.2 → 0.7.0

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

@@ -50,8 +50,7 @@
 // because of this container's memory economy, each insert and delete
 // causes a memory reallocation.
 //
-// See /usr/(local/)?doc/sparsehash-0.1/sparsetable.html
-// for information about how to use this class.
+// See doc/sparsetable.html for information about how to use this class.
 
 #ifndef _SPARSETABLE_H_
 #define _SPARSETABLE_H_
@@ -73,6 +72,7 @@
 #include <algorithm>            // equal, lexicographical_compare, swap,...
 #include <memory>               // uninitialized_copy
 #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
@@ -83,8 +83,6 @@
 #endif
 #endif
 
-_START_GOOGLE_NAMESPACE_
-
 #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,6 +96,8 @@ _START_GOOGLE_NAMESPACE_
 # endif
 #endif
 
+_START_GOOGLE_NAMESPACE_
+
 using STL_NAMESPACE::vector;
 using STL_NAMESPACE::uninitialized_copy;
 
@@ -188,7 +188,7 @@ class table_iterator {
   }
 
   // Arithmetic: we just do arithmetic on pos.  We don't even need to
-  // do bounds checking, since STL doesn't consider that it's job.  :-)
+  // do bounds checking, since STL doesn't consider that its job.  :-)
   iterator& operator+=(size_type t) { pos += t; check(); return *this; }
   iterator& operator-=(size_type t) { pos -= t; check(); return *this; }
   iterator& operator++()            { ++pos; check(); return *this; }
@@ -271,7 +271,7 @@ class const_table_iterator {
   }
 
   // Arithmetic: we just do arithmetic on pos.  We don't even need to
-  // do bounds checking, since STL doesn't consider that it's job.  :-)
+  // do bounds checking, since STL doesn't consider that its job.  :-)
   const_iterator& operator+=(size_type t) { pos += t; check(); return *this; }
   const_iterator& operator-=(size_type t) { pos -= t; check(); return *this; }
   const_iterator& operator++()            { ++pos; check(); return *this; }
@@ -388,7 +388,7 @@ class two_d_iterator {
   pointer operator->() const     { return &(operator*()); }
 
   // Arithmetic: we just do arithmetic on pos.  We don't even need to
-  // do bounds checking, since STL doesn't consider that it's job.  :-)
+  // do bounds checking, since STL doesn't consider that its job.  :-)
   // NOTE: this is not amortized constant time!  What do we do about it?
   void advance_past_end() {          // used when col_current points to end()
     while ( col_current == row_current->TWOD_END_() ) {  // end of current row
@@ -600,7 +600,7 @@ class destructive_two_d_iterator {
 #undef TWOD_CONST_ITER_
 
 
-
+
 
 // SPARSE-TABLE
 // ------------
@@ -639,18 +639,25 @@ class destructive_two_d_iterator {
     add_to |= (static_cast<size_type>(x) << ((offset) % (sizeof(add_to)*8))); \
 } while (0)
 
-template <class T, u_int16_t GROUP_SIZE>
+template <class T, u_int16_t GROUP_SIZE, class Alloc>
 class sparsegroup {
+ private:
+  typedef typename Alloc::template rebind<T>::other value_alloc_type;
+
  public:
   // Basic types
   typedef T value_type;
-  typedef value_type* pointer;
-  typedef const value_type* const_pointer;
-  typedef table_iterator<sparsegroup<T, GROUP_SIZE> > iterator;
-  typedef const_table_iterator<sparsegroup<T, GROUP_SIZE> > const_iterator;
-  typedef table_element_adaptor<sparsegroup<T, GROUP_SIZE> > element_adaptor;
-  typedef value_type &reference;
-  typedef const value_type &const_reference;
+  typedef Alloc allocator_type;
+  typedef typename value_alloc_type::reference reference;
+  typedef typename value_alloc_type::const_reference const_reference;
+  typedef typename value_alloc_type::pointer pointer;
+  typedef typename value_alloc_type::const_pointer const_pointer;
+
+  typedef table_iterator<sparsegroup<T, GROUP_SIZE, Alloc> > iterator;
+  typedef const_table_iterator<sparsegroup<T, GROUP_SIZE, Alloc> >
+      const_iterator;
+  typedef table_element_adaptor<sparsegroup<T, GROUP_SIZE, Alloc> >
+      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;
@@ -708,37 +715,38 @@ class sparsegroup {
   void bmset(size_type i)          { bitmap[charbit(i)] |= modbit(i); }
   void bmclear(size_type i)        { bitmap[charbit(i)] &= ~modbit(i); }
 
-  void* realloc_or_die(void* ptr, size_t num_bytes) {
-    void* retval = realloc(ptr, num_bytes);
+  pointer allocate_group(size_type n) {
+    pointer retval = allocator.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, "FATAL ERROR: failed to allocate %lu bytes for ptr %p",
-              static_cast<unsigned long>(num_bytes), ptr);
+      fprintf(stderr, "sparsehash: FATAL ERROR: "
+              "failed to allocate %lu groups\n",
+              static_cast<unsigned long>(n));
       exit(1);
     }
     return retval;
   }
 
-  value_type* allocate_group(size_t n) {
-    return static_cast<value_type*>(realloc_or_die(NULL,
-                                                   n * sizeof(value_type)));
-  }
-
   void free_group() {
-    // Valid even for empty group, because NULL+0 is defined to be NULL
-    value_type* end_it = group + num_buckets;
-    for (value_type* p = group; p != end_it; ++p)
+    if (!group)  return;
+    pointer end_it = group + num_buckets;
+    for (pointer p = group; p != end_it; ++p)
       p->~value_type();
-    free(group);
+    allocator.deallocate(group, 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
+  // 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) {
     // We could make these ints.  The tradeoff is size (eg does it overwhelm
     // the cache?) vs efficiency in referencing sub-word-sized array elements
@@ -776,8 +784,11 @@ class sparsegroup {
 
  public:
   // Constructors -- default and copy -- and destructor
-  sparsegroup() : group(0), num_buckets(0) { memset(bitmap, 0, sizeof(bitmap)); }
-  sparsegroup(const sparsegroup& x) : group(0), num_buckets(x.num_buckets) {
+  sparsegroup(allocator_type& a) : allocator(a), group(0), num_buckets(0) {
+    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);
@@ -794,7 +805,7 @@ class sparsegroup {
     if ( x.num_buckets == 0 ) {
       free_group();
     } else {
-      value_type* p = allocate_group(x.num_buckets);
+      pointer p = allocate_group(x.num_buckets);
       uninitialized_copy(x.group, x.group + x.num_buckets, p);
       free_group();
       group = p;
@@ -810,6 +821,7 @@ class sparsegroup {
     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);
+    // we purposefully don't swap the allocator, which may not be swap-able
   }
 
   // It's always nice to be able to clear a table without deallocating it
@@ -864,14 +876,14 @@ class sparsegroup {
 
  private:
   // Create space at group[offset], assuming value_type has trivial
-  // copy constructor and destructor.  (Really, we want it to have
+  // copy constructor and destructor, and the allocator_type is
+  // the default libc_allocator_with_alloc.  (Really, we want it to have
   // "trivial move", because that's what realloc and memmove both do.
   // 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 = (value_type *)
-            realloc_or_die(group, sizeof(*group) * (num_buckets+1));
+    group = allocator.realloc_or_die(group, 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)
@@ -879,9 +891,10 @@ class sparsegroup {
   }
 
   // Create space at group[offset], without special assumptions about value_type
+  // and allocator_type.
   void set_aux(size_type offset, false_type) {
     // This is valid because 0 <= offset <= num_buckets
-    value_type* p = allocate_group(num_buckets + 1);
+    pointer p = allocate_group(num_buckets + 1);
     uninitialized_copy(group, group + offset, p);
     uninitialized_copy(group + offset, group + num_buckets, p + offset + 1);
     free_group();
@@ -900,7 +913,9 @@ class sparsegroup {
     } else {
       typedef integral_constant<bool,
           (has_trivial_copy<value_type>::value &&
-           has_trivial_destructor<value_type>::value)>
+           has_trivial_destructor<value_type>::value &&
+           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;
@@ -914,15 +929,16 @@ class sparsegroup {
 
   // We let you see if a bucket is non-empty without retrieving it
   bool test(size_type i) const {
-    return bmtest(i) ? true : false;   // cast an int to a bool
+    return bmtest(i) != 0;
   }
   bool test(iterator pos) const {
-    return bmtest(pos.pos) ? true : false;
+    return bmtest(pos.pos) != 0;
   }
 
  private:
   // Shrink the array, assuming value_type has trivial copy
-  // constructor and destructor.  (Really, we want it to have "trivial
+  // constructor and destructor, and the allocator_type is the default
+  // libc_allocator_with_alloc.  (Really, we want it to have "trivial
   // move", because that's what realloc and memmove both do.  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);"
@@ -936,14 +952,14 @@ class sparsegroup {
     assert(num_buckets > 0);
     for (size_type i = offset; i < num_buckets-1; ++i)
       memcpy(group + i, group + i+1, sizeof(*group));  // hopefully inlined!
-    group = (value_type *)
-            realloc_or_die(group, sizeof(*group) * (num_buckets-1));
+    group = allocator.realloc_or_die(group, num_buckets-1);
   }
 
-  // Shrink the array, without any special assumptions about value_type.
+  // Shrink the array, without any special assumptions about value_type and
+  // allocator_type.
   void erase_aux(size_type offset, false_type) {
     // This is valid because 0 <= offset < num_buckets. Note the inequality.
-    value_type* p = allocate_group(num_buckets - 1);
+    pointer p = allocate_group(num_buckets - 1);
     uninitialized_copy(group, group + offset, p);
     uninitialized_copy(group + offset + 1, group + num_buckets, p + offset);
     free_group();
@@ -956,7 +972,7 @@ 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 ) {
         free_group();
@@ -964,7 +980,10 @@ class sparsegroup {
       } else {
         typedef integral_constant<bool,
             (has_trivial_copy<value_type>::value &&
-             has_trivial_destructor<value_type>::value)>
+             has_trivial_destructor<value_type>::value &&
+             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());
       }
@@ -1054,48 +1073,113 @@ class sparsegroup {
   bool operator>=(const sparsegroup& x) const { return !(*this < x); }
 
  private:
+  template <class A>
+  class alloc_impl : public A {
+   public:
+    typedef typename A::pointer pointer;
+    typedef typename A::size_type size_type;
+
+    // Convert a normal allocator to one that has realloc_or_die()
+    alloc_impl(const A& a) : A(a) { }
+
+    // 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) {
+      fprintf(stderr, "realloc_or_die is only supported for "
+                      "libc_allocator_with_realloc");
+      exit(1);
+      return NULL;
+    }
+  };
+
+  // A template specialization of alloc_impl for
+  // libc_allocator_with_realloc that can handle realloc_or_die.
+  template <class A>
+  class alloc_impl<libc_allocator_with_realloc<A> >
+      : public libc_allocator_with_realloc<A> {
+   public:
+    typedef typename libc_allocator_with_realloc<A>::pointer pointer;
+    typedef typename libc_allocator_with_realloc<A>::size_type size_type;
+
+    alloc_impl(const libc_allocator_with_realloc<A>& a)
+        : libc_allocator_with_realloc<A>(a) { }
+
+    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);
+        exit(1);
+      }
+      return retval;
+    }
+  };
+
   // The actual data
-  value_type *group;                            // (small) array of T's
+  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
 };
 
 // We need a global swap as well
-template <class T, u_int16_t GROUP_SIZE>
-inline void swap(sparsegroup<T,GROUP_SIZE> &x, sparsegroup<T,GROUP_SIZE> &y) {
+template <class T, u_int16_t GROUP_SIZE, class Alloc>
+inline void swap(sparsegroup<T,GROUP_SIZE,Alloc> &x,
+                 sparsegroup<T,GROUP_SIZE,Alloc> &y) {
   x.swap(y);
 }
 
 // ---------------------------------------------------------------------------
 
 
-template <class T, u_int16_t GROUP_SIZE = DEFAULT_SPARSEGROUP_SIZE>
+template <class T, u_int16_t GROUP_SIZE = DEFAULT_SPARSEGROUP_SIZE,
+          class Alloc = libc_allocator_with_realloc<T> >
 class sparsetable {
+ private:
+  typedef typename Alloc::template rebind<T>::other value_alloc_type;
+  typedef typename Alloc::template rebind<
+      sparsegroup<T, GROUP_SIZE, value_alloc_type> >::other vector_alloc;
+
  public:
   // Basic types
   typedef T value_type;                        // stolen from stl_vector.h
-  typedef value_type* pointer;
-  typedef const value_type* const_pointer;
-  typedef table_iterator<sparsetable<T, GROUP_SIZE> > iterator;
-  typedef const_table_iterator<sparsetable<T, GROUP_SIZE> > const_iterator;
-  typedef table_element_adaptor<sparsetable<T, GROUP_SIZE> > element_adaptor;
-  typedef value_type &reference;
-  typedef const value_type &const_reference;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
+  typedef Alloc allocator_type;
+  typedef typename value_alloc_type::size_type size_type;
+  typedef typename value_alloc_type::difference_type difference_type;
+  typedef typename value_alloc_type::reference reference;
+  typedef typename value_alloc_type::const_reference const_reference;
+  typedef typename value_alloc_type::pointer pointer;
+  typedef typename value_alloc_type::const_pointer const_pointer;
+  typedef table_iterator<sparsetable<T, GROUP_SIZE, Alloc> > iterator;
+  typedef const_table_iterator<sparsetable<T, GROUP_SIZE, Alloc> >
+      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;
 
   // 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> > >
+  typedef two_d_iterator< vector< sparsegroup<value_type, GROUP_SIZE,
+                                              value_alloc_type>,
+                                  vector_alloc> >
      nonempty_iterator;
-  typedef const_two_d_iterator< vector< sparsegroup<value_type, GROUP_SIZE> > >
+  typedef const_two_d_iterator< 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;
   // Another special iterator: it frees memory as it iterates (used to resize)
-  typedef destructive_two_d_iterator< vector< sparsegroup<value_type, GROUP_SIZE> > >
+  typedef destructive_two_d_iterator< vector< sparsegroup<value_type,
+                                                          GROUP_SIZE,
+                                                          value_alloc_type>,
+                                              vector_alloc> >
      destructive_iterator;
 
   // Iterator functions
@@ -1140,16 +1224,13 @@ class sparsetable {
     return destructive_iterator(groups.begin(), groups.end(), groups.end());
   }
 
- private:
-  typedef typename vector< sparsegroup<value_type, GROUP_SIZE> >::reference
-    GroupsReference;
-  typedef typename
-    vector< sparsegroup<value_type, GROUP_SIZE> >::const_reference
-    GroupsConstReference;
-  typedef typename vector< sparsegroup<value_type, GROUP_SIZE> >::iterator
-    GroupsIterator;
-  typedef typename vector< sparsegroup<value_type, GROUP_SIZE> >::const_iterator
-    GroupsConstIterator;
+  typedef sparsegroup<value_type, GROUP_SIZE, allocator_type> group_type;
+  typedef vector<group_type, vector_alloc > group_vector_type;
+
+  typedef typename group_vector_type::reference GroupsReference;
+  typedef typename group_vector_type::const_reference GroupsConstReference;
+  typedef typename group_vector_type::iterator GroupsIterator;
+  typedef typename group_vector_type::const_iterator GroupsConstIterator;
 
   // How to deal with the proper group
   static size_type num_groups(size_type num) {   // how many to hold num buckets
@@ -1171,9 +1252,12 @@ class sparsetable {
 
  public:
   // Constructors -- default, normal (when you specify size), and copy
-  sparsetable(size_type sz = 0)
-    : groups(num_groups(sz)), table_size(sz), num_buckets(0) { }
-  // We'll can get away with using the default copy constructor,
+  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));
+  }
+  // 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
@@ -1192,19 +1276,23 @@ class sparsetable {
     num_buckets = 0;
   }
 
+  // ACCESSOR FUNCTIONS for the things we templatize on, basically
+  allocator_type get_allocator() const    { return allocator; }
+
+
   // 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 size_type(-1); }
+  size_type max_size() const       { return allocator.max_size(); }
   bool empty() const               { return table_size == 0; }
   // We also may want to know how many *used* buckets there are
   size_type num_nonempty() const   { return num_buckets; }
 
   // OK, we'll let you resize one of these puppies
   void resize(size_type new_size) {
-    groups.resize(num_groups(new_size));
+    groups.resize(num_groups(new_size), group_type(allocator));
     if ( new_size < 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),
@@ -1449,14 +1537,16 @@ class sparsetable {
 
  private:
   // The actual data
-  vector< sparsegroup<value_type, GROUP_SIZE> > groups;  // our list of groups
-  size_type table_size;                         // how many buckets they want
-  size_type num_buckets;                        // number of non-empty buckets
+  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
 };
 
 // We need a global swap as well
-template <class T, u_int16_t GROUP_SIZE>
-inline void swap(sparsetable<T,GROUP_SIZE> &x, sparsetable<T,GROUP_SIZE> &y) {
+template <class T, u_int16_t GROUP_SIZE, class Alloc>
+inline void swap(sparsetable<T,GROUP_SIZE,Alloc> &x,
+                 sparsetable<T,GROUP_SIZE,Alloc> &y) {
   x.swap(y);
 }