Merge branch 'master' of github.com:mavam/libbf

bf/bitvector.hpp

@@ -81,7 +81,7 @@ class bitvector
   bitvector& operator=(bitvector other);
 
   /// Swaps two bit vectors.
-  friend void swap(bitvector x, bitvector y);
+  friend void swap(bitvector& x, bitvector& y);
 
   //
   // Bitwise operations

bf/bloom_filter/basic.hpp

@@ -59,6 +59,12 @@ class basic_bloom_filter : public bloom_filter
   basic_bloom_filter(double fp, size_t capacity, size_t seed = 0,
                      bool double_hashing = true, bool partition = true);
 
+  /// Constructs a basic Bloom filter given a hasher and a bitvector.
+  ///
+  /// @param hasher The hasher to use.
+  /// @param bitvector the underlying bitvector of the bf.
+  basic_bloom_filter(hasher h, bitvector b);
+
   basic_bloom_filter(basic_bloom_filter&&);
 
   using bloom_filter::add;
@@ -82,6 +88,9 @@ class basic_bloom_filter : public bloom_filter
   /// Returns the underlying storage of the Bloom filter.
   bitvector const& storage() const;
 
+  /// Returns the hasher of the Bloom filter.
+  hasher const& hasher_function() const;
+
 private:
   hasher hasher_;
   bitvector bits_;

src/bitvector.cpp

@@ -127,7 +127,7 @@ bitvector& bitvector::operator=(bitvector other)
   return *this;
 }
 
-void swap(bitvector x, bitvector y)
+void swap(bitvector& x, bitvector& y)
 {
   using std::swap;
   swap(x.bits_, y.bits_);

src/bloom_filter/basic.cpp

@@ -34,6 +34,12 @@ basic_bloom_filter::basic_bloom_filter(double fp, size_t capacity, size_t seed,
   hasher_ = make_hasher(optimal_k, seed, double_hashing);
 }
 
+basic_bloom_filter::basic_bloom_filter(hasher h, bitvector b)
+  : hasher_(std::move(h))
+  , bits_(std::move(b))
+{
+}
+
 basic_bloom_filter::basic_bloom_filter(basic_bloom_filter&& other)
   : hasher_(std::move(other.hasher_)),
     bits_(std::move(other.bits_))
@@ -100,5 +106,10 @@ bitvector const& basic_bloom_filter::storage() const
 {
   return bits_;
 }
+hasher const& basic_bloom_filter::hasher_function() const
+{
+  return hasher_;
+}
+
 
 } // namespace bf

test/tests.cpp

@@ -166,6 +166,20 @@ TEST(bloom_filter_basic) {
   // False-positives
   CHECK_EQUAL(bf.lookup("corge"), 1u);
   CHECK_EQUAL(bf.lookup('a'), 1u);
+
+  // another filter
+  basic_bloom_filter obf(0.8, 10);
+  obf.swap(bf);
+
+  CHECK_EQUAL(obf.lookup("foo"), 1u);
+
+  // Make bf using another filter's storage
+  hasher h = obf.hasher_function();
+  bitvector b = obf.storage();
+  basic_bloom_filter obfc(h, b);
+  CHECK_EQUAL(obfc.storage(), b);
+  CHECK_EQUAL(obfc.lookup("foo"), 1u);
+
 }
 
 TEST(bloom_filter_counting) {