datasketches 0.2.7 → 0.3.0

data/vendor/datasketches-cpp/fi/include/frequent_items_sketch_impl.hpp

@@ -30,40 +30,42 @@
 namespace datasketches {
 
 // clang++ seems to require this declaration for CMAKE_BUILD_TYPE='Debug"
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-const uint8_t frequent_items_sketch<T, W, H, E, S, A>::LG_MIN_MAP_SIZE;
+template<typename T, typename W, typename H, typename E, typename A>
+const uint8_t frequent_items_sketch<T, W, H, E, A>::LG_MIN_MAP_SIZE;
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-frequent_items_sketch<T, W, H, E, S, A>::frequent_items_sketch(uint8_t lg_max_map_size, uint8_t lg_start_map_size, const A& allocator):
+template<typename T, typename W, typename H, typename E, typename A>
+frequent_items_sketch<T, W, H, E, A>::frequent_items_sketch(uint8_t lg_max_map_size, uint8_t lg_start_map_size,
+    const E& equal, const A& allocator):
 total_weight(0),
 offset(0),
 map(
   std::max(lg_start_map_size, frequent_items_sketch::LG_MIN_MAP_SIZE),
   std::max(lg_max_map_size, frequent_items_sketch::LG_MIN_MAP_SIZE),
+  equal,
   allocator
 )
 {
   if (lg_start_map_size > lg_max_map_size) throw std::invalid_argument("starting size must not be greater than maximum size");
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::update(const T& item, W weight) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::update(const T& item, W weight) {
   check_weight(weight);
   if (weight == 0) return;
   total_weight += weight;
   offset += map.adjust_or_insert(item, weight);
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::update(T&& item, W weight) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::update(T&& item, W weight) {
   check_weight(weight);
   if (weight == 0) return;
   total_weight += weight;
   offset += map.adjust_or_insert(std::move(item), weight);
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::merge(const frequent_items_sketch& other) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::merge(const frequent_items_sketch& other) {
   if (other.is_empty()) return;
   const W merged_total_weight = total_weight + other.get_total_weight(); // for correction at the end
   for (auto it: other.map) {
@@ -73,8 +75,8 @@ void frequent_items_sketch<T, W, H, E, S, A>::merge(const frequent_items_sketch&
   total_weight = merged_total_weight;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::merge(frequent_items_sketch&& other) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::merge(frequent_items_sketch&& other) {
   if (other.is_empty()) return;
   const W merged_total_weight = total_weight + other.get_total_weight(); // for correction at the end
   for (auto it: other.map) {
@@ -84,69 +86,67 @@ void frequent_items_sketch<T, W, H, E, S, A>::merge(frequent_items_sketch&& othe
   total_weight = merged_total_weight;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-bool frequent_items_sketch<T, W, H, E, S, A>::is_empty() const {
+template<typename T, typename W, typename H, typename E, typename A>
+bool frequent_items_sketch<T, W, H, E, A>::is_empty() const {
   return map.get_num_active() == 0;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-uint32_t frequent_items_sketch<T, W, H, E, S, A>::get_num_active_items() const {
+template<typename T, typename W, typename H, typename E, typename A>
+uint32_t frequent_items_sketch<T, W, H, E, A>::get_num_active_items() const {
   return map.get_num_active();
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-W frequent_items_sketch<T, W, H, E, S, A>::get_total_weight() const {
+template<typename T, typename W, typename H, typename E, typename A>
+W frequent_items_sketch<T, W, H, E, A>::get_total_weight() const {
   return total_weight;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-W frequent_items_sketch<T, W, H, E, S, A>::get_estimate(const T& item) const {
+template<typename T, typename W, typename H, typename E, typename A>
+W frequent_items_sketch<T, W, H, E, A>::get_estimate(const T& item) const {
   // if item is tracked estimate = weight + offset, otherwise 0
   const W weight = map.get(item);
   if (weight > 0) return weight + offset;
   return 0;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-W frequent_items_sketch<T, W, H, E, S, A>::get_lower_bound(const T& item) const {
+template<typename T, typename W, typename H, typename E, typename A>
+W frequent_items_sketch<T, W, H, E, A>::get_lower_bound(const T& item) const {
   return map.get(item);
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-W frequent_items_sketch<T, W, H, E, S, A>::get_upper_bound(const T& item) const {
+template<typename T, typename W, typename H, typename E, typename A>
+W frequent_items_sketch<T, W, H, E, A>::get_upper_bound(const T& item) const {
   return map.get(item) + offset;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-W frequent_items_sketch<T, W, H, E, S, A>::get_maximum_error() const {
+template<typename T, typename W, typename H, typename E, typename A>
+W frequent_items_sketch<T, W, H, E, A>::get_maximum_error() const {
   return offset;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-double frequent_items_sketch<T, W, H, E, S, A>::get_epsilon() const {
+template<typename T, typename W, typename H, typename E, typename A>
+double frequent_items_sketch<T, W, H, E, A>::get_epsilon() const {
   return EPSILON_FACTOR / (1 << map.get_lg_max_size());
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-double frequent_items_sketch<T, W, H, E, S, A>::get_epsilon(uint8_t lg_max_map_size) {
+template<typename T, typename W, typename H, typename E, typename A>
+double frequent_items_sketch<T, W, H, E, A>::get_epsilon(uint8_t lg_max_map_size) {
   return EPSILON_FACTOR / (1 << lg_max_map_size);
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-double frequent_items_sketch<T, W, H, E, S, A>::get_apriori_error(uint8_t lg_max_map_size, W estimated_total_weight) {
+template<typename T, typename W, typename H, typename E, typename A>
+double frequent_items_sketch<T, W, H, E, A>::get_apriori_error(uint8_t lg_max_map_size, W estimated_total_weight) {
   return get_epsilon(lg_max_map_size) * estimated_total_weight;
 }
 
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-typename frequent_items_sketch<T, W, H, E, S, A>::vector_row
-frequent_items_sketch<T, W, H, E, S, A>::get_frequent_items(frequent_items_error_type err_type) const {
+template<typename T, typename W, typename H, typename E, typename A>
+auto frequent_items_sketch<T, W, H, E, A>::get_frequent_items(frequent_items_error_type err_type) const -> vector_row {
   return get_frequent_items(err_type, get_maximum_error());
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-typename frequent_items_sketch<T, W, H, E, S, A>::vector_row
-frequent_items_sketch<T, W, H, E, S, A>::get_frequent_items(frequent_items_error_type err_type, W threshold) const {
+template<typename T, typename W, typename H, typename E, typename A>
+auto frequent_items_sketch<T, W, H, E, A>::get_frequent_items(frequent_items_error_type err_type, W threshold) const -> vector_row {
   vector_row items(map.get_allocator());
   for (auto it: map) {
     const W lb = it.second;
@@ -160,9 +160,9 @@ frequent_items_sketch<T, W, H, E, S, A>::get_frequent_items(frequent_items_error
   return items;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename SerDe>
-void frequent_items_sketch<T, W, H, E, S, A>::serialize(std::ostream& os, const SerDe& sd) const {
+void frequent_items_sketch<T, W, H, E, A>::serialize(std::ostream& os, const SerDe& sd) const {
   const uint8_t preamble_longs = is_empty() ? PREAMBLE_LONGS_EMPTY : PREAMBLE_LONGS_NONEMPTY;
   write(os, preamble_longs);
   const uint8_t serial_version = SERIAL_VERSION;
@@ -206,18 +206,18 @@ void frequent_items_sketch<T, W, H, E, S, A>::serialize(std::ostream& os, const
   }
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename SerDe>
-size_t frequent_items_sketch<T, W, H, E, S, A>::get_serialized_size_bytes(const SerDe& sd) const {
+size_t frequent_items_sketch<T, W, H, E, A>::get_serialized_size_bytes(const SerDe& sd) const {
   if (is_empty()) return PREAMBLE_LONGS_EMPTY * sizeof(uint64_t);
   size_t size = PREAMBLE_LONGS_NONEMPTY * sizeof(uint64_t) + map.get_num_active() * sizeof(W);
   for (auto it: map) size += sd.size_of_item(it.first);
   return size;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename SerDe>
-auto frequent_items_sketch<T, W, H, E, S, A>::serialize(unsigned header_size_bytes, const SerDe& sd) const -> vector_bytes {
+auto frequent_items_sketch<T, W, H, E, A>::serialize(unsigned header_size_bytes, const SerDe& sd) const -> vector_bytes {
   const size_t size = header_size_bytes + get_serialized_size_bytes(sd);
   vector_bytes bytes(size, 0, map.get_allocator());
   uint8_t* ptr = bytes.data() + header_size_bytes;
@@ -266,8 +266,8 @@ auto frequent_items_sketch<T, W, H, E, S, A>::serialize(unsigned header_size_byt
   return bytes;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-class frequent_items_sketch<T, W, H, E, S, A>::items_deleter {
+template<typename T, typename W, typename H, typename E, typename A>
+class frequent_items_sketch<T, W, H, E, A>::items_deleter {
 public:
   items_deleter(uint32_t num, bool destroy, const A& allocator):
     allocator_(allocator), num_(num), destroy_(destroy) {}
@@ -286,14 +286,10 @@ private:
   bool destroy_;
 };
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>::deserialize(std::istream& is, const A& allocator) {
-  return deserialize(is, S(), allocator);
-}
-
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename SerDe>
-frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>::deserialize(std::istream& is, const SerDe& sd, const A& allocator) {
+frequent_items_sketch<T, W, H, E, A> frequent_items_sketch<T, W, H, E, A>::deserialize(std::istream& is,
+    const SerDe& sd, const E& equal, const A& allocator) {
   const auto preamble_longs = read<uint8_t>(is);
   const auto serial_version = read<uint8_t>(is);
   const auto family_id = read<uint8_t>(is);
@@ -309,7 +305,7 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
   check_family_id(family_id);
   check_size(lg_cur_size, lg_max_size);
 
-  frequent_items_sketch<T, W, H, E, S, A> sketch(lg_max_size, lg_cur_size, allocator);
+  frequent_items_sketch sketch(lg_max_size, lg_cur_size, equal, allocator);
   if (!is_empty) {
     const auto num_items = read<uint32_t>(is);
     read<uint32_t>(is); // unused
@@ -335,14 +331,10 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
   return sketch;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>::deserialize(const void* bytes, size_t size, const A& allocator) {
-  return deserialize(bytes, size, S(), allocator);
-}
-
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename SerDe>
-frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>::deserialize(const void* bytes, size_t size, const SerDe& sd, const A& allocator) {
+frequent_items_sketch<T, W, H, E, A> frequent_items_sketch<T, W, H, E, A>::deserialize(const void* bytes, size_t size,
+    const SerDe& sd, const E& equal, const A& allocator) {
   ensure_minimum_memory(size, 8);
   const char* ptr = static_cast<const char*>(bytes);
   const char* base = static_cast<const char*>(bytes);
@@ -368,7 +360,7 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
   check_size(lg_cur_size, lg_max_size);
   ensure_minimum_memory(size, preamble_longs * sizeof(uint64_t));
 
-  frequent_items_sketch<T, W, H, E, S, A> sketch(lg_max_size, lg_cur_size, allocator);
+  frequent_items_sketch sketch(lg_max_size, lg_cur_size, equal, allocator);
   if (!is_empty) {
     uint32_t num_items;
     ptr += copy_from_mem(ptr, num_items);
@@ -398,8 +390,8 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
   return sketch;
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::check_preamble_longs(uint8_t preamble_longs, bool is_empty) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::check_preamble_longs(uint8_t preamble_longs, bool is_empty) {
   if (is_empty) {
     if (preamble_longs != PREAMBLE_LONGS_EMPTY) {
       throw std::invalid_argument("Possible corruption: preamble longs of an empty sketch must be " + std::to_string(PREAMBLE_LONGS_EMPTY) + ": " + std::to_string(preamble_longs));
@@ -411,22 +403,22 @@ void frequent_items_sketch<T, W, H, E, S, A>::check_preamble_longs(uint8_t pream
   }
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::check_serial_version(uint8_t serial_version) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::check_serial_version(uint8_t serial_version) {
   if (serial_version != SERIAL_VERSION) {
     throw std::invalid_argument("Possible corruption: serial version must be " + std::to_string(SERIAL_VERSION) + ": " + std::to_string(serial_version));
   }
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::check_family_id(uint8_t family_id) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::check_family_id(uint8_t family_id) {
   if (family_id != FAMILY_ID) {
     throw std::invalid_argument("Possible corruption: family ID must be " + std::to_string(FAMILY_ID) + ": " + std::to_string(family_id));
   }
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::check_size(uint8_t lg_cur_size, uint8_t lg_max_size) {
+template<typename T, typename W, typename H, typename E, typename A>
+void frequent_items_sketch<T, W, H, E, A>::check_size(uint8_t lg_cur_size, uint8_t lg_max_size) {
   if (lg_cur_size > lg_max_size) {
     throw std::invalid_argument("Possible corruption: expected lg_cur_size <= lg_max_size: " + std::to_string(lg_cur_size) + " <= " + std::to_string(lg_max_size));
   }
@@ -435,8 +427,8 @@ void frequent_items_sketch<T, W, H, E, S, A>::check_size(uint8_t lg_cur_size, ui
   }
 }
 
-template<typename T, typename W, typename H, typename E, typename S, typename A>
-string<A> frequent_items_sketch<T, W, H, E, S, A>::to_string(bool print_items) const {
+template<typename T, typename W, typename H, typename E, typename A>
+string<A> frequent_items_sketch<T, W, H, E, A>::to_string(bool print_items) const {
   // Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
   // The stream does not support passing an allocator instance, and alternatives are complicated.
   std::ostringstream os;
@@ -466,23 +458,23 @@ string<A> frequent_items_sketch<T, W, H, E, S, A>::to_string(bool print_items) c
 }
 
 // version for integral signed type
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename WW, typename std::enable_if<std::is_integral<WW>::value && std::is_signed<WW>::value, int>::type>
-void frequent_items_sketch<T, W, H, E, S, A>::check_weight(WW weight) {
+void frequent_items_sketch<T, W, H, E, A>::check_weight(WW weight) {
   if (weight < 0) {
     throw std::invalid_argument("weight must be non-negative");
   }
 }
 
 // version for integral unsigned type - no-op
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename WW, typename std::enable_if<std::is_integral<WW>::value && std::is_unsigned<WW>::value, int>::type>
-void frequent_items_sketch<T, W, H, E, S, A>::check_weight(WW) {}
+void frequent_items_sketch<T, W, H, E, A>::check_weight(WW) {}
 
 // version for floating point type
-template<typename T, typename W, typename H, typename E, typename S, typename A>
+template<typename T, typename W, typename H, typename E, typename A>
 template<typename WW, typename std::enable_if<std::is_floating_point<WW>::value, int>::type>
-void frequent_items_sketch<T, W, H, E, S, A>::check_weight(WW weight) {
+void frequent_items_sketch<T, W, H, E, A>::check_weight(WW weight) {
   if (weight < 0) {
     throw std::invalid_argument("weight must be non-negative");
   }

data/vendor/datasketches-cpp/fi/include/reverse_purge_hash_map.hpp

@@ -29,21 +29,27 @@ namespace datasketches {
  * This is a specialized linear-probing hash map with a reverse purge operation
  * that removes all entries in the map with values that are less than zero.
  * Based on Java implementation here:
- * https://github.com/DataSketches/sketches-core/blob/master/src/main/java/com/yahoo/sketches/frequencies/ReversePurgeItemHashMap.java
+ * https://github.com/apache/datasketches-java/blob/master/src/main/java/org/apache/datasketches/frequencies/ReversePurgeItemHashMap.java
  * author Alexander Saydakov
  */
 
-template<typename K, typename V = uint64_t, typename H = std::hash<K>, typename E = std::equal_to<K>, typename A = std::allocator<K>>
+template<
+  typename K,
+  typename V = uint64_t,
+  typename H = std::hash<K>,
+  typename E = std::equal_to<K>,
+  typename A = std::allocator<K>
+>
 class reverse_purge_hash_map {
 public:
   using AllocV = typename std::allocator_traits<A>::template rebind_alloc<V>;
   using AllocU16 = typename std::allocator_traits<A>::template rebind_alloc<uint16_t>;
 
-  reverse_purge_hash_map(uint8_t lg_size, uint8_t lg_max_size, const A& allocator);
+  reverse_purge_hash_map(uint8_t lg_size, uint8_t lg_max_size, const E& equal, const A& allocator);
   reverse_purge_hash_map(const reverse_purge_hash_map& other);
   reverse_purge_hash_map(reverse_purge_hash_map&& other) noexcept;
   ~reverse_purge_hash_map();
-  reverse_purge_hash_map& operator=(reverse_purge_hash_map other);
+  reverse_purge_hash_map& operator=(const reverse_purge_hash_map& other);
   reverse_purge_hash_map& operator=(reverse_purge_hash_map&& other);
 
   template<typename FwdK>
@@ -65,6 +71,7 @@ private:
   static constexpr uint16_t DRIFT_LIMIT = 1024; // used only for stress testing
   static constexpr uint32_t MAX_SAMPLE_SIZE = 1024; // number of samples to compute approximate median during purge
 
+  E equal_;
   A allocator_;
   uint8_t lg_cur_size_;
   uint8_t lg_max_size_;

data/vendor/datasketches-cpp/fi/include/reverse_purge_hash_map_impl.hpp

@@ -34,7 +34,9 @@ template<typename K, typename V, typename H, typename E, typename A>
 constexpr uint32_t reverse_purge_hash_map<K, V, H, E, A>::MAX_SAMPLE_SIZE;
 
 template<typename K, typename V, typename H, typename E, typename A>
-reverse_purge_hash_map<K, V, H, E, A>::reverse_purge_hash_map(uint8_t lg_cur_size, uint8_t lg_max_size, const A& allocator):
+reverse_purge_hash_map<K, V, H, E, A>::reverse_purge_hash_map(uint8_t lg_cur_size, uint8_t lg_max_size,
+    const E& equal, const A& allocator):
+equal_(equal),
 allocator_(allocator),
 lg_cur_size_(lg_cur_size),
 lg_max_size_(lg_max_size),
@@ -52,6 +54,7 @@ states_(nullptr)
 
 template<typename K, typename V, typename H, typename E, typename A>
 reverse_purge_hash_map<K, V, H, E, A>::reverse_purge_hash_map(const reverse_purge_hash_map<K, V, H, E, A>& other):
+equal_(other.equal_),
 allocator_(other.allocator_),
 lg_cur_size_(other.lg_cur_size_),
 lg_max_size_(other.lg_max_size_),
@@ -80,6 +83,7 @@ states_(nullptr)
 
 template<typename K, typename V, typename H, typename E, typename A>
 reverse_purge_hash_map<K, V, H, E, A>::reverse_purge_hash_map(reverse_purge_hash_map<K, V, H, E, A>&& other) noexcept:
+equal_(std::move(other.equal_)),
 allocator_(std::move(other.allocator_)),
 lg_cur_size_(other.lg_cur_size_),
 lg_max_size_(other.lg_max_size_),
@@ -119,19 +123,22 @@ reverse_purge_hash_map<K, V, H, E, A>::~reverse_purge_hash_map() {
 }
 
 template<typename K, typename V, typename H, typename E, typename A>
-reverse_purge_hash_map<K, V, H, E, A>& reverse_purge_hash_map<K, V, H, E, A>::operator=(reverse_purge_hash_map<K, V, H, E, A> other) {
-  std::swap(allocator_, other.allocator_);
-  std::swap(lg_cur_size_, other.lg_cur_size_);
-  std::swap(lg_max_size_, other.lg_max_size_);
-  std::swap(num_active_, other.num_active_);
-  std::swap(keys_, other.keys_);
-  std::swap(values_, other.values_);
-  std::swap(states_, other.states_);
+reverse_purge_hash_map<K, V, H, E, A>& reverse_purge_hash_map<K, V, H, E, A>::operator=(const reverse_purge_hash_map<K, V, H, E, A>& other) {
+  reverse_purge_hash_map copy(other);
+  std::swap(equal_, copy.equal_);
+  std::swap(allocator_, copy.allocator_);
+  std::swap(lg_cur_size_, copy.lg_cur_size_);
+  std::swap(lg_max_size_, copy.lg_max_size_);
+  std::swap(num_active_, copy.num_active_);
+  std::swap(keys_, copy.keys_);
+  std::swap(values_, copy.values_);
+  std::swap(states_, copy.states_);
   return *this;
 }
 
 template<typename K, typename V, typename H, typename E, typename A>
 reverse_purge_hash_map<K, V, H, E, A>& reverse_purge_hash_map<K, V, H, E, A>::operator=(reverse_purge_hash_map<K, V, H, E, A>&& other) {
+  std::swap(equal_, other.equal_);
   std::swap(allocator_, other.allocator_);
   std::swap(lg_cur_size_, other.lg_cur_size_);
   std::swap(lg_max_size_, other.lg_max_size_);

data/vendor/datasketches-cpp/fi/test/CMakeLists.txt

@@ -17,7 +17,7 @@
 
 add_executable(fi_test)
 
-target_link_libraries(fi_test fi common_test)
+target_link_libraries(fi_test fi common_test_lib)
 
 set_target_properties(fi_test PROPERTIES
   CXX_STANDARD 11

data/vendor/datasketches-cpp/fi/test/frequent_items_sketch_custom_type_test.cpp

@@ -27,62 +27,75 @@
 
 namespace datasketches {
 
-using frequent_test_type_sketch = frequent_items_sketch<test_type, float, test_type_hash, test_type_equal, test_type_serde, test_allocator<test_type>>;
+using frequent_test_type_sketch = frequent_items_sketch<test_type, float, test_type_hash, test_type_equal, test_allocator<test_type>>;
 using alloc = test_allocator<test_type>;
 
 TEST_CASE("frequent items: custom type", "[frequent_items_sketch]") {
-  frequent_test_type_sketch sketch(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, 0);
-  sketch.update(1, 10); // should survive the purge
-  sketch.update(2);
-  sketch.update(3);
-  sketch.update(4);
-  sketch.update(5);
-  sketch.update(6);
-  sketch.update(7);
-  test_type a8(8);
-  sketch.update(a8);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE(sketch.get_total_weight() == 17);
-  REQUIRE(sketch.get_estimate(1) == 10);
+  test_allocator_total_bytes = 0;
+  {
+    frequent_test_type_sketch sketch(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, test_type_equal(), 0);
+    sketch.update(1, 10); // should survive the purge
+    sketch.update(2);
+    sketch.update(3);
+    sketch.update(4);
+    sketch.update(5);
+    sketch.update(6);
+    sketch.update(7);
+    test_type a8(8);
+    sketch.update(a8);
+    REQUIRE_FALSE(sketch.is_empty());
+    REQUIRE(sketch.get_total_weight() == 17);
+    REQUIRE(sketch.get_estimate(1) == 10);
 
-  auto items = sketch.get_frequent_items(frequent_items_error_type::NO_FALSE_POSITIVES);
-  REQUIRE(items.size() == 1); // only 1 item should be above threshold
-  REQUIRE(items[0].get_item().get_value() == 1);
-  REQUIRE(items[0].get_estimate() == 10);
+    auto items = sketch.get_frequent_items(frequent_items_error_type::NO_FALSE_POSITIVES);
+    REQUIRE(items.size() == 1); // only 1 item should be above threshold
+    REQUIRE(items[0].get_item().get_value() == 1);
+    REQUIRE(items[0].get_estimate() == 10);
 
-  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
-  sketch.serialize(s);
-  auto sketch2 = frequent_test_type_sketch::deserialize(s, alloc(0));
-  REQUIRE_FALSE(sketch2.is_empty());
-  REQUIRE(sketch2.get_total_weight() == 17);
-  REQUIRE(sketch2.get_estimate(1) == 10);
-  REQUIRE(sketch.get_num_active_items() == sketch2.get_num_active_items());
-  REQUIRE(sketch.get_maximum_error() == sketch2.get_maximum_error());
+    std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+    sketch.serialize(s, test_type_serde());
+    auto sketch2 = frequent_test_type_sketch::deserialize(s, test_type_serde(), test_type_equal(), 0);
+    REQUIRE_FALSE(sketch2.is_empty());
+    REQUIRE(sketch2.get_total_weight() == 17);
+    REQUIRE(sketch2.get_estimate(1) == 10);
+    REQUIRE(sketch.get_num_active_items() == sketch2.get_num_active_items());
+    REQUIRE(sketch.get_maximum_error() == sketch2.get_maximum_error());
 
-  auto bytes = sketch.serialize();
-  auto sketch3 = frequent_test_type_sketch::deserialize(bytes.data(), bytes.size(), alloc(0));
-  REQUIRE_FALSE(sketch3.is_empty());
-  REQUIRE(sketch3.get_total_weight() == 17);
-  REQUIRE(sketch3.get_estimate(1) == 10);
-  REQUIRE(sketch.get_num_active_items() == sketch3.get_num_active_items());
-  REQUIRE(sketch.get_maximum_error() == sketch3.get_maximum_error());
+    auto bytes = sketch.serialize(0, test_type_serde());
+    auto sketch3 = frequent_test_type_sketch::deserialize(bytes.data(), bytes.size(), test_type_serde(),
+        test_type_equal(), 0);
+    REQUIRE_FALSE(sketch3.is_empty());
+    REQUIRE(sketch3.get_total_weight() == 17);
+    REQUIRE(sketch3.get_estimate(1) == 10);
+    REQUIRE(sketch.get_num_active_items() == sketch3.get_num_active_items());
+    REQUIRE(sketch.get_maximum_error() == sketch3.get_maximum_error());
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
 }
 
 // this is to see the debug print from test_type if enabled there to make sure items are moved
 TEST_CASE("frequent items: moving merge", "[frequent_items_sketch]") {
-  frequent_test_type_sketch sketch1(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, 0);
-  sketch1.update(1);
+  test_allocator_total_bytes = 0;
+  {
+    frequent_test_type_sketch sketch1(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, test_type_equal(), 0);
+    sketch1.update(1);
 
-  frequent_test_type_sketch sketch2(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, 0);
-  sketch2.update(2);
+    frequent_test_type_sketch sketch2(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, test_type_equal(), 0);
+    sketch2.update(2);
 
-  sketch2.merge(std::move(sketch1));
-  REQUIRE(sketch2.get_total_weight() == 2);
+    sketch2.merge(std::move(sketch1));
+    REQUIRE(sketch2.get_total_weight() == 2);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
 }
 
 TEST_CASE("frequent items: negative weight", "[frequent_items_sketch]") {
-  frequent_test_type_sketch sketch(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, 0);
-  REQUIRE_THROWS_AS(sketch.update(1, -1), std::invalid_argument);
+  test_allocator_total_bytes = 0;
+  {
+    frequent_test_type_sketch sketch(3, frequent_test_type_sketch::LG_MIN_MAP_SIZE, test_type_equal(), 0);
+    REQUIRE_THROWS_AS(sketch.update(1, -1), std::invalid_argument);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
 }
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/fi/test/reverse_purge_hash_map_test.cpp

@@ -24,20 +24,20 @@
 namespace datasketches {
 
 TEST_CASE("reverse purge hash map: empty", "[frequent_items_sketch]") {
-  reverse_purge_hash_map<int> map(3, 3, std::allocator<int>());
+  reverse_purge_hash_map<int> map(3, 3, std::equal_to<int>(), std::allocator<int>());
   REQUIRE(map.get_num_active() == 0);
   REQUIRE(map.get_lg_cur_size() == 3);  // static_cast<uint8_t>(3)
 }
 
 TEST_CASE("reverse purge hash map: one item", "[frequent_items_sketch]") {
-  reverse_purge_hash_map<int> map(3, 3, std::allocator<int>());
+  reverse_purge_hash_map<int> map(3, 3, std::equal_to<int>(), std::allocator<int>());
   map.adjust_or_insert(1, 1);
   REQUIRE(map.get_num_active() == 1);
   REQUIRE(map.get(1) == 1);
 }
 
 TEST_CASE("reverse purge hash map: iterator", "[frequent_items_sketch]") {
-  reverse_purge_hash_map<int> map(3, 4, std::allocator<int>());
+  reverse_purge_hash_map<int> map(3, 4, std::equal_to<int>(), std::allocator<int>());
   for (int i = 0; i < 11; i++) map.adjust_or_insert(i, 1); // this should fit with no purge
   uint64_t sum = 0;
   for (auto it: map) sum += it.second;

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

@@ -267,10 +267,10 @@ void Hll4Array<A>::shiftToBiggerCurMin() {
     for (const auto coupon: *auxHashMap_) {
       slotNum = HllUtil<A>::getLow26(coupon) & configKmask;
       oldActualVal = HllUtil<A>::getValue(coupon);
-      newShiftedVal = oldActualVal - newCurMin;
-      if (newShiftedVal < 0) {
+      if (oldActualVal < newCurMin) {
         throw std::logic_error("oldActualVal < newCurMin when incrementing curMin");
       }
+      newShiftedVal = oldActualVal - newCurMin;
 
       if (getSlot(slotNum) != hll_constants::AUX_TOKEN) {
         throw std::logic_error("getSlot(slotNum) != AUX_TOKEN for item in auxiliary hash map");

data/vendor/datasketches-cpp/hll/test/CMakeLists.txt

@@ -17,7 +17,7 @@
 
 add_executable(hll_test)
 
-target_link_libraries(hll_test hll common_test)
+target_link_libraries(hll_test hll common_test_lib)
 
 set_target_properties(hll_test PROPERTIES
   CXX_STANDARD 11