From 22afbe42dd91e668de8c72417b6a8ff8b544dd99 Mon Sep 17 00:00:00 2001
From: Matthias Vallentin <vallentin@icir.org>
Date: Mon, 10 Jun 2013 20:15:13 -0700
Subject: [PATCH] A number of tweaks of the serialization code.

---
 src/BitVector.h    |  2 +-
 src/BloomFilter.cc | 17 ++++++++---------
 src/BloomFilter.h  |  2 +-
 src/OpaqueVal.cc   | 10 ++++++----
 src/SerialTypes.h  |  8 ++++----
 5 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/BitVector.h b/src/BitVector.h
index 8315a151f0..83fec44a0d 100644
--- a/src/BitVector.h
+++ b/src/BitVector.h
@@ -8,7 +8,7 @@
 /**
  * A vector of bits.
  */
-class BitVector : SerialObj {
+class BitVector : public SerialObj {
 public:
   typedef size_t block_type;
   typedef size_t size_type;
diff --git a/src/BloomFilter.cc b/src/BloomFilter.cc
index 40772fecb6..1d73734236 100644
--- a/src/BloomFilter.cc
+++ b/src/BloomFilter.cc
@@ -55,7 +55,7 @@ IMPLEMENT_SERIAL(CounterVector, SER_COUNTERVECTOR)
 bool CounterVector::DoSerialize(SerialInfo* info) const
 	{
 	DO_SERIALIZE(SER_COUNTERVECTOR, SerialObj);
-  if ( ! SERIALIZE(bits_) )
+  if ( ! bits_->Serialize(info) )
     return false;
 	return SERIALIZE(static_cast<uint64>(width_));
   }
@@ -63,14 +63,13 @@ bool CounterVector::DoSerialize(SerialInfo* info) const
 bool CounterVector::DoUnserialize(UnserialInfo* info)
 	{
 	DO_UNSERIALIZE(SerialObj);
-	return false;
 	bits_ = BitVector::Unserialize(info);
   if ( ! bits_ )
     return false;
   uint64 width;
   if ( ! UNSERIALIZE(&width) )
     return false;
-	width_ = static_cast<unsigned>(width);
+	width_ = static_cast<size_t>(width);
 	return true;
   }
 
@@ -127,7 +126,7 @@ bool BloomFilter::DoSerialize(SerialInfo* info) const
 	DO_SERIALIZE(SER_BLOOMFILTER, SerialObj);
   if ( ! SERIALIZE(static_cast<uint16>(hash_->K())) )
     return false;
-  return SERIALIZE(static_cast<uint16>(elements_));
+  return SERIALIZE(static_cast<uint64>(elements_));
   }
 
 bool BloomFilter::DoUnserialize(UnserialInfo* info)
@@ -178,14 +177,14 @@ IMPLEMENT_SERIAL(BasicBloomFilter, SER_BASICBLOOMFILTER)
 bool BasicBloomFilter::DoSerialize(SerialInfo* info) const
 	{
 	DO_SERIALIZE(SER_BASICBLOOMFILTER, BloomFilter);
-  return SERIALIZE(bits_);
+  return bits_->Serialize(info);
   }
 
 bool BasicBloomFilter::DoUnserialize(UnserialInfo* info)
 	{
 	DO_UNSERIALIZE(BloomFilter);
 	bits_ = BitVector::Unserialize(info);
-	return bits_ == NULL;
+	return bits_ != NULL;
   }
 
 void BasicBloomFilter::AddImpl(const HashPolicy::HashVector& h)
@@ -227,15 +226,15 @@ IMPLEMENT_SERIAL(CountingBloomFilter, SER_COUNTINGBLOOMFILTER)
 
 bool CountingBloomFilter::DoSerialize(SerialInfo* info) const
 	{
-	DO_SERIALIZE(SER_BASICBLOOMFILTER, BloomFilter);
-  return SERIALIZE(cells_);
+	DO_SERIALIZE(SER_COUNTINGBLOOMFILTER, BloomFilter);
+  return cells_->Serialize(info);
   }
 
 bool CountingBloomFilter::DoUnserialize(UnserialInfo* info)
 	{
 	DO_UNSERIALIZE(BloomFilter);
 	cells_ = CounterVector::Unserialize(info);
-	return cells_ == NULL;
+	return cells_ != NULL;
   }
 
 void CountingBloomFilter::AddImpl(const HashPolicy::HashVector& h)
diff --git a/src/BloomFilter.h b/src/BloomFilter.h
index c0101cadf8..4a83ba904b 100644
--- a/src/BloomFilter.h
+++ b/src/BloomFilter.h
@@ -73,7 +73,7 @@ protected:
 
 private:
   BitVector* bits_;
-  unsigned width_;
+  size_t width_;
 };
 
 /**
diff --git a/src/OpaqueVal.cc b/src/OpaqueVal.cc
index 38ea93d000..76936dfb78 100644
--- a/src/OpaqueVal.cc
+++ b/src/OpaqueVal.cc
@@ -574,7 +574,7 @@ size_t BloomFilterVal::Count(const Val* val) const
 
 BloomFilterVal* BloomFilterVal::Merge(const BloomFilterVal* first,
                                       const BloomFilterVal* second)
-{
+  {
   assert(! "not yet implemented");
   return NULL;
   }
@@ -594,14 +594,15 @@ IMPLEMENT_SERIAL(BloomFilterVal, SER_BLOOMFILTER_VAL);
 bool BloomFilterVal::DoSerialize(SerialInfo* info) const
 	{
 	DO_SERIALIZE(SER_BLOOMFILTER_VAL, OpaqueVal);
-	if ( ! SERIALIZE(type_) )
+	if ( ! type_->Serialize(info) )
 	  return false;
-	return SERIALIZE(bloom_filter_);
+	return bloom_filter_->Serialize(info);
   }
 
 bool BloomFilterVal::DoUnserialize(UnserialInfo* info)
 	{
 	DO_UNSERIALIZE(OpaqueVal);
+
 	type_ = BroType::Unserialize(info);
 	if ( ! type_ )
 	  return false;
@@ -609,6 +610,7 @@ bool BloomFilterVal::DoUnserialize(UnserialInfo* info)
   tl->Append(type_);
   hash_ = new CompositeHash(tl);
   Unref(tl);
+
 	bloom_filter_ = BloomFilter::Unserialize(info);
-	return bloom_filter_ == NULL;
+	return bloom_filter_ != NULL;
   }
diff --git a/src/SerialTypes.h b/src/SerialTypes.h
index 859145f19f..9e4aef5b3b 100644
--- a/src/SerialTypes.h
+++ b/src/SerialTypes.h
@@ -50,10 +50,10 @@ SERIAL_IS_BO(CASE, 0x1200)
 SERIAL_IS(LOCATION, 0x1300)
 SERIAL_IS(RE_MATCHER, 0x1400)
 SERIAL_IS(BITVECTOR, 0x1500)
-SERIAL_IS(COUNTERVECTOR, 0xa000)
-SERIAL_IS(BLOOMFILTER, 0xa100)
-SERIAL_IS(BASICBLOOMFILTER, 0xa200)
-SERIAL_IS(COUNTINGBLOOMFILTER, 0xa300)
+SERIAL_IS(COUNTERVECTOR, 0x1600)
+SERIAL_IS(BLOOMFILTER, 0x1700)
+SERIAL_IS(BASICBLOOMFILTER, 0x1800)
+SERIAL_IS(COUNTINGBLOOMFILTER, 0x1900)
 
 // These are the externally visible types.
 const SerialType SER_NONE = 0;