datasketches 0.2.3 → 0.2.6

data/vendor/datasketches-cpp/common/include/quantile_sketch_sorted_view_impl.hpp

@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef QUANTILE_SKETCH_SORTED_VIEW_IMPL_HPP_
+#define QUANTILE_SKETCH_SORTED_VIEW_IMPL_HPP_
+
+#include <algorithm>
+#include <stdexcept>
+
+namespace datasketches {
+
+template<typename T, typename C, typename A>
+quantile_sketch_sorted_view<T, C, A>::quantile_sketch_sorted_view(uint32_t num, const A& allocator):
+total_weight_(0),
+entries_(allocator)
+{
+  entries_.reserve(num);
+}
+
+template<typename T, typename C, typename A>
+template<typename Iterator>
+void quantile_sketch_sorted_view<T, C, A>::add(Iterator first, Iterator last, uint64_t weight) {
+  const size_t size_before = entries_.size();
+  for (auto it = first; it != last; ++it) entries_.push_back(Entry(ref_helper(*it), weight));
+  if (size_before > 0) {
+    Container tmp(entries_.get_allocator());
+    tmp.reserve(entries_.capacity());
+    std::merge(
+        entries_.begin(), entries_.begin() + size_before,
+        entries_.begin() + size_before, entries_.end(),
+        std::back_inserter(tmp), compare_pairs_by_first()
+    );
+    std::swap(tmp, entries_);
+  }
+}
+
+template<typename T, typename C, typename A>
+template<bool inclusive>
+void quantile_sketch_sorted_view<T, C, A>::convert_to_cummulative() {
+  uint64_t subtotal = 0;
+  for (auto& entry: entries_) {
+    const uint64_t new_subtotal = subtotal + entry.second;
+    entry.second = inclusive ? new_subtotal : subtotal;
+    subtotal = new_subtotal;
+  }
+  total_weight_ = subtotal;
+}
+
+template<typename T, typename C, typename A>
+auto quantile_sketch_sorted_view<T, C, A>::get_quantile(double rank) const -> quantile_return_type {
+  if (total_weight_ == 0) throw std::invalid_argument("supported for cumulative weight only");
+  uint64_t weight = static_cast<uint64_t>(rank * total_weight_);
+  auto it = std::lower_bound(entries_.begin(), entries_.end(), make_dummy_entry<T>(weight), compare_pairs_by_second());
+  if (it == entries_.end()) return deref_helper(entries_[entries_.size() - 1].first);
+  return deref_helper(it->first);
+}
+
+template<typename T, typename C, typename A>
+auto quantile_sketch_sorted_view<T, C, A>::begin() const -> const_iterator {
+  return entries_.begin();
+}
+
+template<typename T, typename C, typename A>
+auto quantile_sketch_sorted_view<T, C, A>::end() const -> const_iterator {
+  return entries_.end();
+}
+
+template<typename T, typename C, typename A>
+size_t quantile_sketch_sorted_view<T, C, A>::size() const {
+  return entries_.size();
+}
+
+} /* namespace datasketches */
+
+#endif

data/vendor/datasketches-cpp/common/test/test_type.hpp

@@ -20,7 +20,9 @@
 #ifndef CLASS_TEST_TYPE_HPP_
 #define CLASS_TEST_TYPE_HPP_
 
+#include <cstring>
 #include <iostream>
+#include "memory_operations.hpp"
 
 namespace datasketches {
 

data/vendor/datasketches-cpp/cpc/CMakeLists.txt

@@ -32,43 +32,23 @@ target_include_directories(cpc
 target_link_libraries(cpc INTERFACE common)
 target_compile_features(cpc INTERFACE cxx_std_11)
 
-set(cpc_HEADERS "")
-list(APPEND cpc_HEADERS "include/compression_data.hpp")
-list(APPEND cpc_HEADERS "include/cpc_common.hpp")
-list(APPEND cpc_HEADERS "include/cpc_compressor.hpp")
-list(APPEND cpc_HEADERS "include/cpc_compressor_impl.hpp")
-list(APPEND cpc_HEADERS "include/cpc_confidence.hpp")
-list(APPEND cpc_HEADERS "include/cpc_sketch.hpp")
-list(APPEND cpc_HEADERS "include/cpc_sketch_impl.hpp")
-list(APPEND cpc_HEADERS "include/cpc_union.hpp")
-list(APPEND cpc_HEADERS "include/cpc_union_impl.hpp")
-list(APPEND cpc_HEADERS "include/cpc_util.hpp")
-list(APPEND cpc_HEADERS "include/icon_estimator.hpp")
-list(APPEND cpc_HEADERS "include/kxp_byte_lookup.hpp")
-list(APPEND cpc_HEADERS "include/u32_table.hpp")
-list(APPEND cpc_HEADERS "include/u32_table_impl.hpp")
-
 install(TARGETS cpc
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${cpc_HEADERS}
+install(FILES 
+			include/compression_data.hpp
+			include/cpc_common.hpp
+			include/cpc_compressor.hpp
+			include/cpc_compressor_impl.hpp
+			include/cpc_confidence.hpp
+			include/cpc_sketch.hpp
+			include/cpc_sketch_impl.hpp
+			include/cpc_union.hpp
+			include/cpc_union_impl.hpp
+			include/cpc_util.hpp
+			include/icon_estimator.hpp
+			include/kxp_byte_lookup.hpp
+			include/u32_table.hpp
+			include/u32_table_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(cpc
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/compression_data.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_common.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_compressor.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_compressor_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_confidence.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_sketch_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_union.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_union_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_util.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/icon_estimator.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/kxp_byte_lookup.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/u32_table.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/u32_table_impl.hpp
-)

data/vendor/datasketches-cpp/cpc/include/cpc_compressor_impl.hpp

@@ -23,6 +23,7 @@
 #define CPC_COMPRESSOR_IMPL_HPP_
 
 #include <memory>
+#include <stdexcept>
 
 #include "compression_data.hpp"
 #include "cpc_util.hpp"
@@ -296,6 +297,7 @@ void cpc_compressor<A>::compress_sliding_flavor(const cpc_sketch_alloc<A>& sourc
     // changes the implied ordering of the pairs, so we must do it before sorting.
 
     const uint8_t pseudo_phase = determine_pseudo_phase(source.get_lg_k(), source.get_num_coupons());
+    if (pseudo_phase >= 16) throw std::logic_error("unexpected pseudo phase for sliding flavor");
     const uint8_t* permutation = column_permutations_for_encoding[pseudo_phase];
 
     const uint8_t offset = source.window_offset;
@@ -332,7 +334,7 @@ void cpc_compressor<A>::uncompress_sliding_flavor(const compressed_state<A>& sou
         lg_k, source.table_data.get_allocator());
 
     const uint8_t pseudo_phase = determine_pseudo_phase(lg_k, num_coupons);
-    if (pseudo_phase >= 16) throw std::logic_error("pseudo phase >= 16");
+    if (pseudo_phase >= 16) throw std::logic_error("unexpected pseudo phase for sliding flavor");
     const uint8_t* permutation = column_permutations_for_decoding[pseudo_phase];
 
     uint8_t offset = cpc_sketch_alloc<A>::determine_correct_offset(lg_k, num_coupons);

data/vendor/datasketches-cpp/cpc/include/cpc_confidence.hpp

@@ -23,6 +23,7 @@
 #define CPC_CONFIDENCE_HPP_
 
 #include <cmath>
+#include <stdexcept>
 
 #include "cpc_sketch.hpp"
 

data/vendor/datasketches-cpp/cpc/include/cpc_sketch_impl.hpp

@@ -381,7 +381,9 @@ void cpc_sketch_alloc<A>::refresh_kxp(const uint64_t* bit_matrix) {
 
 template<typename A>
 string<A> cpc_sketch_alloc<A>::to_string() const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
+  // 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;
   os << "### CPC sketch summary:" << std::endl;
   os << "   lg_k           : " << std::to_string(lg_k) << std::endl;
   os << "   seed hash      : " << std::hex << compute_seed_hash(seed) << std::dec << std::endl;
@@ -392,14 +394,14 @@ string<A> cpc_sketch_alloc<A>::to_string() const {
     os << "   HIP estimate   : " << hip_est_accum << std::endl;
     os << "   kxp            : " << kxp << std::endl;
   }
-  os << "   intresting col : " << std::to_string(first_interesting_column) << std::endl;
+  os << "   interesting col: " << std::to_string(first_interesting_column) << std::endl;
   os << "   table entries  : " << surprising_value_table.get_num_items() << std::endl;
   os << "   window         : " << (sliding_window.size() == 0 ? "not " : "") <<  "allocated" << std::endl;
   if (sliding_window.size() > 0) {
     os << "   window offset  : " << std::to_string(window_offset) << std::endl;
   }
   os << "### End sketch summary" << std::endl;
-  return os.str();
+  return string<A>(os.str().c_str(), sliding_window.get_allocator());
 }
 
 template<typename A>

data/vendor/datasketches-cpp/cpc/include/cpc_union_impl.hpp

@@ -22,6 +22,8 @@
 
 #include "count_zeros.hpp"
 
+#include <stdexcept>
+
 namespace datasketches {
 
 template<typename A>
@@ -34,7 +36,7 @@ bit_matrix(allocator)
   if (lg_k < CPC_MIN_LG_K || lg_k > CPC_MAX_LG_K) {
     throw std::invalid_argument("lg_k must be >= " + std::to_string(CPC_MIN_LG_K) + " and <= " + std::to_string(CPC_MAX_LG_K) + ": " + std::to_string(lg_k));
   }
-  accumulator = new (AllocCpc().allocate(1)) cpc_sketch_alloc<A>(lg_k, seed, allocator);
+  accumulator = new (AllocCpc(allocator).allocate(1)) cpc_sketch_alloc<A>(lg_k, seed, allocator);
 }
 
 template<typename A>
@@ -45,7 +47,7 @@ accumulator(other.accumulator),
 bit_matrix(other.bit_matrix)
 {
   if (accumulator != nullptr) {
-    accumulator = new (AllocCpc().allocate(1)) cpc_sketch_alloc<A>(*other.accumulator);
+    accumulator = new (AllocCpc(accumulator->get_allocator()).allocate(1)) cpc_sketch_alloc<A>(*other.accumulator);
   }
 }
 
@@ -62,8 +64,9 @@ bit_matrix(std::move(other.bit_matrix))
 template<typename A>
 cpc_union_alloc<A>::~cpc_union_alloc() {
   if (accumulator != nullptr) {
+    AllocCpc allocator(accumulator->get_allocator());
     accumulator->~cpc_sketch_alloc<A>();
-    AllocCpc().deallocate(accumulator, 1);
+    allocator.deallocate(accumulator, 1);
   }
 }
 
@@ -181,7 +184,7 @@ template<typename A>
 cpc_sketch_alloc<A> cpc_union_alloc<A>::get_result_from_accumulator() const {
   if (lg_k != accumulator->get_lg_k()) throw std::logic_error("lg_k != accumulator->lg_k");
   if (accumulator->get_num_coupons() == 0) {
-    return cpc_sketch_alloc<A>(lg_k, seed);
+    return cpc_sketch_alloc<A>(lg_k, seed, accumulator->get_allocator());
   }
   if (accumulator->determine_flavor() != cpc_sketch_alloc<A>::flavor::SPARSE) throw std::logic_error("wrong flavor");
   cpc_sketch_alloc<A> copy(*accumulator);
@@ -242,8 +245,9 @@ cpc_sketch_alloc<A> cpc_union_alloc<A>::get_result_from_bit_matrix() const {
 template<typename A>
 void cpc_union_alloc<A>::switch_to_bit_matrix() {
   bit_matrix = accumulator->build_bit_matrix();
+  AllocCpc allocator(accumulator->get_allocator());
   accumulator->~cpc_sketch_alloc<A>();
-  AllocCpc().deallocate(accumulator, 1);
+  allocator.deallocate(accumulator, 1);
   accumulator = nullptr;
 }
 
@@ -324,7 +328,7 @@ void cpc_union_alloc<A>::reduce_k(uint8_t new_lg_k) {
     if (bit_matrix.size() > 0) throw std::logic_error("bit_matrix is not expected");
     if (!accumulator->is_empty()) {
       cpc_sketch_alloc<A> old_accumulator(*accumulator);
-      *accumulator = cpc_sketch_alloc<A>(new_lg_k, seed);
+      *accumulator = cpc_sketch_alloc<A>(new_lg_k, seed, old_accumulator.get_allocator());
       walk_table_updating_sketch(old_accumulator.surprising_value_table);
     }
     lg_k = new_lg_k;

data/vendor/datasketches-cpp/cpc/test/cpc_sketch_allocation_test.cpp

@@ -25,6 +25,7 @@
 #include <catch.hpp>
 
 #include "cpc_sketch.hpp"
+#include "cpc_union.hpp"
 #include "test_allocator.hpp"
 
 namespace datasketches {
@@ -234,4 +235,20 @@ TEST_CASE("cpc sketch allocation: serialize deserialize sliding, bytes", "[cpc_s
   REQUIRE(test_allocator_net_allocations == 0);
 }
 
+using cpc_union_test_alloc = cpc_union_alloc<test_allocator<uint8_t>>;
+
+TEST_CASE("cpc sketch allocation: union") {
+  cpc_sketch_test_alloc s1(11, DEFAULT_SEED, 0);
+  s1.update(1);
+
+  cpc_sketch_test_alloc s2(11, DEFAULT_SEED, 0);
+  s2.update(2);
+
+  cpc_union_test_alloc u(11, DEFAULT_SEED, 0);
+  u.update(s1);
+  u.update(s2);
+  auto s3 = u.get_result();
+  REQUIRE_FALSE(s3.is_empty());
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/cpc/test/cpc_sketch_test.cpp

@@ -21,6 +21,7 @@
 #include <cstring>
 #include <sstream>
 #include <fstream>
+#include <stdexcept>
 
 #include <catch.hpp>
 

data/vendor/datasketches-cpp/cpc/test/cpc_union_test.cpp

@@ -21,6 +21,8 @@
 
 #include "cpc_union.hpp"
 
+#include <stdexcept>
+
 namespace datasketches {
 
 static const double RELATIVE_ERROR_FOR_LG_K_11 = 0.02;

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

@@ -32,23 +32,13 @@ target_include_directories(fi
 target_link_libraries(fi INTERFACE common)
 target_compile_features(fi INTERFACE cxx_std_11)
 
-set(fi_HEADERS "")
-list(APPEND fi_HEADERS "include/frequent_items_sketch.hpp")
-list(APPEND fi_HEADERS "include/frequent_items_sketch_impl.hpp")
-list(APPEND fi_HEADERS "include/reverse_purge_hash_map.hpp")
-list(APPEND fi_HEADERS "include/reverse_purge_hash_map_impl.hpp")
-
 install(TARGETS fi
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${fi_HEADERS}
+install(FILES 
+		include/frequent_items_sketch.hpp
+		include/frequent_items_sketch_impl.hpp
+		include/reverse_purge_hash_map.hpp
+		include/reverse_purge_hash_map_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(fi
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/frequent_items_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/frequent_items_sketch_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/reverse_purge_hash_map.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/reverse_purge_hash_map_impl.hpp
-)

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

@@ -46,7 +46,7 @@ template<
   typename W = uint64_t,
   typename H = std::hash<T>,
   typename E = std::equal_to<T>,
-  typename S = serde<T>,
+  typename S = serde<T>, // deprecated, to be removed in the next major version
   typename A = std::allocator<T>
 >
 class frequent_items_sketch {
@@ -225,46 +225,78 @@ public:
   /**
    * Computes size needed to serialize the current state of the sketch.
    * This can be expensive since every item needs to be looked at.
+   * @param instance of a SerDe
    * @return size in bytes needed to serialize this sketch
    */
-  size_t get_serialized_size_bytes() const;
+  template<typename SerDe = S>
+  size_t get_serialized_size_bytes(const SerDe& sd = SerDe()) const;
 
   /**
    * This method serializes the sketch into a given stream in a binary form
    * @param os output stream
+   * @param instance of a SerDe
    */
-  void serialize(std::ostream& os) const;
+  template<typename SerDe = S>
+  void serialize(std::ostream& os, const SerDe& sd = SerDe()) const;
 
   // This is a convenience alias for users
   // The type returned by the following serialize method
   using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
 
-
   /**
    * This method serializes the sketch as a vector of bytes.
    * An optional header can be reserved in front of the sketch.
    * It is a blank space of a given size.
    * This header is used in Datasketches PostgreSQL extension.
    * @param header_size_bytes space to reserve in front of the sketch
+   * @param instance of a SerDe
    * @return serialized sketch as a vector of bytes
    */
-  vector_bytes serialize(unsigned header_size_bytes = 0) const;
+  template<typename SerDe = S>
+  vector_bytes serialize(unsigned header_size_bytes = 0, const SerDe& sd = SerDe()) const;
 
   /**
    * This method deserializes a sketch from a given stream.
    * @param is input stream
+   * @param instance of an Allocator
    * @return an instance of the sketch
+   *
+   * Deprecated, to be removed in the next major version
    */
   static frequent_items_sketch deserialize(std::istream& is, const A& allocator = A());
 
+  /**
+   * This method deserializes a sketch from a given stream.
+   * @param is input stream
+   * @param instance of a SerDe
+   * @param instance of an Allocator
+   * @return an instance of the sketch
+   */
+  template<typename SerDe = S>
+  static frequent_items_sketch deserialize(std::istream& is, const SerDe& sd = SerDe(), const A& allocator = A());
+
   /**
    * This method deserializes a sketch from a given array of bytes.
    * @param bytes pointer to the array of bytes
    * @param size the size of the array
+   * @param instance of an Allocator
    * @return an instance of the sketch
+   *
+   * Deprecated, to be removed in the next major version
    */
   static frequent_items_sketch deserialize(const void* bytes, size_t size, const A& allocator = A());
 
+  /**
+   * This method deserializes a sketch from a given array of bytes.
+   * @param bytes pointer to the array of bytes
+   * @param size the size of the array
+   * @param instance of a SerDe
+   * @param instance of an Allocator
+   * @return an instance of the sketch
+   */
+  template<typename SerDe = S>
+  static frequent_items_sketch deserialize(const void* bytes, size_t size, const SerDe& sd = SerDe(), const A& allocator = A());
+
   /**
    * Returns a human readable summary of this sketch
    * @param print_items if true include the list of items retained by the sketch

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

@@ -23,6 +23,7 @@
 #include <cstring>
 #include <limits>
 #include <sstream>
+#include <stdexcept>
 
 #include "memory_operations.hpp"
 
@@ -160,7 +161,8 @@ frequent_items_sketch<T, W, H, E, S, A>::get_frequent_items(frequent_items_error
 }
 
 template<typename T, typename W, typename H, typename E, typename S, typename A>
-void frequent_items_sketch<T, W, H, E, S, A>::serialize(std::ostream& os) const {
+template<typename SerDe>
+void frequent_items_sketch<T, W, H, E, S, 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;
@@ -198,23 +200,25 @@ void frequent_items_sketch<T, W, H, E, S, A>::serialize(std::ostream& os) const
     }
     write(os, weights, sizeof(W) * num_items);
     aw.deallocate(weights, num_items);
-    S().serialize(os, items, num_items);
+    sd.serialize(os, items, num_items);
     for (i = 0; i < num_items; i++) items[i].~T();
     alloc.deallocate(items, num_items);
   }
 }
 
 template<typename T, typename W, typename H, typename E, typename S, typename A>
-size_t frequent_items_sketch<T, W, H, E, S, A>::get_serialized_size_bytes() const {
+template<typename SerDe>
+size_t frequent_items_sketch<T, W, H, E, S, 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 += S().size_of_item(it.first);
+  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>
-auto frequent_items_sketch<T, W, H, E, S, A>::serialize(unsigned header_size_bytes) const -> vector_bytes {
-  const size_t size = header_size_bytes + get_serialized_size_bytes();
+template<typename SerDe>
+auto frequent_items_sketch<T, W, H, E, S, 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;
   uint8_t* end_ptr = ptr + size;
@@ -255,7 +259,7 @@ auto frequent_items_sketch<T, W, H, E, S, A>::serialize(unsigned header_size_byt
     ptr += copy_to_mem(weights, ptr, sizeof(W) * num_items);
     aw.deallocate(weights, num_items);
     const size_t bytes_remaining = end_ptr - ptr;
-    ptr += S().serialize(ptr, bytes_remaining, items, num_items);
+    ptr += sd.serialize(ptr, bytes_remaining, items, num_items);
     for (i = 0; i < num_items; i++) items[i].~T();
     alloc.deallocate(items, num_items);
   }
@@ -284,6 +288,12 @@ private:
 
 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 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) {
   const auto preamble_longs = read<uint8_t>(is);
   const auto serial_version = read<uint8_t>(is);
   const auto family_id = read<uint8_t>(is);
@@ -312,7 +322,7 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
     read(is, weights.data(), sizeof(W) * num_items);
     A alloc(allocator);
     std::unique_ptr<T, items_deleter> items(alloc.allocate(num_items), items_deleter(num_items, false, alloc));
-    S().deserialize(is, items.get(), num_items);
+    sd.deserialize(is, items.get(), num_items);
     items.get_deleter().set_destroy(true); // serde did not throw, so the items must be constructed
     for (uint32_t i = 0; i < num_items; i++) {
       sketch.update(std::move(items.get()[i]), weights[i]);
@@ -327,6 +337,12 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
 
 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 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) {
   ensure_minimum_memory(size, 8);
   const char* ptr = static_cast<const char*>(bytes);
   const char* base = static_cast<const char*>(bytes);
@@ -370,7 +386,7 @@ frequent_items_sketch<T, W, H, E, S, A> frequent_items_sketch<T, W, H, E, S, A>:
     A alloc(allocator);
     std::unique_ptr<T, items_deleter> items(alloc.allocate(num_items), items_deleter(num_items, false, alloc));
     const size_t bytes_remaining = size - (ptr - base);
-    ptr += S().deserialize(ptr, bytes_remaining, items.get(), num_items);
+    ptr += sd.deserialize(ptr, bytes_remaining, items.get(), num_items);
     items.get_deleter().set_destroy(true); // serde did not throw, so the items must be constructed
     for (uint32_t i = 0; i < num_items; i++) {
       sketch.update(std::move(items.get()[i]), weights[i]);
@@ -421,7 +437,9 @@ 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 {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
+  // 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;
   os << "### Frequent items sketch summary:" << std::endl;
   os << "   lg cur map size  : " << (int) map.get_lg_cur_size() << std::endl;
   os << "   lg max map size  : " << (int) map.get_lg_max_size() << std::endl;
@@ -444,7 +462,7 @@ string<A> frequent_items_sketch<T, W, H, E, S, A>::to_string(bool print_items) c
     }
     os << "### End items" << std::endl;
   }
-  return os.str();
+  return string<A>(os.str().c_str(), map.get_allocator());
 }
 
 // version for integral signed type

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

@@ -19,6 +19,7 @@
 
 #include <catch.hpp>
 #include <sstream>
+#include <stdexcept>
 
 #include "frequent_items_sketch.hpp"
 #include "test_type.hpp"
@@ -59,7 +60,7 @@ TEST_CASE("frequent items: custom type", "[frequent_items_sketch]") {
   REQUIRE(sketch.get_maximum_error() == sketch2.get_maximum_error());
 
   auto bytes = sketch.serialize();
-  auto sketch3 = frequent_test_type_sketch::deserialize(bytes.data(), bytes.size(), 0);
+  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);

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

@@ -20,6 +20,7 @@
 #include <catch.hpp>
 #include <sstream>
 #include <fstream>
+#include <stdexcept>
 
 #include "frequent_items_sketch.hpp"