datasketches 0.1.2 → 0.2.0

data/vendor/datasketches-cpp/hll/include/HllUnion-internal.hpp

@@ -32,9 +32,9 @@
 namespace datasketches {
 
 template<typename A>
-hll_union_alloc<A>::hll_union_alloc(const int lg_max_k):
+hll_union_alloc<A>::hll_union_alloc(const int lg_max_k, const A& allocator):
   lg_max_k(HllUtil<A>::checkLgK(lg_max_k)),
-  gadget(lg_max_k, target_hll_type::HLL_8)
+  gadget(lg_max_k, target_hll_type::HLL_8, false, allocator)
 {}
 
 template<typename A>
@@ -149,16 +149,6 @@ double hll_union_alloc<A>::get_upper_bound(const int num_std_dev) const {
   return gadget.get_upper_bound(num_std_dev);
 }
 
-template<typename A>
-int hll_union_alloc<A>::get_compact_serialization_bytes() const {
-  return gadget.get_compact_serialization_bytes();
-}
-
-template<typename A>
-int hll_union_alloc<A>::get_updatable_serialization_bytes() const {
-  return gadget.get_updatable_serialization_bytes();
-}
-
 template<typename A>
 int hll_union_alloc<A>::get_lg_config_k() const {
   return gadget.get_lg_config_k();
@@ -169,11 +159,6 @@ void hll_union_alloc<A>::reset() {
   gadget.reset();
 }
 
-template<typename A>
-bool hll_union_alloc<A>::is_compact() const {
-  return gadget.is_compact();
-}
-
 template<typename A>
 bool hll_union_alloc<A>::is_empty() const {
   return gadget.is_empty();
@@ -194,21 +179,11 @@ bool hll_union_alloc<A>::is_estimation_mode() const {
   return gadget.is_estimation_mode();
 }
 
-template<typename A>
-int hll_union_alloc<A>::get_serialization_version() const {
-  return HllUtil<A>::SER_VER;
-}
-
 template<typename A>
 target_hll_type hll_union_alloc<A>::get_target_type() const {
   return target_hll_type::HLL_8;
 }
 
-template<typename A>
-int hll_union_alloc<A>::get_max_serialization_bytes(const int lg_k) {
-  return hll_sketch_alloc<A>::get_max_updatable_serialization_bytes(lg_k, target_hll_type::HLL_8);
-}
-
 template<typename A>
 double hll_union_alloc<A>::get_rel_err(const bool upper_bound, const bool unioned,
                            const int lg_config_k, const int num_std_dev) {
@@ -226,7 +201,7 @@ HllSketchImpl<A>* hll_union_alloc<A>::copy_or_downsample(const HllSketchImpl<A>*
     return src->copyAs(HLL_8);
   }
   typedef typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>> hll8Alloc;
-  Hll8Array<A>* tgtHllArr = new (hll8Alloc().allocate(1)) Hll8Array<A>(tgt_lg_k, false);
+  Hll8Array<A>* tgtHllArr = new (hll8Alloc(src->getAllocator()).allocate(1)) Hll8Array<A>(tgt_lg_k, false, src->getAllocator());
   tgtHllArr->mergeHll(*src);
   //both of these are required for isomorphism
   tgtHllArr->putHipAccum(src->getHipAccum());

data/vendor/datasketches-cpp/hll/include/HllUtil.hpp

@@ -36,7 +36,7 @@ enum hll_mode { LIST = 0, SET, HLL };
 
 // template provides internal consistency and allows static float values
 // but we don't use the template parameter anywhere
-template<typename A = std::allocator<char> >
+template<typename A = std::allocator<uint8_t> >
 class HllUtil final {
 public:
   // preamble stuff

data/vendor/datasketches-cpp/hll/include/RelativeErrorTables.hpp

@@ -24,7 +24,7 @@
 
 namespace datasketches {
 
-template<typename A = std::allocator<char>>
+template<typename A = std::allocator<uint8_t>>
 class RelativeErrorTables {
   public:
     /**

data/vendor/datasketches-cpp/hll/include/hll.hpp

@@ -108,7 +108,7 @@ class hll_union_alloc;
 template<typename A> using AllocU8 = typename std::allocator_traits<A>::template rebind_alloc<uint8_t>;
 template<typename A> using vector_u8 = std::vector<uint8_t, AllocU8<A>>;
 
-template<typename A = std::allocator<char> >
+template<typename A = std::allocator<uint8_t> >
 class hll_sketch_alloc final {
   public:
     /**
@@ -119,7 +119,7 @@ class hll_sketch_alloc final {
      *        keeping memory use constant (if HLL_6 or HLL_8) at the cost of
      *        starting out using much more memory
      */
-    explicit hll_sketch_alloc(int lg_config_k, target_hll_type tgt_type = HLL_4, bool start_full_size = false);
+    explicit hll_sketch_alloc(int lg_config_k, target_hll_type tgt_type = HLL_4, bool start_full_size = false, const A& allocator = A());
 
     /**
      * Copy constructor
@@ -140,14 +140,14 @@ class hll_sketch_alloc final {
      * Reconstructs a sketch from a serialized image on a stream.
      * @param is An input stream with a binary image of a sketch
      */
-    static hll_sketch_alloc deserialize(std::istream& is);
+    static hll_sketch_alloc deserialize(std::istream& is, const A& allocator = A());
 
     /**
      * Reconstructs a sketch from a serialized image in a byte array.
      * @param is bytes An input array with a binary image of a sketch
      * @param len Length of the input array, in bytes
      */
-    static hll_sketch_alloc deserialize(const void* bytes, size_t len);
+    static hll_sketch_alloc deserialize(const void* bytes, size_t len, const A& allocator = A());
 
     //! Class destructor
     virtual ~hll_sketch_alloc();
@@ -423,7 +423,7 @@ class hll_sketch_alloc final {
  * author Kevin Lang
  */
  
-template<typename A = std::allocator<char> >
+template<typename A = std::allocator<uint8_t> >
 class hll_union_alloc {
   public:
     /**
@@ -431,7 +431,7 @@ class hll_union_alloc {
      * @param lg_max_k The maximum size, in log2, of k. The value must
      * be between 7 and 21, inclusive.
      */
-    explicit hll_union_alloc(int lg_max_k);
+    explicit hll_union_alloc(int lg_max_k, const A& allocator = A());
 
     /**
      * Returns the current cardinality estimate
@@ -468,18 +468,6 @@ class hll_union_alloc {
      */
     double get_upper_bound(int num_std_dev) const;
 
-    /**
-     * Returns the size of the union serialized in compact form.
-     * @return Size of the union serialized in compact form, in bytes.
-     */
-    int get_compact_serialization_bytes() const;
-
-    /**
-     * Returns the size of the union serialized without compaction.
-     * @return Size of the union serialized without compaction, in bytes.
-     */
-    int get_updatable_serialization_bytes() const;
-
     /**
      * Returns union's configured lg_k value.
      * @return Configured lg_k value.
@@ -492,12 +480,6 @@ class hll_union_alloc {
      */
     target_hll_type get_target_type() const;
 
-    /**
-     * Indicates if the union is currently stored compacted.
-     * @return True if the union is stored in compact form.
-     */
-    bool is_compact() const;
-
     /**
      * Indicates if the union is currently empty.
      * @return True if the union is empty.
@@ -605,15 +587,6 @@ class hll_union_alloc {
      */
     void update(const void* data, size_t length_bytes);
 
-    /**
-     * Returns the maximum size in bytes that this union operator can grow to given a lg_k.
-     *
-     * @param lg_k The maximum Log2 of k for this union operator. This value must be
-     * between 4 and 21 inclusively.
-     * @return the maximum size in bytes that this union operator can grow to.
-     */
-    static int get_max_serialization_bytes(int lg_k);
-
     /**
      * Gets the current (approximate) Relative Error (RE) asymptotic values given several
      * parameters. This is used primarily for testing.
@@ -645,7 +618,6 @@ class hll_union_alloc {
     void coupon_update(int coupon);
 
     hll_mode get_current_mode() const;
-    int get_serialization_version() const;
     bool is_out_of_order_flag() const;
     bool is_estimation_mode() const;
 

data/vendor/datasketches-cpp/hll/test/AuxHashMapTest.cpp

@@ -25,7 +25,7 @@
 namespace datasketches {
 
 TEST_CASE("aux hash map: check must replace", "[aux_hash_map]") {
-  AuxHashMap<>* map = new AuxHashMap<>(3, 7);
+  AuxHashMap<std::allocator<uint8_t>>* map = new AuxHashMap<std::allocator<uint8_t>>(3, 7, std::allocator<uint8_t>());
   map->mustAdd(100, 5);
   int val = map->mustFindValueFor(100);
   REQUIRE(val == 5);
@@ -40,9 +40,9 @@ TEST_CASE("aux hash map: check must replace", "[aux_hash_map]") {
 }
 
 TEST_CASE("aux hash map: check grow space", "[aux_hash_map]") {
-  auto map = std::unique_ptr<AuxHashMap<>, std::function<void(AuxHashMap<>*)>>(
-      AuxHashMap<>::newAuxHashMap(3, 7),
-      AuxHashMap<>::make_deleter()
+  auto map = std::unique_ptr<AuxHashMap<std::allocator<uint8_t>>, std::function<void(AuxHashMap<std::allocator<uint8_t>>*)>>(
+      AuxHashMap<std::allocator<uint8_t>>::newAuxHashMap(3, 7, std::allocator<uint8_t>()),
+      AuxHashMap<std::allocator<uint8_t>>::make_deleter()
       );
   REQUIRE(map->getLgAuxArrInts() == 3);
   for (int i = 1; i <= 7; ++i) {
@@ -63,17 +63,17 @@ TEST_CASE("aux hash map: check grow space", "[aux_hash_map]") {
 }
 
 TEST_CASE("aux hash map: check exception must find value for", "[aux_hash_map]") {
-  AuxHashMap<> map(3, 7);
+  AuxHashMap<std::allocator<uint8_t>> map(3, 7, std::allocator<uint8_t>());
   map.mustAdd(100, 5);
   REQUIRE_THROWS_AS(map.mustFindValueFor(101), std::invalid_argument);
 }
 
 TEST_CASE("aux hash map: check exception must add", "[aux_hash_map]") {
-  AuxHashMap<>* map = AuxHashMap<>::newAuxHashMap(3, 7);
+  AuxHashMap<std::allocator<uint8_t>>* map = AuxHashMap<std::allocator<uint8_t>>::newAuxHashMap(3, 7, std::allocator<uint8_t>());
   map->mustAdd(100, 5);
   REQUIRE_THROWS_AS(map->mustAdd(100, 6), std::invalid_argument);
   
-  AuxHashMap<>::make_deleter()(map);
+  AuxHashMap<std::allocator<uint8_t>>::make_deleter()(map);
 }
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/hll/test/CouponHashSetTest.cpp

@@ -43,7 +43,7 @@ TEST_CASE("coupon hash set: check corrupt bytearray", "[coupon_hash_set]") {
   // fail in HllSketchImpl
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
   // fail in CouponHashSet
-  REQUIRE_THROWS_AS(CouponHashSet<>::newSet(bytes, size), std::invalid_argument);
+  REQUIRE_THROWS_AS(CouponHashSet<std::allocator<uint8_t>>::newSet(bytes, size, std::allocator<uint8_t>()), std::invalid_argument);
   bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::HASH_SET_PREINTS;
 
   bytes[HllUtil<>::SER_VER_BYTE] = 0;
@@ -88,7 +88,7 @@ TEST_CASE("coupon hash set: check corrupt stream", "[coupon_hash_set]") {
   // fail in HllSketchImpl
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
   // fail in CouponHashSet
-  REQUIRE_THROWS_AS(CouponHashSet<>::newSet(ss), std::invalid_argument);
+  REQUIRE_THROWS_AS(CouponHashSet<std::allocator<uint8_t>>::newSet(ss, std::allocator<uint8_t>()), std::invalid_argument);
   ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
   ss.put(HllUtil<>::HASH_SET_PREINTS);
 

data/vendor/datasketches-cpp/hll/test/CouponListTest.cpp

@@ -36,7 +36,7 @@ void println_string(std::string str) {
 
 TEST_CASE("coupon list: check iterator", "[coupon_list]") {
   int lgConfigK = 8;
-  CouponList<> cl(lgConfigK, HLL_4, LIST);
+  CouponList<std::allocator<uint8_t>> cl(lgConfigK, HLL_4, LIST, std::allocator<uint8_t>());
   for (int i = 1; i <= 7; ++i) { cl.couponUpdate(HllUtil<>::pair(i, i)); } // not hashes but distinct values
   const int mask = (1 << lgConfigK) - 1;
   int idx = 0;
@@ -120,7 +120,7 @@ TEST_CASE("coupon list: check corrupt bytearray data", "[coupon_list]") {
 
   bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  REQUIRE_THROWS_AS(CouponList<>::newList(bytes, size), std::invalid_argument);
+  REQUIRE_THROWS_AS(CouponList<std::allocator<uint8_t>>::newList(bytes, size, std::allocator<uint8_t>()), std::invalid_argument);
 
   bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::LIST_PREINTS;
 
@@ -154,7 +154,7 @@ TEST_CASE("coupon list: check corrupt stream data", "[coupon_list]") {
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  REQUIRE_THROWS_AS(CouponList<>::newList(ss), std::invalid_argument);
+  REQUIRE_THROWS_AS(CouponList<std::allocator<uint8_t>>::newList(ss, std::allocator<uint8_t>()), std::invalid_argument);
   ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
   ss.put(HllUtil<>::LIST_PREINTS);
 

data/vendor/datasketches-cpp/hll/test/HllArrayTest.cpp

@@ -111,7 +111,7 @@ TEST_CASE("hll array: check corrupt bytearray", "[hll_array]") {
 
   bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  REQUIRE_THROWS_AS(HllArray<>::newHll(bytes, size), std::invalid_argument);
+  REQUIRE_THROWS_AS(HllArray<std::allocator<uint8_t>>::newHll(bytes, size, std::allocator<uint8_t>()), std::invalid_argument);
   bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::HLL_PREINTS;
 
   bytes[HllUtil<>::SER_VER_BYTE] = 0;
@@ -150,7 +150,7 @@ TEST_CASE("hll array: check corrupt stream", "[hll_array]") {
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  REQUIRE_THROWS_AS(HllArray<>::newHll(ss), std::invalid_argument);                                
+  REQUIRE_THROWS_AS(HllArray<std::allocator<uint8_t>>::newHll(ss, std::allocator<uint8_t>()), std::invalid_argument);
   ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
   ss.put(HllUtil<>::HLL_PREINTS);
 

data/vendor/datasketches-cpp/hll/test/HllSketchTest.cpp

@@ -24,10 +24,11 @@
 
 namespace datasketches {
 
-typedef hll_sketch_alloc<test_allocator<void>> hll_sketch_test_alloc;
+using hll_sketch_test_alloc = hll_sketch_alloc<test_allocator<uint8_t>>;
+using alloc = test_allocator<uint8_t>;
 
 static void runCheckCopy(int lgConfigK, target_hll_type tgtHllType) {
-  hll_sketch_test_alloc sk(lgConfigK, tgtHllType);
+  hll_sketch_test_alloc sk(lgConfigK, tgtHllType, false, 0);
 
   for (int i = 0; i < 7; ++i) {
     sk.update(i);
@@ -71,7 +72,7 @@ static void copyAs(target_hll_type srcType, target_hll_type dstType) {
   int n3 = 1000;
   int base = 0;
 
-  hll_sketch_test_alloc src(lgK, srcType);
+  hll_sketch_test_alloc src(lgK, srcType, false, 0);
   for (int i = 0; i < n1; ++i) {
     src.update(i + base);
   }
@@ -110,7 +111,7 @@ TEST_CASE("hll sketch: check misc1", "[hll_sketch]") {
   {
     int lgConfigK = 8;
     target_hll_type srcType = target_hll_type::HLL_8;
-    hll_sketch_test_alloc sk(lgConfigK, srcType);
+    hll_sketch_test_alloc sk(lgConfigK, srcType, false, 0);
 
     for (int i = 0; i < 7; ++i) { sk.update(i); } // LIST
     REQUIRE(sk.get_compact_serialization_bytes() == 36);
@@ -135,7 +136,7 @@ TEST_CASE("hll sketch: check num std dev", "[hll_sketch]") {
 }
 
 void checkSerializationSizes(const int lgConfigK, target_hll_type tgtHllType) {
-  hll_sketch_test_alloc sk(lgConfigK, tgtHllType);
+  hll_sketch_test_alloc sk(lgConfigK, tgtHllType, false, 0);
   int i;
 
   // LIST
@@ -162,27 +163,23 @@ TEST_CASE("hll sketch: check ser sizes", "[hll_sketch]") {
 }
 
 TEST_CASE("hll sketch: exercise to string", "[hll_sketch]") {
-  test_allocator_total_bytes = 0;
-  {
-    hll_sketch_test_alloc sk(15, HLL_4);
-    for (int i = 0; i < 25; ++i) { sk.update(i); }
-    std::ostringstream oss(std::ios::binary);
-    oss << sk.to_string(false, true, true, true);
-    for (int i = 25; i < (1 << 20); ++i) { sk.update(i); }
-    oss << sk.to_string(false, true, true, true);
-    oss << sk.to_string(false, true, true, false);
-
-    sk = hll_sketch_test_alloc(8, HLL_8);
-    for (int i = 0; i < 25; ++i) { sk.update(i); }
-    oss << sk.to_string(false, true, true, true);
-  }
-  REQUIRE(test_allocator_total_bytes == 0);
+  hll_sketch sk(15, HLL_4);
+  for (int i = 0; i < 25; ++i) { sk.update(i); }
+  std::ostringstream oss(std::ios::binary);
+  oss << sk.to_string(false, true, true, true);
+  for (int i = 25; i < (1 << 20); ++i) { sk.update(i); }
+  oss << sk.to_string(false, true, true, true);
+  oss << sk.to_string(false, true, true, false);
+
+  sk = hll_sketch(8, HLL_8);
+  for (int i = 0; i < 25; ++i) { sk.update(i); }
+  oss << sk.to_string(false, true, true, true);
 }
 
 // Creates and serializes then deserializes sketch.
 // Returns true if deserialized sketch is compact.
 static bool checkCompact(const int lgK, const int n, const target_hll_type type, bool compact) {
-  hll_sketch_test_alloc sk(lgK, type);
+  hll_sketch_test_alloc sk(lgK, type, false, 0);
   for (int i = 0; i < n; ++i) { sk.update(i); }
   
   std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
@@ -194,7 +191,7 @@ static bool checkCompact(const int lgK, const int n, const target_hll_type type,
     REQUIRE(ss.tellp() == sk.get_updatable_serialization_bytes());
   }
   
-  hll_sketch_test_alloc sk2 = hll_sketch_test_alloc::deserialize(ss);
+  hll_sketch_test_alloc sk2 = hll_sketch_test_alloc::deserialize(ss, alloc(0));
   REQUIRE(sk2.get_estimate() == Approx(n).margin(0.01));
   bool isCompact = sk2.is_compact();
 
@@ -233,11 +230,10 @@ TEST_CASE("hll sketch: check compact flag", "[hll_sketch]") {
 TEST_CASE("hll sketch: check k limits", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sketch1(HllUtil<>::MIN_LOG_K, target_hll_type::HLL_8);
-    hll_sketch_test_alloc sketch2(HllUtil<>::MAX_LOG_K, target_hll_type::HLL_4);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MIN_LOG_K - 1), std::invalid_argument);
-
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MAX_LOG_K + 1), std::invalid_argument);
+    hll_sketch_test_alloc sketch1(HllUtil<>::MIN_LOG_K, target_hll_type::HLL_8, false, 0);
+    hll_sketch_test_alloc sketch2(HllUtil<>::MAX_LOG_K, target_hll_type::HLL_4, false, 0);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MIN_LOG_K - 1, target_hll_type::HLL_4, false, 0), std::invalid_argument);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MAX_LOG_K + 1, target_hll_type::HLL_4, false, 0), std::invalid_argument);
   }
   REQUIRE(test_allocator_total_bytes == 0);
 }
@@ -245,7 +241,7 @@ TEST_CASE("hll sketch: check k limits", "[hll_sketch]") {
 TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sk(8, target_hll_type::HLL_8);
+    hll_sketch_test_alloc sk(8, target_hll_type::HLL_8, false, 0);
 
     // inserting the same value as a variety of input types
     sk.update((uint8_t) 102);
@@ -271,19 +267,19 @@ TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
     sk.update(str.c_str(), str.length());
     REQUIRE(sk.get_estimate() == Approx(4.0).margin(0.01));
 
-    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_6);
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_6, false, 0);
     sk.update((float) 0.0);
     sk.update((float) -0.0);
     sk.update((double) 0.0);
     sk.update((double) -0.0);
     REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
 
-    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4);
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4, false, 0);
     sk.update(std::nanf("3"));
     sk.update(std::nan("9"));
     REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
 
-    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4);
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4, false, 0);
     sk.update(nullptr, 0);
     sk.update("");
     REQUIRE(sk.is_empty());
@@ -294,24 +290,24 @@ TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
 TEST_CASE("hll sketch: deserialize list mode buffer overrun", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sketch(10);
+    hll_sketch_test_alloc sketch(10, target_hll_type::HLL_4, false, 0);
     sketch.update(1);
     auto bytes = sketch.serialize_compact();
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
     // ckeck for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 7));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
   }
   REQUIRE(test_allocator_total_bytes == 0);
@@ -320,25 +316,25 @@ TEST_CASE("hll sketch: deserialize list mode buffer overrun", "[hll_sketch]") {
 TEST_CASE("hll sketch: deserialize set mode buffer overrun", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sketch(10);
+    hll_sketch_test_alloc sketch(10, target_hll_type::HLL_4, false, 0);
     for (int i = 0; i < 10; ++i) sketch.update(i);
     //std::cout << sketch.to_string();
     auto bytes = sketch.serialize_updatable();
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
     // ckeck for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 7));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
   }
   REQUIRE(test_allocator_total_bytes == 0);
@@ -348,39 +344,39 @@ TEST_CASE("hll sketch: deserialize HLL mode buffer overrun", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
     // this sketch should have aux table
-    hll_sketch_test_alloc sketch(15);
+    hll_sketch_test_alloc sketch(15, target_hll_type::HLL_4, false, 0);
     for (int i = 0; i < 14444; ++i) sketch.update(i);
     //std::cout << sketch.to_string();
     auto bytes = sketch.serialize_compact();
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 15), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 16420), std::out_of_range); // before aux table
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 15, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 16420, 0), std::out_of_range); // before aux table
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
     // ckeck for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 7));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 15));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 16420)); // before aux table
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
   }
   REQUIRE(test_allocator_total_bytes == 0);