datasketches 0.2.4 → 0.2.5

data/vendor/datasketches-cpp/sampling/include/var_opt_sketch_impl.hpp

@@ -25,6 +25,7 @@
 #include <cmath>
 #include <random>
 #include <algorithm>
+#include <stdexcept>
 
 #include "var_opt_sketch.hpp"
 #include "serde.hpp"
@@ -311,8 +312,8 @@ var_opt_sketch<T,S,A>& var_opt_sketch<T,S,A>::operator=(var_opt_sketch&& other)
 
 // implementation for fixed-size arithmetic types (integral and floating point)
 template<typename T, typename S, typename A>
-template<typename TT, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type>
-size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes() const {
+template<typename TT, typename SerDe, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type>
+size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes(const SerDe&) const {
   if (is_empty()) { return PREAMBLE_LONGS_EMPTY << 3; }
   size_t num_bytes = (r_ == 0 ? PREAMBLE_LONGS_WARMUP : PREAMBLE_LONGS_FULL) << 3;
   num_bytes += h_ * sizeof(double);    // weights
@@ -325,8 +326,8 @@ size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes() const {
 
 // implementation for all other types
 template<typename T, typename S, typename A>
-template<typename TT, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type>
-size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes() const {
+template<typename TT, typename SerDe, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type>
+size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes(const SerDe& sd) const {
   if (is_empty()) { return PREAMBLE_LONGS_EMPTY << 3; }
   size_t num_bytes = (r_ == 0 ? PREAMBLE_LONGS_WARMUP : PREAMBLE_LONGS_FULL) << 3;
   num_bytes += h_ * sizeof(double);    // weights
@@ -335,13 +336,14 @@ size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes() const {
   }
   // must iterate over the items
   for (auto it: *this)
-    num_bytes += S().size_of_item(it.first);
+    num_bytes += sd.size_of_item(it.first);
   return num_bytes;
 }
 
 template<typename T, typename S, typename A>
-std::vector<uint8_t, AllocU8<A>> var_opt_sketch<T,S,A>::serialize(unsigned header_size_bytes) const {
-  const size_t size = header_size_bytes + get_serialized_size_bytes();
+template<typename SerDe>
+std::vector<uint8_t, AllocU8<A>> var_opt_sketch<T,S,A>::serialize(unsigned header_size_bytes, const SerDe& sd) const {
+  const size_t size = header_size_bytes + get_serialized_size_bytes(sd);
   std::vector<uint8_t, AllocU8<A>> bytes(size, 0, allocator_);
   uint8_t* ptr = bytes.data() + header_size_bytes;
   uint8_t* end_ptr = ptr + size;
@@ -400,8 +402,8 @@ std::vector<uint8_t, AllocU8<A>> var_opt_sketch<T,S,A>::serialize(unsigned heade
     }
 
     // write the sample items, skipping the gap. Either h_ or r_ may be 0
-    ptr += S().serialize(ptr, end_ptr - ptr, data_, h_);
-    ptr += S().serialize(ptr, end_ptr - ptr, &data_[h_ + 1], r_);
+    ptr += sd.serialize(ptr, end_ptr - ptr, data_, h_);
+    ptr += sd.serialize(ptr, end_ptr - ptr, &data_[h_ + 1], r_);
   }
   
   size_t bytes_written = ptr - bytes.data();
@@ -413,7 +415,8 @@ std::vector<uint8_t, AllocU8<A>> var_opt_sketch<T,S,A>::serialize(unsigned heade
 }
 
 template<typename T, typename S, typename A>
-void var_opt_sketch<T,S,A>::serialize(std::ostream& os) const {
+template<typename SerDe>
+void var_opt_sketch<T,S,A>::serialize(std::ostream& os, const SerDe& sd) const {
   const bool empty = (h_ == 0) && (r_ == 0);
 
   const uint8_t preLongs = (empty ? PREAMBLE_LONGS_EMPTY
@@ -469,13 +472,19 @@ void var_opt_sketch<T,S,A>::serialize(std::ostream& os) const {
     }
 
     // write the sample items, skipping the gap. Either h_ or r_ may be 0
-    S().serialize(os, data_, h_);
-    S().serialize(os, &data_[h_ + 1], r_);
+    sd.serialize(os, data_, h_);
+    sd.serialize(os, &data_[h_ + 1], r_);
   }
 }
 
 template<typename T, typename S, typename A>
 var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size_t size, const A& allocator) {
+  return deserialize(bytes, size, S(), allocator);
+}
+
+template<typename T, typename S, typename A>
+template<typename SerDe>
+var_opt_sketch<T,S,A> var_opt_sketch<T,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 = ptr;
@@ -559,10 +568,10 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size
   items_deleter deleter(array_size, allocator);
   std::unique_ptr<T, items_deleter> items(A(allocator).allocate(array_size), deleter);
   
-  ptr += S().deserialize(ptr, end_ptr - ptr, items.get(), h);
+  ptr += sd.deserialize(ptr, end_ptr - ptr, items.get(), h);
   items.get_deleter().set_h(h); // serde didn't throw, so the items are now valid
   
-  ptr += S().deserialize(ptr, end_ptr - ptr, &(items.get()[h + 1]), r);
+  ptr += sd.deserialize(ptr, end_ptr - ptr, &(items.get()[h + 1]), r);
   items.get_deleter().set_r(r); // serde didn't throw, so the items are now valid
 
   return var_opt_sketch(k, h, (r > 0 ? 1 : 0), r, n, total_wt_r, rf, array_size, false,
@@ -571,6 +580,12 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size
 
 template<typename T, typename S, typename A>
 var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(std::istream& is, const A& allocator) {
+  return deserialize(is, S(), allocator);
+}
+
+template<typename T, typename S, typename A>
+template<typename SerDe>
+var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(std::istream& is, const SerDe& sd, const A& allocator) {
   const auto first_byte = read<uint8_t>(is);
   uint8_t preamble_longs = first_byte & 0x3f;
   const resize_factor rf = static_cast<resize_factor>((first_byte >> 6) & 0x03);
@@ -640,10 +655,10 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(std::istream& is, const
   items_deleter deleter(array_size, allocator);
   std::unique_ptr<T, items_deleter> items(A(allocator).allocate(array_size), deleter);
 
-  S().deserialize(is, items.get(), h); // aka &data_[0]
+  sd.deserialize(is, items.get(), h); // aka &data_[0]
   items.get_deleter().set_h(h); // serde didn't throw, so the items are now valid
 
-  S().deserialize(is, &(items.get()[h + 1]), r);
+  sd.deserialize(is, &(items.get()[h + 1]), r);
   items.get_deleter().set_r(r); // serde didn't throw, so the items are now valid
 
   if (!is.good())
@@ -1683,16 +1698,6 @@ bool var_opt_sketch<T, S, A>::iterator::get_mark() const {
   return sk_->marks_ == nullptr ? false : sk_->marks_[idx_];
 }
 
-
-
-// ******************** MOVE TO COMMON UTILS AREA EVENTUALLY *********************
-
-namespace random_utils {
-  static std::random_device rd; // possibly unsafe in MinGW with GCC < 9.2
-  static std::mt19937_64 rand(rd());
-  static std::uniform_real_distribution<> next_double(0.0, 1.0);
-}
-
 /**
  * Checks if target sampling allocation is more than 50% of max sampling size.
  * If so, returns max sampling size, otherwise passes through target size.

data/vendor/datasketches-cpp/sampling/include/var_opt_union.hpp

@@ -45,7 +45,11 @@ template<typename A> using AllocU8 = typename std::allocator_traits<A>::template
  * author Kevin Lang 
  * author Jon Malkin
  */
-template <typename T, typename S = serde<T>, typename A = std::allocator<T>>
+template<
+  typename T,
+  typename S = serde<T>, // deprecated, to be removed in the next major version
+  typename A = std::allocator<T>
+>
 class var_opt_union {
 
 public:
@@ -88,14 +92,16 @@ public:
   /**
    * Computes size needed to serialize the current state of the union.
    * This version is for all other types and 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 is a convenience alias for users
   // The type returned by the following serialize method
   typedef vector_u8<A> vector_bytes;
-  
+
   /**
    * NOTE: This method may be deprecated in a future version.
    * This method serializes the sketch as a vector of bytes.
@@ -103,33 +109,62 @@ public:
    * 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
    */
-  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;
 
   /**
    * NOTE: This method may be deprecated in a future version.
    * 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;
 
   /**
    * NOTE: This method may be deprecated in a future version.
    * This method deserializes a union from a given stream.
    * @param is input stream
+   * @param instance of an Allocator
    * @return an instance of a union
    */
   static var_opt_union deserialize(std::istream& is, const A& allocator = A());
 
+  /**
+   * NOTE: This method may be deprecated in a future version.
+   * This method deserializes a union from a given stream.
+   * @param is input stream
+   * @param instance of a SerDe
+   * @param instance of an Allocator
+   * @return an instance of a union
+   */
+  template<typename SerDe = S>
+  static var_opt_union deserialize(std::istream& is, const SerDe& sd = SerDe(), const A& allocator = A());
+
   /**
    * NOTE: This method may be deprecated in a future version.
    * This method deserializes a union 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 a union
    */
   static var_opt_union deserialize(const void* bytes, size_t size, const A& allocator = A());
 
+  /**
+   * NOTE: This method may be deprecated in a future version.
+   * This method deserializes a union 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 a union
+   */
+  template<typename SerDe = S>
+  static var_opt_union deserialize(const void* bytes, size_t size, const SerDe& sd = SerDe(), const A& allocator = A());
+
   /**
    * Prints a summary of the union as a string.
    * @return the summary as a string

data/vendor/datasketches-cpp/sampling/include/var_opt_union_impl.hpp

@@ -24,6 +24,7 @@
 
 #include <cmath>
 #include <sstream>
+#include <stdexcept>
 
 namespace datasketches {
 
@@ -129,6 +130,12 @@ var_opt_union<T,S,A>& var_opt_union<T,S,A>::operator=(var_opt_union&& other) {
 
 template<typename T, typename S, typename A>
 var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A& allocator) {
+  return deserialize(is, S(), allocator);
+}
+
+template<typename T, typename S, typename A>
+template<typename SerDe>
+var_opt_union<T,S,A> var_opt_union<T,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);
@@ -155,7 +162,7 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A
   const auto outer_tau_numer = read<double>(is);
   const auto outer_tau_denom = read<uint64_t>(is);
 
-  var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(is, allocator);
+  var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(is, sd, allocator);
 
   if (!is.good())
     throw std::runtime_error("error reading from std::istream"); 
@@ -165,6 +172,12 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A
 
 template<typename T, typename S, typename A>
 var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(const void* bytes, size_t size, const A& allocator) {
+  return deserialize(bytes, size, S(), allocator);
+}
+
+template<typename T, typename S, typename A>
+template<typename SerDe>
+var_opt_union<T,S,A> var_opt_union<T,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);
   uint8_t preamble_longs;
@@ -199,22 +212,24 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(const void* bytes, size_t
   ptr += copy_from_mem(ptr, outer_tau_denom);
 
   const size_t gadget_size = size - (PREAMBLE_LONGS_NON_EMPTY << 3);
-  var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(ptr, gadget_size, allocator);
+  var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(ptr, gadget_size, sd, allocator);
 
   return var_opt_union<T,S,A>(items_seen, outer_tau_numer, outer_tau_denom, max_k, std::move(gadget));
 }
 
 template<typename T, typename S, typename A>
-size_t var_opt_union<T,S,A>::get_serialized_size_bytes() const {
+template<typename SerDe>
+size_t var_opt_union<T,S,A>::get_serialized_size_bytes(const SerDe& sd) const {
   if (n_ == 0) {
     return PREAMBLE_LONGS_EMPTY << 3;
   } else {
-    return (PREAMBLE_LONGS_NON_EMPTY << 3) + gadget_.get_serialized_size_bytes();
+    return (PREAMBLE_LONGS_NON_EMPTY << 3) + gadget_.get_serialized_size_bytes(sd);
   }
 }
 
 template<typename T, typename S, typename A>
-void var_opt_union<T,S,A>::serialize(std::ostream& os) const {
+template<typename SerDe>
+void var_opt_union<T,S,A>::serialize(std::ostream& os, const SerDe& sd) const {
   bool empty = (n_ == 0);
 
   const uint8_t serialization_version(SER_VER);
@@ -240,13 +255,14 @@ void var_opt_union<T,S,A>::serialize(std::ostream& os) const {
     write(os, n_);
     write(os, outer_tau_numer_);
     write(os, outer_tau_denom_);
-    gadget_.serialize(os);
+    gadget_.serialize(os, sd);
   }
 }
 
 template<typename T, typename S, typename A>
-std::vector<uint8_t, AllocU8<A>> var_opt_union<T,S,A>::serialize(unsigned header_size_bytes) const {
-  const size_t size = header_size_bytes + get_serialized_size_bytes();
+template<typename SerDe>
+std::vector<uint8_t, AllocU8<A>> var_opt_union<T,S,A>::serialize(unsigned header_size_bytes, const SerDe& sd) const {
+  const size_t size = header_size_bytes + get_serialized_size_bytes(sd);
   std::vector<uint8_t, AllocU8<A>> bytes(size, 0, gadget_.allocator_);
   uint8_t* ptr = bytes.data() + header_size_bytes;
 
@@ -278,7 +294,7 @@ std::vector<uint8_t, AllocU8<A>> var_opt_union<T,S,A>::serialize(unsigned header
     ptr += copy_to_mem(outer_tau_numer_, ptr);
     ptr += copy_to_mem(outer_tau_denom_, ptr);
 
-    auto gadget_bytes = gadget_.serialize();
+    auto gadget_bytes = gadget_.serialize(0, sd);
     ptr += copy_to_mem(gadget_bytes.data(), ptr, gadget_bytes.size() * sizeof(uint8_t));
   }
 

data/vendor/datasketches-cpp/sampling/test/var_opt_allocation_test.cpp

@@ -39,7 +39,7 @@ TEST_CASE("varopt allocation test", "[var_opt_sketch]") {
     var_opt_test_sketch sk1(10, var_opt_test_sketch::DEFAULT_RESIZE_FACTOR, 0);
     for (int i = 0; i < 100; ++i) sk1.update(i);
     auto bytes1 = sk1.serialize();
-    auto sk2 = var_opt_test_sketch::deserialize(bytes1.data(), bytes1.size(), 0);
+    auto sk2 = var_opt_test_sketch::deserialize(bytes1.data(), bytes1.size(), test_type_serde(), 0);
 
     std::stringstream ss;
     sk1.serialize(ss);
@@ -51,7 +51,7 @@ TEST_CASE("varopt allocation test", "[var_opt_sketch]") {
     u1.update(sk3);
 
     auto bytes2 = u1.serialize();
-    auto u2 = var_opt_test_union::deserialize(bytes2.data(), bytes2.size(), 0);
+    auto u2 = var_opt_test_union::deserialize(bytes2.data(), bytes2.size(), test_type_serde(), 0);
   }
   REQUIRE(test_allocator_total_bytes == 0);
   REQUIRE(test_allocator_net_allocations == 0);

data/vendor/datasketches-cpp/sampling/test/var_opt_sketch_test.cpp

@@ -27,6 +27,7 @@
 #include <fstream>
 #include <cmath>
 #include <random>
+#include <stdexcept>
 
 #ifdef TEST_BINARY_INPUT_PATH
 static std::string testBinaryInputPath = TEST_BINARY_INPUT_PATH;

data/vendor/datasketches-cpp/sampling/test/var_opt_union_test.cpp

@@ -27,6 +27,7 @@
 #include <fstream>
 #include <cmath>
 #include <random>
+#include <stdexcept>
 
 #ifdef TEST_BINARY_INPUT_PATH
 static std::string testBinaryInputPath = TEST_BINARY_INPUT_PATH;

data/vendor/datasketches-cpp/setup.py

@@ -81,7 +81,7 @@ class CMakeBuild(build_ext):
 
 setup(
     name='datasketches',
-    version='3.3.0',
+    version='3.4.0',
     author='Apache Software Foundation',
     author_email='dev@datasketches.apache.org',
     description='The Apache DataSketches Library for Python',

data/vendor/datasketches-cpp/theta/include/bounds_on_ratios_in_sampled_sets.hpp

@@ -22,6 +22,7 @@
 
 #include <cstdint>
 #include <string>
+#include <stdexcept>
 
 #include "bounds_binomial_proportions.hpp"
 

data/vendor/datasketches-cpp/theta/include/compact_theta_sketch_parser_impl.hpp

@@ -22,12 +22,13 @@
 
 #include <iostream>
 #include <iomanip>
+#include <stdexcept>
 
 namespace datasketches {
 
 template<bool dummy>
 auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error) -> compact_theta_sketch_data {
-  if (size < 8) throw std::invalid_argument("at least 8 bytes expected, actual " + std::to_string(size)
+  if (size < 8) throw std::out_of_range("at least 8 bytes expected, actual " + std::to_string(size)
       + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
 
   uint8_t serial_version = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE];
@@ -43,10 +44,11 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
       checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
       const bool has_theta = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] > 2;
       if (has_theta) {
-        if (size < 16) throw std::invalid_argument("at least 16 bytes expected, actual " + std::to_string(size));
+        if (size < 16) throw std::out_of_range("at least 16 bytes expected, actual " + std::to_string(size));
         theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
       }
       if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] == 1) {
+        if (size < 16) throw std::out_of_range("at least 16 bytes expected, actual " + std::to_string(size));
         return {false, true, seed_hash, 1, theta, reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_SINGLE_ENTRY_U64};
       }
       const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
@@ -54,7 +56,7 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
       const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + entries_start_u64;
       const size_t expected_size_bytes = (entries_start_u64 + num_entries) * sizeof(uint64_t);
       if (size < expected_size_bytes) {
-        throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+        throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
             + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
       }
       const bool is_ordered = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_ORDERED_FLAG);
@@ -72,7 +74,7 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
       const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
       const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
       if (size < expected_size_bytes) {
-        throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+        throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
             + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
       }
       return {false, true, seed_hash, num_entries, theta, entries};
@@ -91,7 +93,7 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
           } else {
               const size_t expected_size_bytes = (preamble_size + num_entries) << 3;
               if (size < expected_size_bytes) {
-                  throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+                  throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
                       + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
               }
               const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_EXACT_U64;
@@ -107,7 +109,7 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
           const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
           const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
           if (size < expected_size_bytes) {
-            throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+            throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
                 + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
           }
           return {false, true, seed_hash, num_entries, theta, entries};

data/vendor/datasketches-cpp/theta/include/theta_intersection_base_impl.hpp

@@ -20,6 +20,7 @@
 #include <iostream>
 #include <sstream>
 #include <algorithm>
+#include <stdexcept>
 
 #include "conditional_forward.hpp"
 

data/vendor/datasketches-cpp/theta/include/theta_set_difference_base_impl.hpp

@@ -21,6 +21,7 @@
 #define THETA_A_SET_DIFFERENCE_BASE_IMPL_HPP_
 
 #include <algorithm>
+#include <stdexcept>
 
 #include "conditional_back_inserter.hpp"
 #include "conditional_forward.hpp"

data/vendor/datasketches-cpp/theta/include/theta_sketch_impl.hpp

@@ -22,6 +22,7 @@
 
 #include <sstream>
 #include <vector>
+#include <stdexcept>
 
 #include "serde.hpp"
 #include "binomial_bounds.hpp"
@@ -453,7 +454,7 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::is
       const auto num_entries = read<uint32_t>(is);
       read<uint32_t>(is); //unused
       const auto theta = read<uint64_t>(is);
-      std::vector<uint64_t> entries(num_entries, 0, allocator);
+      std::vector<uint64_t, A> entries(num_entries, 0, allocator);
       bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
       if (!is_empty)
           read(is, entries.data(), sizeof(uint64_t) * entries.size());
@@ -470,12 +471,12 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::is
       if (preamble_longs == 1) {
           if (!is.good())
               throw std::runtime_error("error reading from std::istream");
-          std::vector<uint64_t> entries(0, 0, allocator);
+          std::vector<uint64_t, A> entries(0, 0, allocator);
           return compact_theta_sketch_alloc(true, true, seed_hash, theta_constants::MAX_THETA, std::move(entries));
       } else if (preamble_longs == 2) {
           const uint32_t num_entries = read<uint32_t>(is);
           read<uint32_t>(is); // unused
-          std::vector<uint64_t> entries(num_entries, 0, allocator);
+          std::vector<uint64_t, A> entries(num_entries, 0, allocator);
           if (num_entries == 0) {
               return compact_theta_sketch_alloc(true, true, seed_hash, theta_constants::MAX_THETA, std::move(entries));
           }
@@ -488,7 +489,7 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::is
           read<uint32_t>(is); // unused
           const auto theta = read<uint64_t>(is);
           bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
-          std::vector<uint64_t> entries(num_entries, 0, allocator);
+          std::vector<uint64_t, A> entries(num_entries, 0, allocator);
           if (is_empty) {
               if (!is.good())
                   throw std::runtime_error("error reading from std::istream");
@@ -514,47 +515,8 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::is
 
 template<typename A>
 compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(const void* bytes, size_t size, uint64_t seed, const A& allocator) {
-  ensure_minimum_memory(size, 8);
-  const char* ptr = static_cast<const char*>(bytes);
-  const char* base = ptr;
-  uint8_t preamble_longs;
-  ptr += copy_from_mem(ptr, preamble_longs);
-  uint8_t serial_version;
-  ptr += copy_from_mem(ptr, serial_version);
-  uint8_t type;
-  ptr += copy_from_mem(ptr, type);
-  ptr += sizeof(uint16_t); // unused
-  uint8_t flags_byte;
-  ptr += copy_from_mem(ptr, flags_byte);
-  uint16_t seed_hash;
-  ptr += copy_from_mem(ptr, seed_hash);
-  checker<true>::check_sketch_type(type, SKETCH_TYPE);
-  checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
-  const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
-  if (!is_empty) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
-
-  uint64_t theta = theta_constants::MAX_THETA;
-  uint32_t num_entries = 0;
-  if (!is_empty) {
-    if (preamble_longs == 1) {
-      num_entries = 1;
-    } else {
-      ensure_minimum_memory(size, 8); // read the first prelong before this method
-      ptr += copy_from_mem(ptr, num_entries);
-      ptr += sizeof(uint32_t); // unused
-      if (preamble_longs > 2) {
-        ensure_minimum_memory(size, (preamble_longs - 1) << 3);
-        ptr += copy_from_mem(ptr, theta);
-      }
-    }
-  }
-  const size_t entries_size_bytes = sizeof(uint64_t) * num_entries;
-  check_memory_size(ptr - base + entries_size_bytes, size);
-  std::vector<uint64_t, A> entries(num_entries, 0, allocator);
-  if (!is_empty) ptr += copy_from_mem(ptr, entries.data(), entries_size_bytes);
-
-  const bool is_ordered = flags_byte & (1 << flags::IS_ORDERED);
-  return compact_theta_sketch_alloc(is_empty, is_ordered, seed_hash, theta, std::move(entries));
+  auto data = compact_theta_sketch_parser<true>::parse(bytes, size, seed, false);
+  return compact_theta_sketch_alloc(data.is_empty, data.is_ordered, data.seed_hash, data.theta, std::vector<uint64_t, A>(data.entries, data.entries + data.num_entries, allocator));
 }
 
 // wrapped compact sketch

data/vendor/datasketches-cpp/theta/include/theta_union_base_impl.hpp

@@ -21,6 +21,7 @@
 #define THETA_UNION_BASE_IMPL_HPP_
 
 #include <algorithm>
+#include <stdexcept>
 
 #include "conditional_forward.hpp"
 

data/vendor/datasketches-cpp/theta/include/theta_update_sketch_base_impl.hpp

@@ -23,6 +23,7 @@
 #include <iostream>
 #include <sstream>
 #include <algorithm>
+#include <stdexcept>
 
 #include "theta_helpers.hpp"
 

data/vendor/datasketches-cpp/theta/test/theta_a_not_b_test.cpp

@@ -21,6 +21,8 @@
 
 #include <theta_a_not_b.hpp>
 
+#include <stdexcept>
+
 namespace datasketches {
 
 TEST_CASE("theta a-not-b: empty", "[theta_a_not_b]") {

data/vendor/datasketches-cpp/theta/test/theta_intersection_test.cpp

@@ -21,6 +21,8 @@
 
 #include <theta_intersection.hpp>
 
+#include <stdexcept>
+
 namespace datasketches {
 
 TEST_CASE("theta intersection: invalid", "[theta_intersection]") {

data/vendor/datasketches-cpp/theta/test/theta_setop_test.cpp

@@ -18,6 +18,7 @@
  */
 
 #include <sstream>
+#include <stdexcept>
 
 #include <catch.hpp>
 #include <theta_union.hpp>