datasketches 0.3.1 → 0.4.0

data/vendor/datasketches-cpp/quantiles/include/quantiles_sketch.hpp

@@ -27,9 +27,20 @@
 #include "quantiles_sorted_view.hpp"
 #include "common_defs.hpp"
 #include "serde.hpp"
+#include "optional.hpp"
 
 namespace datasketches {
 
+/// Constants for Quantiles sketch
+namespace quantiles_constants {
+  /// default value of parameter K
+  const uint16_t DEFAULT_K = 128;
+  /// minimum value of parameter K
+  const uint16_t MIN_K = 2;
+  /// maximum value of parameter K
+  const uint16_t MAX_K = 1 << 15;
+}
+
 /**
  * This is a stochastic streaming sketch that enables near-real time analysis of the
  * approximate distribution from a very large stream in a single pass.
@@ -136,13 +147,6 @@ Table Guide for DoublesSketch Size in Bytes and Approximate Error:
  * @author Alexander Saydakov
  * @author Jon Malkin
  */
-
-namespace quantiles_constants {
-  const uint16_t DEFAULT_K = 128;
-  const uint16_t MIN_K = 2;
-  const uint16_t MAX_K = 1 << 15;
-}
-
 template <typename T,
           typename Comparator = std::less<T>, // strict weak ordering function (see C++ named requirements: Compare)
           typename Allocator = std::allocator<T>>
@@ -151,13 +155,43 @@ public:
   using value_type = T;
   using allocator_type = Allocator;
   using comparator = Comparator;
+  using quantile_return_type = typename quantiles_sorted_view<T, Comparator, Allocator>::quantile_return_type;
+  using vector_double = typename quantiles_sorted_view<T, Comparator, Allocator>::vector_double;
 
+  /**
+   * Constructor
+   * @param k affects the size of the sketch and its estimation error
+   * @param comparator strict weak ordering function (see C++ named requirements: Compare)
+   * @param allocator used to allocate memory
+   */
   explicit quantiles_sketch(uint16_t k = quantiles_constants::DEFAULT_K,
       const Comparator& comparator = Comparator(), const Allocator& allocator = Allocator());
+
+  /**
+   * Copy constructor
+   * @param other sketch to be copied
+   */
   quantiles_sketch(const quantiles_sketch& other);
+
+  /** Move constructor
+   * @param other sketch to be moved
+   */
   quantiles_sketch(quantiles_sketch&& other) noexcept;
+
   ~quantiles_sketch();
+
+  /**
+   * Copy assignment
+   * @param other sketch to be copied
+   * @return reference to this sketch
+   */
   quantiles_sketch& operator=(const quantiles_sketch& other);
+
+  /**
+   * Move assignment
+   * @param other sketch to be moved
+   * @return reference to this sketch
+   */
   quantiles_sketch& operator=(quantiles_sketch&& other) noexcept;
 
   /**
@@ -247,48 +281,13 @@ public:
    * If the sketch is empty this throws std::runtime_error.
    *
    * @param rank the specified normalized rank in the hypothetical sorted stream.
-   *
+   * @param inclusive if true the weight of the given item is included into the rank.
+   * Otherwise the rank equals the sum of the weights of all items that are less than the given item
+   * according to the Comparator.
    * @return the approximation to the item at the given rank
    */
-  using quantile_return_type = typename quantiles_sorted_view<T, Comparator, Allocator>::quantile_return_type;
   quantile_return_type get_quantile(double rank, bool inclusive = true) const;
 
-  /**
-   * This is a multiple-query version of get_quantile().
-   * <p>
-   * This returns an array that could have been generated by using get_quantile() for each
-   * normalized rank separately.
-   *
-   * <p>If the sketch is empty this throws std::runtime_error.
-   *
-   * @param ranks given array of normalized ranks in the hypothetical sorted stream.
-   * These ranks must be in the interval [0.0, 1.0], inclusive.
-   * @param size the number of ranks in the array
-   *
-   * @return array of approximations to items associated with given ranks in the same order as given ranks
-   * in the input array.
-   *
-   * Deprecated. Will be removed in the next major version. Use get_quantile() instead.
-   */
-  std::vector<T, Allocator> get_quantiles(const double* ranks, uint32_t size, bool inclusive = true) const;
-
-  /**
-   * This is a multiple-query version of get_quantile() that allows the caller to
-   * specify the number of evenly-spaced normalized ranks.
-   *
-   * <p>If the sketch is empty this throws std::runtime_error.
-   *
-   * @param num an integer that specifies the number of evenly-spaced ranks.
-   * This must be an integer greater than 0. A value of 1 is equivalent to get_quantiles([0]).
-   * A value of 2 is equivalent to get_quantiles([0, 1]). A value of 3 is equivalent to
-   * get_quantiles([0, 0.5, 1]), etc.
-   *
-   * @return array of approximations to items associated with the given number of evenly-spaced normalized ranks.
-   *
-   * Deprecated. Will be removed in the next major version. Use get_quantile() instead.
-   */
-  std::vector<T, Allocator> get_quantiles(uint32_t num, bool inclusive = true) const;
-
   /**
    * Returns an approximation to the normalized rank of the given item from 0 to 1, inclusive.
    *
@@ -300,7 +299,7 @@ public:
    * @param item to be ranked
    * @param inclusive if true the weight of the given item is included into the rank.
    * Otherwise the rank equals the sum of the weights of all items that are less than the given item
-   * according to the comparator C.
+   * according to the Comparator.
    * @return an approximate normalized rank of the given item
    */
   double get_rank(const T& item, bool inclusive = true) const;
@@ -327,7 +326,6 @@ public:
    * @return an array of m+1 doubles each of which is an approximation
    * to the fraction of the input stream items (the mass) that fall into one of those intervals.
    */
-  using vector_double = typename quantiles_sorted_view<T, Comparator, Allocator>::vector_double;
   vector_double get_PMF(const T* split_points, uint32_t size, bool inclusive = true) const;
 
   /**
@@ -451,9 +449,26 @@ public:
   string<Allocator> to_string(bool print_levels = false, bool print_items = false) const;
 
   class const_iterator;
+
+  /**
+   * Iterator pointing to the first item in the sketch.
+   * If the sketch is empty, the returned iterator must not be dereferenced or incremented.
+   * @return iterator pointing to the first item in the sketch
+   */
   const_iterator begin() const;
+
+  /**
+   * Iterator pointing to the past-the-end item in the sketch.
+   * The past-the-end item is the hypothetical item that would follow the last item.
+   * It does not point to any item, and must not be dereferenced or incremented.
+   * @return iterator pointing to the past-the-end item in the sketch
+   */
   const_iterator end() const;
 
+  /**
+   * Gets the sorted view of this sketch
+   * @return the sorted view of this sketch
+   */
   quantiles_sorted_view<T, Comparator, Allocator> get_sorted_view() const;
 
 private:
@@ -493,19 +508,18 @@ private:
   uint64_t bit_pattern_;
   Level base_buffer_;
   VectorLevels levels_;
-  T* min_item_;
-  T* max_item_;
+  optional<T> min_item_;
+  optional<T> max_item_;
   mutable quantiles_sorted_view<T, Comparator, Allocator>* sorted_view_;
 
   void setup_sorted_view() const; // modifies mutable state
   void reset_sorted_view();
 
   // for deserialization
-  class item_deleter;
   class items_deleter;
   quantiles_sketch(uint16_t k, uint64_t n, uint64_t bit_pattern,
       Level&& base_buffer, VectorLevels&& levels,
-      std::unique_ptr<T, item_deleter> min_item, std::unique_ptr<T, item_deleter> max_item,
+      optional<T>&& min_item, optional<T>&& max_item,
       bool is_sorted, const Comparator& comparator = Comparator(), const Allocator& allocator = Allocator());
 
   void grow_base_buffer();
@@ -576,19 +590,27 @@ private:
   static inline bool check_update_item(TT) {
     return true;
   }
+
+  // for type converting constructor
+  template<typename From, typename FC, typename FA> friend class quantiles_sketch;
 };
 
 
 template<typename T, typename C, typename A>
-class quantiles_sketch<T, C, A>::const_iterator: public std::iterator<std::input_iterator_tag, T> {
+class quantiles_sketch<T, C, A>::const_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
   using value_type = std::pair<const T&, const uint64_t>;
+  using difference_type = void;
+  using pointer = const return_value_holder<value_type>;
+  using reference = const value_type;
+
   const_iterator& operator++();
   const_iterator& operator++(int);
   bool operator==(const const_iterator& other) const;
   bool operator!=(const const_iterator& other) const;
-  const value_type operator*() const;
-  const return_value_holder<value_type> operator->() const;
+  reference operator*() const;
+  pointer operator->() const;
 private:
   friend class quantiles_sketch<T, C, A>;
   using Level = std::vector<T, A>;

data/vendor/datasketches-cpp/quantiles/include/quantiles_sketch_impl.hpp

@@ -41,8 +41,8 @@ n_(0),
 bit_pattern_(0),
 base_buffer_(allocator_),
 levels_(allocator_),
-min_item_(nullptr),
-max_item_(nullptr),
+min_item_(),
+max_item_(),
 sorted_view_(nullptr)
 {
   check_k(k_);
@@ -59,12 +59,10 @@ n_(other.n_),
 bit_pattern_(other.bit_pattern_),
 base_buffer_(other.base_buffer_),
 levels_(other.levels_),
-min_item_(nullptr),
-max_item_(nullptr),
+min_item_(other.min_item_),
+max_item_(other.max_item_),
 sorted_view_(nullptr)
 {
-  if (other.min_item_ != nullptr) min_item_ = new (allocator_.allocate(1)) T(*other.min_item_);
-  if (other.max_item_ != nullptr) max_item_ = new (allocator_.allocate(1)) T(*other.max_item_);
   for (size_t i = 0; i < levels_.size(); ++i) { 
     if (levels_[i].capacity() != other.levels_[i].capacity()) {
       levels_[i].reserve(other.levels_[i].capacity());
@@ -82,13 +80,10 @@ n_(other.n_),
 bit_pattern_(other.bit_pattern_),
 base_buffer_(std::move(other.base_buffer_)),
 levels_(std::move(other.levels_)),
-min_item_(other.min_item_),
-max_item_(other.max_item_),
+min_item_(std::move(other.min_item_)),
+max_item_(std::move(other.max_item_)),
 sorted_view_(nullptr)
-{
-  other.min_item_ = nullptr;
-  other.max_item_ = nullptr;
-}
+{}
 
 template<typename T, typename C, typename A>
 quantiles_sketch<T, C, A>& quantiles_sketch<T, C, A>::operator=(const quantiles_sketch& other) {
@@ -126,7 +121,7 @@ quantiles_sketch<T, C, A>& quantiles_sketch<T, C, A>::operator=(quantiles_sketch
 template<typename T, typename C, typename A>
 quantiles_sketch<T, C, A>::quantiles_sketch(uint16_t k, uint64_t n, uint64_t bit_pattern,
       Level&& base_buffer, VectorLevels&& levels,
-      std::unique_ptr<T, item_deleter> min_item, std::unique_ptr<T, item_deleter> max_item,
+      optional<T>&& min_item, optional<T>&& max_item,
       bool is_sorted, const C& comparator, const A& allocator):
 comparator_(comparator),
 allocator_(allocator),
@@ -136,13 +131,13 @@ n_(n),
 bit_pattern_(bit_pattern),
 base_buffer_(std::move(base_buffer)),
 levels_(std::move(levels)),
-min_item_(min_item.release()),
-max_item_(max_item.release()),
+min_item_(std::move(min_item)),
+max_item_(std::move(max_item)),
 sorted_view_(nullptr)
 {
-  uint32_t item_count = base_buffer_.size();
+  uint32_t item_count = static_cast<uint32_t>(base_buffer_.size());
   for (Level& lvl : levels_) {
-    item_count += lvl.size();
+    item_count += static_cast<uint32_t>(lvl.size());
   }
   if (item_count != compute_retained_items(k_, n_))
     throw std::logic_error("Item count does not match value computed from k, n");
@@ -160,8 +155,8 @@ n_(other.get_n()),
 bit_pattern_(compute_bit_pattern(other.get_k(), other.get_n())),
 base_buffer_(allocator),
 levels_(allocator),
-min_item_(nullptr),
-max_item_(nullptr),
+min_item_(other.min_item_),
+max_item_(other.max_item_),
 sorted_view_(nullptr)
 {
   static_assert(std::is_constructible<T, From>::value,
@@ -170,9 +165,6 @@ sorted_view_(nullptr)
   base_buffer_.reserve(2 * std::min(quantiles_constants::MIN_K, k_));
 
   if (!other.is_empty()) {
-    min_item_ = new (allocator_.allocate(1)) T(other.get_min_item());
-    max_item_ = new (allocator_.allocate(1)) T(other.get_max_item());
-
     // reserve space in levels
     const uint8_t num_levels = compute_levels_needed(k_, n_);
     levels_.reserve(num_levels);
@@ -212,14 +204,6 @@ sorted_view_(nullptr)
 
 template<typename T, typename C, typename A>
 quantiles_sketch<T, C, A>::~quantiles_sketch() {
-  if (min_item_ != nullptr) {
-    min_item_->~T();
-    allocator_.deallocate(min_item_, 1);
-  }
-  if (max_item_ != nullptr) {
-    max_item_->~T();
-    allocator_.deallocate(max_item_, 1);
-  }
   reset_sorted_view();
 }
 
@@ -228,8 +212,8 @@ template<typename FwdT>
 void quantiles_sketch<T, C, A>::update(FwdT&& item) {
   if (!check_update_item(item)) { return; }
   if (is_empty()) {
-    min_item_ = new (allocator_.allocate(1)) T(item);
-    max_item_ = new (allocator_.allocate(1)) T(item);
+    min_item_.emplace(item);
+    max_item_.emplace(item);
   } else {
     if (comparator_(item, *min_item_)) *min_item_ = item;
     if (comparator_(*max_item_, item)) *max_item_ = item;
@@ -263,17 +247,17 @@ void quantiles_sketch<T, C, A>::merge(FwdSk&& other) {
   // other has data and is in estimation mode
   if (is_estimation_mode()) {
     if (k_ == other.get_k()) {
-      standard_merge(*this, other);
+      standard_merge(*this, std::forward<FwdSk>(other));
     } else if (k_ > other.get_k()) {
-      quantiles_sketch sk_copy(other);
-      downsampling_merge(sk_copy, *this);
-      *this = sk_copy;
+      quantiles_sketch sk_copy(std::forward<FwdSk>(other));
+      downsampling_merge(sk_copy, std::move(*this));
+      *this = std::move(sk_copy);
     } else { // k_ < other.get_k()
-      downsampling_merge(*this, other);
+      downsampling_merge(*this, std::forward<FwdSk>(other));
     }
   } else {
     // exact or empty
-    quantiles_sketch sk_copy(other);
+    quantiles_sketch sk_copy(std::forward<FwdSk>(other));
     if (k_ <= other.get_k()) {
       if (!is_empty()) {
         for (uint16_t i = 0; i < base_buffer_.size(); ++i) {
@@ -281,9 +265,9 @@ void quantiles_sketch<T, C, A>::merge(FwdSk&& other) {
         }
       }
     } else { // k_ > other.get_k()
-      downsampling_merge(sk_copy, *this);
+      downsampling_merge(sk_copy, std::move(*this));
     }
-    *this = sk_copy;
+    *this = std::move(sk_copy);
   }
   reset_sorted_view();
 }
@@ -317,8 +301,8 @@ void quantiles_sketch<T, C, A>::serialize(std::ostream& os, const SerDe& serde)
     write(os, n_);
 
     // min and max
-    serde.serialize(os, min_item_, 1);
-    serde.serialize(os, max_item_, 1);
+    serde.serialize(os, &*min_item_, 1);
+    serde.serialize(os, &*max_item_, 1);
 
     // base buffer items
     serde.serialize(os, base_buffer_.data(), static_cast<unsigned>(base_buffer_.size()));
@@ -365,8 +349,8 @@ auto quantiles_sketch<T, C, A>::serialize(unsigned header_size_bytes, const SerD
     ptr += copy_to_mem(n_, ptr);
     
     // min and max
-    ptr += serde.serialize(ptr, end_ptr - ptr, min_item_, 1);
-    ptr += serde.serialize(ptr, end_ptr - ptr, max_item_, 1);
+    ptr += serde.serialize(ptr, end_ptr - ptr, &*min_item_, 1);
+    ptr += serde.serialize(ptr, end_ptr - ptr, &*max_item_, 1);
  
     // base buffer items
     if (base_buffer_.size() > 0)
@@ -409,19 +393,18 @@ auto quantiles_sketch<T, C, A>::deserialize(std::istream &is, const SerDe& serde
   const bool is_compact = (serial_version == 2) | ((flags_byte & (1 << flags::IS_COMPACT)) > 0);
   const bool is_sorted = (flags_byte & (1 << flags::IS_SORTED)) > 0;
 
-  A alloc(allocator);
-  auto item_buffer_deleter = [&alloc](T* ptr) { alloc.deallocate(ptr, 1); };
-  std::unique_ptr<T, decltype(item_buffer_deleter)> min_item_buffer(alloc.allocate(1), item_buffer_deleter);
-  std::unique_ptr<T, decltype(item_buffer_deleter)> max_item_buffer(alloc.allocate(1), item_buffer_deleter);
-  std::unique_ptr<T, item_deleter> min_item(nullptr, item_deleter(allocator));
-  std::unique_ptr<T, item_deleter> max_item(nullptr, item_deleter(allocator));
-
-  serde.deserialize(is, min_item_buffer.get(), 1);
-  // serde call did not throw, repackage with destrtuctor
-  min_item = std::unique_ptr<T, item_deleter>(min_item_buffer.release(), item_deleter(allocator));
-  serde.deserialize(is, max_item_buffer.get(), 1);
-  // serde call did not throw, repackage with destrtuctor
-  max_item = std::unique_ptr<T, item_deleter>(max_item_buffer.release(), item_deleter(allocator));
+  optional<T> tmp; // space to deserialize min and max
+  optional<T> min_item;
+  optional<T> max_item;
+
+  serde.deserialize(is, &*tmp, 1);
+  // serde call did not throw, repackage and cleanup
+  min_item.emplace(*tmp);
+  (*tmp).~T();
+  serde.deserialize(is, &*tmp, 1);
+  // serde call did not throw, repackage and cleanup
+  max_item.emplace(*tmp);
+  (*tmp).~T();
 
   if (serial_version == 1) {
     read<uint64_t>(is); // no longer used
@@ -477,7 +460,7 @@ auto quantiles_sketch<T, C, A>::deserialize_array(std::istream& is, uint32_t num
   items.get_deleter().set_destroy(true);
   if (!is.good()) throw std::runtime_error("error reading from std::istream");
 
-  // succesfully read, now put into a Level
+  // successfully read, now put into a Level
   Level level(allocator);
   level.reserve(capacity);
   level.insert(level.begin(),
@@ -524,19 +507,18 @@ auto quantiles_sketch<T, C, A>::deserialize(const void* bytes, size_t size, cons
   const bool is_compact = (serial_version == 2) | ((flags_byte & (1 << flags::IS_COMPACT)) > 0);
   const bool is_sorted = (flags_byte & (1 << flags::IS_SORTED)) > 0;
 
-  A alloc(allocator);
-  auto item_buffer_deleter = [&alloc](T* ptr) { alloc.deallocate(ptr, 1); };
-  std::unique_ptr<T, decltype(item_buffer_deleter)> min_item_buffer(alloc.allocate(1), item_buffer_deleter);
-  std::unique_ptr<T, decltype(item_buffer_deleter)> max_item_buffer(alloc.allocate(1), item_buffer_deleter);
-  std::unique_ptr<T, item_deleter> min_item(nullptr, item_deleter(allocator));
-  std::unique_ptr<T, item_deleter> max_item(nullptr, item_deleter(allocator));
-
-  ptr += serde.deserialize(ptr, end_ptr - ptr, min_item_buffer.get(), 1);
-  // serde call did not throw, repackage with destrtuctor
-  min_item = std::unique_ptr<T, item_deleter>(min_item_buffer.release(), item_deleter(allocator));
-  ptr += serde.deserialize(ptr, end_ptr - ptr, max_item_buffer.get(), 1);
-  // serde call did not throw, repackage with destrtuctor
-  max_item = std::unique_ptr<T, item_deleter>(max_item_buffer.release(), item_deleter(allocator));
+  optional<T> tmp; // space to deserialize min and max
+  optional<T> min_item;
+  optional<T> max_item;
+
+  ptr += serde.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+  // serde call did not throw, repackage and cleanup
+  min_item.emplace(*tmp);
+  (*tmp).~T();
+  ptr += serde.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+  // serde call did not throw, repackage and cleanup
+  max_item.emplace(*tmp);
+  (*tmp).~T();
 
   if (serial_version == 1) {
     uint64_t unused_long;
@@ -645,12 +627,12 @@ string<A> quantiles_sketch<T, C, A>::to_string(bool print_levels, bool print_ite
     uint8_t level = 0;
     os << " BB:" << std::endl;
     for (const T& item : base_buffer_) {
-      os << "    " << std::to_string(item) << std::endl;
+      os << "    " << item << std::endl;
     }
     for (uint8_t i = 0; i < levels_.size(); ++i) {
       os << " level " << static_cast<unsigned int>(level) << ":" << std::endl;
       for (const T& item : levels_[i]) {
-        os << "   " << std::to_string(item) << std::endl;
+        os << "   " << item << std::endl;
       }
     }
     os << "### End sketch data" << std::endl;
@@ -769,42 +751,6 @@ auto quantiles_sketch<T, C, A>::get_quantile(double rank, bool inclusive) const
   return sorted_view_->get_quantile(rank, inclusive);
 }
 
-template<typename T, typename C, typename A>
-std::vector<T, A> quantiles_sketch<T, C, A>::get_quantiles(const double* ranks, uint32_t size, bool inclusive) const {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
-  std::vector<T, A> quantiles(allocator_);
-  quantiles.reserve(size);
-
-  // possible side-effect: sorting base buffer
-  setup_sorted_view();
-
-  for (uint32_t i = 0; i < size; ++i) {
-    const double rank = ranks[i];
-    if ((rank < 0.0) || (rank > 1.0)) {
-      throw std::invalid_argument("Normalized rank cannot be less than 0 or greater than 1");
-    }
-    quantiles.push_back(sorted_view_->get_quantile(rank, inclusive));
-  }
-  return quantiles;
-}
-
-template<typename T, typename C, typename A>
-std::vector<T, A> quantiles_sketch<T, C, A>::get_quantiles(uint32_t num, bool inclusive) const {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
-  if (num == 0) {
-    throw std::invalid_argument("num must be > 0");
-  }
-  vector_double ranks(num, 0, allocator_);
-  ranks[0] = 0.0;
-  for (size_t i = 1; i < num; i++) {
-    ranks[i] = static_cast<double>(i) / (num - 1);
-  }
-  if (num > 1) {
-    ranks[num - 1] = 1.0;
-  }
-  return get_quantiles(ranks.data(), num, inclusive);
-}
-
 template<typename T, typename C, typename A>
 double quantiles_sketch<T, C, A>::get_rank(const T& item, bool inclusive) const {
   if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
@@ -1012,7 +958,7 @@ void quantiles_sketch<T, C, A>::zip_buffer(Level& buf_in, Level& buf_out) {
   uint32_t rand_offset = next_offset;
   next_offset = 1 - next_offset;
 #else
-  uint32_t rand_offset = random_bit();
+  uint32_t rand_offset = random_utils::random_bit();
 #endif
   if ((buf_in.size() != 2 * buf_out.capacity())
     || (buf_out.size() > 0)) {
@@ -1127,15 +1073,14 @@ void quantiles_sketch<T, C, A>::standard_merge(quantiles_sketch& tgt, FwdSk&& sr
   // update min and max items
   // can't just check is_empty() since min and max might not have been set if
   // there were no base buffer items added via update()
-  if (tgt.min_item_ == nullptr) {
-    tgt.min_item_ = new (tgt.allocator_.allocate(1)) T(*src.min_item_);
+  if (!tgt.min_item_) {
+    tgt.min_item_.emplace(conditional_forward<FwdSk>(*src.min_item_));
   } else {
     if (tgt.comparator_(*src.min_item_, *tgt.min_item_))
       *tgt.min_item_ = conditional_forward<FwdSk>(*src.min_item_);
   }
-
-  if (tgt.max_item_ == nullptr) {
-    tgt.max_item_ = new (tgt.allocator_.allocate(1)) T(*src.max_item_);
+  if (!tgt.max_item_) {
+    tgt.max_item_.emplace(conditional_forward<FwdSk>(*src.max_item_));
   } else {
     if (tgt.comparator_(*tgt.max_item_, *src.max_item_))
       *tgt.max_item_ = conditional_forward<FwdSk>(*src.max_item_);
@@ -1203,15 +1148,14 @@ void quantiles_sketch<T, C, A>::downsampling_merge(quantiles_sketch& tgt, FwdSk&
   // update min and max items
   // can't just check is_empty() since min and max might not have been set if
   // there were no base buffer items added via update()
-  if (tgt.min_item_ == nullptr) {
-    tgt.min_item_ = new (tgt.allocator_.allocate(1)) T(*src.min_item_);
+  if (!tgt.min_item_) {
+    tgt.min_item_.emplace(conditional_forward<FwdSk>(*src.min_item_));
   } else {
     if (tgt.comparator_(*src.min_item_, *tgt.min_item_))
       *tgt.min_item_ = conditional_forward<FwdSk>(*src.min_item_);
   }
-
-  if (tgt.max_item_ == nullptr) {
-    tgt.max_item_ = new (tgt.allocator_.allocate(1)) T(*src.max_item_);
+  if (!tgt.max_item_) {
+    tgt.max_item_.emplace(conditional_forward<FwdSk>(*src.max_item_));
   } else {
     if (tgt.comparator_(*tgt.max_item_, *src.max_item_))
       *tgt.max_item_ = conditional_forward<FwdSk>(*src.max_item_);
@@ -1230,20 +1174,6 @@ uint8_t quantiles_sketch<T, C, A>::lowest_zero_bit_starting_at(uint64_t bits, ui
   return pos;
 }
 
-template<typename T, typename C, typename A>
-class quantiles_sketch<T, C, A>::item_deleter {
-  public:
-  item_deleter(const A& allocator): allocator_(allocator) {}
-  void operator() (T* ptr) {
-    if (ptr != nullptr) {
-      ptr->~T();
-      allocator_.deallocate(ptr, 1);
-    }
-  }
-  private:
-  A allocator_;
-};
-
 template<typename T, typename C, typename A>
 class quantiles_sketch<T, C, A>::items_deleter {
   public:
@@ -1354,12 +1284,12 @@ bool quantiles_sketch<T, C, A>::const_iterator::operator!=(const const_iterator&
 }
 
 template<typename T, typename C, typename A>
-auto quantiles_sketch<T, C, A>::const_iterator::operator*() const -> const value_type {
+auto quantiles_sketch<T, C, A>::const_iterator::operator*() const -> reference {
   return value_type(level_ == -1 ? base_buffer_[index_] : levels_[level_][index_], weight_);
 }
 
 template<typename T, typename C, typename A>
-auto quantiles_sketch<T, C, A>::const_iterator::operator->() const -> const return_value_holder<value_type> {
+auto quantiles_sketch<T, C, A>::const_iterator::operator->() const -> pointer {
   return **this;
 }
 

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

@@ -20,7 +20,6 @@ add_executable(quantiles_test)
 target_link_libraries(quantiles_test quantiles common common_test_lib)
 
 set_target_properties(quantiles_test PROPERTIES
-  CXX_STANDARD 11
   CXX_STANDARD_REQUIRED YES
 )
 
@@ -42,3 +41,17 @@ target_sources(quantiles_test
     quantiles_compatibility_test.cpp
     kolmogorov_smirnov_test.cpp
 )
+
+if (SERDE_COMPAT)
+target_sources(quantiles_test
+  PRIVATE
+    quantiles_sketch_deserialize_from_java_test.cpp
+)
+endif()
+
+if (GENERATE)
+target_sources(quantiles_test
+  PRIVATE
+    quantiles_sketch_serialize_for_java.cpp
+)
+endif()