Make bitvectors serializable.

src/BitVector.cc

@@ -2,6 +2,7 @@
 
 #include <cassert>
 #include <limits>
+#include "Serializer.h"
 
 BitVector::size_type BitVector::npos = static_cast<BitVector::size_type>(-1);
 BitVector::block_type BitVector::bits_per_block =
@@ -453,3 +454,55 @@ BitVector::size_type BitVector::find_from(size_type i) const
     return npos;
   return i * bits_per_block + lowest_bit(bits_[i]);
   }
+
+bool BitVector::Serialize(SerialInfo* info) const
+  {
+  return SerialObj::Serialize(info);
+  }
+
+BitVector* BitVector::Unserialize(UnserialInfo* info)
+  {
+  return reinterpret_cast<BitVector*>(
+      SerialObj::Unserialize(info, SER_BITVECTOR));
+  }
+
+IMPLEMENT_SERIAL(BitVector, SER_BITVECTOR);
+
+bool BitVector::DoSerialize(SerialInfo* info) const
+  {
+  DO_SERIALIZE(SER_BITVECTOR, SerialObj);
+
+  if ( ! SERIALIZE(static_cast<uint64>(bits_.size())) )
+    return false;
+
+  for (size_t i = 0; i < bits_.size(); ++i)
+    if ( ! SERIALIZE(static_cast<uint64>(bits_[i])) )
+      return false;
+
+  return SERIALIZE(static_cast<uint64>(num_bits_));
+  }
+
+bool BitVector::DoUnserialize(UnserialInfo* info)
+  {
+  DO_UNSERIALIZE(SerialObj);
+
+  uint64 size;
+  if ( ! UNSERIALIZE(&size) )
+    return false;
+
+  bits_.resize(static_cast<size_t>(size));
+  uint64 block;
+  for ( size_t i = 0; i < bits_.size(); ++i )
+    {
+    if ( ! UNSERIALIZE(&block) )
+      return false;
+    bits_[i] = static_cast<block_type>(block);
+    }
+
+  uint64 num_bits;
+  if ( ! UNSERIALIZE(&num_bits) )
+    return false;
+  num_bits_ = static_cast<size_type>(num_bits);
+
+  return true;
+  }

src/BitVector.h

@@ -3,11 +3,12 @@
 
 #include <iterator>
 #include <vector>
+#include "SerialObj.h"
 
 /**
  * A vector of bits.
  */
-class BitVector {
+class BitVector : SerialObj {
 public:
   typedef size_t block_type;
   typedef size_t size_type;
@@ -42,7 +43,7 @@ public:
   typedef bool const_reference;
 
   /**
-   * Constructs an empty bit vector.
+   * Default-constructs an empty bit vector.
    */
   BitVector();
 
@@ -253,6 +254,12 @@ public:
    */
   size_type find_next(size_type i) const;
 
+  bool Serialize(SerialInfo* info) const;
+  static BitVector* Unserialize(UnserialInfo* info);
+
+protected:
+  DECLARE_SERIAL(BitVector);
+
 private:
   /**
    * Computes the block index for a given bit position.

src/SerialTypes.h

@@ -49,6 +49,7 @@ SERIAL_IS(STATE_ACCESS, 0x1100)
 SERIAL_IS_BO(CASE, 0x1200)
 SERIAL_IS(LOCATION, 0x1300)
 SERIAL_IS(RE_MATCHER, 0x1400)
+SERIAL_IS(BITVECTOR, 0x1500)
 
 // These are the externally visible types.
 const SerialType SER_NONE = 0;
@@ -202,5 +203,6 @@ SERIAL_CONST2(STATE_ACCESS)
 SERIAL_CONST2(CASE)
 SERIAL_CONST2(LOCATION)
 SERIAL_CONST2(RE_MATCHER)
+SERIAL_CONST2(BITVECTOR)
 
 #endif