datasketches 0.2.1 → 0.2.2

data/vendor/datasketches-cpp/setup.py

@@ -79,7 +79,7 @@ class CMakeBuild(build_ext):
 
 setup(
     name='datasketches',
-    version='3.0.0',
+    version='3.1.0',
     author='Apache DataSketches Developers',
     author_email='dev@datasketches.apache.org',
     description='A wrapper for the C++ Apache DataSketches library',

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

@@ -90,7 +90,7 @@ public:
    * @param f the inclusion probability used to produce the set with size <i>a</i>.
    * @return the approximate lower bound
    */
-  static double estimate_of_a(uint64_t a, uint64_t f) {
+  static double estimate_of_a(uint64_t a, double f) {
     check_inputs(a, 1, f);
     return a / f;
   }

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

@@ -0,0 +1,67 @@
+/*
+ * 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 COMPACT_THETA_SKETCH_PARSER_HPP_
+#define COMPACT_THETA_SKETCH_PARSER_HPP_
+
+#include <stdint.h>
+
+namespace datasketches {
+
+template<bool dummy>
+class compact_theta_sketch_parser {
+public:
+  struct compact_theta_sketch_data {
+    bool is_empty;
+    bool is_ordered;
+    uint16_t seed_hash;
+    uint32_t num_entries;
+    uint64_t theta;
+    const uint64_t* entries;
+  };
+
+  static compact_theta_sketch_data parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error = false);
+
+private:
+  // offsets are in sizeof(type)
+  static const size_t COMPACT_SKETCH_PRE_LONGS_BYTE = 0;
+  static const size_t COMPACT_SKETCH_SERIAL_VERSION_BYTE = 1;
+  static const size_t COMPACT_SKETCH_TYPE_BYTE = 2;
+  static const size_t COMPACT_SKETCH_FLAGS_BYTE = 5;
+  static const size_t COMPACT_SKETCH_SEED_HASH_U16 = 3;
+  static const size_t COMPACT_SKETCH_NUM_ENTRIES_U32 = 2;
+  static const size_t COMPACT_SKETCH_SINGLE_ENTRY_U64 = 1;
+  static const size_t COMPACT_SKETCH_ENTRIES_EXACT_U64 = 2;
+  static const size_t COMPACT_SKETCH_THETA_U64 = 2;
+  static const size_t COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 = 3;
+
+  static const uint8_t COMPACT_SKETCH_IS_EMPTY_FLAG = 2;
+  static const uint8_t COMPACT_SKETCH_IS_ORDERED_FLAG = 4;
+
+  static const uint8_t COMPACT_SKETCH_SERIAL_VERSION = 3;
+  static const uint8_t COMPACT_SKETCH_TYPE = 3;
+
+  static std::string hex_dump(const uint8_t* ptr, size_t size);
+};
+
+} /* namespace datasketches */
+
+#include "compact_theta_sketch_parser_impl.hpp"
+
+#endif

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

@@ -0,0 +1,70 @@
+/*
+ * 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 COMPACT_THETA_SKETCH_PARSER_IMPL_HPP_
+#define COMPACT_THETA_SKETCH_PARSER_IMPL_HPP_
+
+#include <iostream>
+#include <iomanip>
+
+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)
+      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
+  checker<true>::check_serial_version(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE], COMPACT_SKETCH_SERIAL_VERSION);
+  checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+  uint64_t theta = theta_constants::MAX_THETA;
+  const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
+  checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+  if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_EMPTY_FLAG)) {
+    return {true, true, seed_hash, 0, theta, nullptr};
+  }
+  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));
+    theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
+  }
+  if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] == 1) {
+    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];
+  const size_t entries_start_u64 = has_theta ? COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 : COMPACT_SKETCH_ENTRIES_EXACT_U64;
+  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)
+        + (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);
+  return {false, is_ordered, seed_hash, num_entries, theta, entries};
+}
+
+template<bool dummy>
+std::string compact_theta_sketch_parser<dummy>::hex_dump(const uint8_t* ptr, size_t size) {
+  std::stringstream s;
+  s << std::hex << std::setfill('0') << std::uppercase;
+  for (size_t i = 0; i < size; ++i) s << std::setw(2) << (ptr[i] & 0xff);
+  return s.str();
+}
+
+} /* namespace datasketches */
+
+#endif

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

@@ -33,14 +33,19 @@ public:
   using Sketch = theta_sketch_alloc<Allocator>;
   using CompactSketch = compact_theta_sketch_alloc<Allocator>;
 
-  struct pass_through_policy {
-    uint64_t operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
+  struct nop_policy {
+    void operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
       unused(incoming_entry);
-      return internal_entry;
+      unused(internal_entry);
     }
   };
-  using State = theta_intersection_base<Entry, ExtractKey, pass_through_policy, Sketch, CompactSketch, Allocator>;
+  using State = theta_intersection_base<Entry, ExtractKey, nop_policy, Sketch, CompactSketch, Allocator>;
 
+  /*
+   * Constructor
+   * @param seed for the hash function that was used to create the sketch
+   * @param allocator to use for allocating and deallocating memory
+   */
   explicit theta_intersection_alloc(uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
 
   /**

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

@@ -24,7 +24,7 @@ namespace datasketches {
 
 template<typename A>
 theta_intersection_alloc<A>::theta_intersection_alloc(uint64_t seed, const A& allocator):
-state_(seed, pass_through_policy(), allocator)
+state_(seed, nop_policy(), allocator)
 {}
 
 template<typename A>

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

@@ -46,20 +46,21 @@ public:
    *
    * @param sketch_a given sketch A
    * @param sketch_b given sketch B
+   * @param seed for the hash function that was used to create the sketch
    * @return a double array {LowerBound, Estimate, UpperBound} of the Jaccard index.
    * The Upper and Lower bounds are for a confidence interval of 95.4% or +/- 2 standard deviations.
    */
   template<typename SketchA, typename SketchB>
-  static std::array<double, 3> jaccard(const SketchA& sketch_a, const SketchB& sketch_b) {
+  static std::array<double, 3> jaccard(const SketchA& sketch_a, const SketchB& sketch_b, uint64_t seed = DEFAULT_SEED) {
     if (reinterpret_cast<const void*>(&sketch_a) == reinterpret_cast<const void*>(&sketch_b)) return {1, 1, 1};
     if (sketch_a.is_empty() && sketch_b.is_empty()) return {1, 1, 1};
     if (sketch_a.is_empty() || sketch_b.is_empty()) return {0, 0, 0};
 
-    auto union_ab = compute_union(sketch_a, sketch_b);
+    auto union_ab = compute_union(sketch_a, sketch_b, seed);
     if (identical_sets(sketch_a, sketch_b, union_ab)) return {1, 1, 1};
 
     // intersection
-    Intersection i;
+    Intersection i(seed);
     i.update(sketch_a);
     i.update(sketch_b);
     i.update(union_ab); // ensures that intersection is a subset of the union
@@ -76,15 +77,16 @@ public:
    * Returns true if the two given sketches are equivalent.
    * @param sketch_a the given sketch A
    * @param sketch_b the given sketch B
+   * @param seed for the hash function that was used to create the sketch
    * @return true if the two given sketches are exactly equal
    */
   template<typename SketchA, typename SketchB>
-  static bool exactly_equal(const SketchA& sketch_a, const SketchB& sketch_b) {
+  static bool exactly_equal(const SketchA& sketch_a, const SketchB& sketch_b, uint64_t seed = DEFAULT_SEED) {
     if (reinterpret_cast<const void*>(&sketch_a) == reinterpret_cast<const void*>(&sketch_b)) return true;
     if (sketch_a.is_empty() && sketch_b.is_empty()) return true;
     if (sketch_a.is_empty() || sketch_b.is_empty()) return false;
 
-    auto union_ab = compute_union(sketch_a, sketch_b);
+    auto union_ab = compute_union(sketch_a, sketch_b, seed);
     if (identical_sets(sketch_a, sketch_b, union_ab)) return true;
     return false;
   }
@@ -99,12 +101,13 @@ public:
    * @param actual the sketch to be tested
    * @param expected the reference sketch that is considered to be correct
    * @param threshold a real value between zero and one
+   * @param seed for the hash function that was used to create the sketch
    * @return true if the similarity of the two sketches is greater than the given threshold
    * with at least 97.7% confidence
    */
   template<typename SketchA, typename SketchB>
-  static bool similarity_test(const SketchA& actual, const SketchB& expected, double threshold) {
-    auto jc = jaccard(actual, expected);
+  static bool similarity_test(const SketchA& actual, const SketchB& expected, double threshold, uint64_t seed = DEFAULT_SEED) {
+    auto jc = jaccard(actual, expected, seed);
     return jc[0] >= threshold;
   }
 
@@ -118,23 +121,24 @@ public:
    * @param actual the sketch to be tested
    * @param expected the reference sketch that is considered to be correct
    * @param threshold a real value between zero and one
+   * @param seed for the hash function that was used to create the sketch
    * @return true if the dissimilarity of the two sketches is greater than the given threshold
    * with at least 97.7% confidence
    */
   template<typename SketchA, typename SketchB>
-  static bool dissimilarity_test(const SketchA& actual, const SketchB& expected, double threshold) {
-    auto jc = jaccard(actual, expected);
+  static bool dissimilarity_test(const SketchA& actual, const SketchB& expected, double threshold, uint64_t seed = DEFAULT_SEED) {
+    auto jc = jaccard(actual, expected, seed);
     return jc[2] <= threshold;
   }
 
 private:
 
   template<typename SketchA, typename SketchB>
-  static typename Union::CompactSketch compute_union(const SketchA& sketch_a, const SketchB& sketch_b) {
-    const unsigned count_a = sketch_a.get_num_retained();
-    const unsigned count_b = sketch_b.get_num_retained();
-    const unsigned lg_k = std::min(std::max(log2(ceiling_power_of_2(count_a + count_b)), theta_constants::MIN_LG_K), theta_constants::MAX_LG_K);
-    auto u = typename Union::builder().set_lg_k(lg_k).build();
+  static typename Union::CompactSketch compute_union(const SketchA& sketch_a, const SketchB& sketch_b, uint64_t seed) {
+    const auto count_a = sketch_a.get_num_retained();
+    const auto count_b = sketch_b.get_num_retained();
+    const uint8_t lg_k = std::min(std::max(log2(ceiling_power_of_2(count_a + count_b)), theta_constants::MIN_LG_K), theta_constants::MAX_LG_K);
+    auto u = typename Union::builder().set_lg_k(lg_k).set_seed(seed).build();
     u.update(sketch_a);
     u.update(sketch_b);
     return u.get_result(false);

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

@@ -311,7 +311,8 @@ public:
   // - as a result of a set operation
   // - by deserializing a previously serialized compact sketch
 
-  compact_theta_sketch_alloc(const Base& other, bool ordered);
+  template<typename Other>
+  compact_theta_sketch_alloc(const Other& other, bool ordered);
   compact_theta_sketch_alloc(const compact_theta_sketch_alloc&) = default;
   compact_theta_sketch_alloc(compact_theta_sketch_alloc&&) noexcept = default;
   virtual ~compact_theta_sketch_alloc() = default;
@@ -387,10 +388,50 @@ public:
     update_theta_sketch_alloc build() const;
 };
 
+// This is to wrap a buffer containing a serialized compact sketch and use it in a set operation avoiding some cost of deserialization.
+// It does not take the ownership of the buffer.
+
+template<typename Allocator = std::allocator<uint64_t>>
+class wrapped_compact_theta_sketch_alloc {
+public:
+  using const_iterator = const uint64_t*;
+
+  Allocator get_allocator() const;
+  bool is_empty() const;
+  bool is_ordered() const;
+  uint64_t get_theta64() const;
+  uint32_t get_num_retained() const;
+  uint16_t get_seed_hash() const;
+
+  const_iterator begin() const;
+  const_iterator end() const;
+
+  /**
+   * This method wraps a serialized compact sketch as an array of bytes.
+   * @param bytes pointer to the array of bytes
+   * @param size the size of the array
+   * @param seed the seed for the hash function that was used to create the sketch
+   * @return an instance of the sketch
+   */
+  static const wrapped_compact_theta_sketch_alloc wrap(const void* bytes, size_t size, uint64_t seed = DEFAULT_SEED, bool dump_on_error = false);
+
+private:
+  bool is_empty_;
+  bool is_ordered_;
+  uint16_t seed_hash_;
+  uint32_t num_entries_;
+  uint64_t theta_;
+  const uint64_t* entries_;
+
+  wrapped_compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint32_t num_entries,
+      uint64_t theta, const uint64_t* entries);
+};
+
 // aliases with default allocator for convenience
 using theta_sketch = theta_sketch_alloc<std::allocator<uint64_t>>;
 using update_theta_sketch = update_theta_sketch_alloc<std::allocator<uint64_t>>;
 using compact_theta_sketch = compact_theta_sketch_alloc<std::allocator<uint64_t>>;
+using wrapped_compact_theta_sketch = wrapped_compact_theta_sketch_alloc<std::allocator<uint64_t>>;
 
 } /* namespace datasketches */
 

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

@@ -26,6 +26,7 @@
 #include "serde.hpp"
 #include "binomial_bounds.hpp"
 #include "theta_helpers.hpp"
+#include "compact_theta_sketch_parser.hpp"
 
 namespace datasketches {
 
@@ -246,7 +247,8 @@ update_theta_sketch_alloc<A> update_theta_sketch_alloc<A>::builder::build() cons
 // compact sketch
 
 template<typename A>
-compact_theta_sketch_alloc<A>::compact_theta_sketch_alloc(const Base& other, bool ordered):
+template<typename Other>
+compact_theta_sketch_alloc<A>::compact_theta_sketch_alloc(const Other& other, bool ordered):
 is_empty_(other.is_empty()),
 is_ordered_(other.is_ordered() || ordered),
 seed_hash_(other.get_seed_hash()),
@@ -290,7 +292,7 @@ uint64_t compact_theta_sketch_alloc<A>::get_theta64() const {
 
 template<typename A>
 uint32_t compact_theta_sketch_alloc<A>::get_num_retained() const {
-  return entries_.size();
+  return static_cast<uint32_t>(entries_.size());
 }
 
 template<typename A>
@@ -300,22 +302,22 @@ uint16_t compact_theta_sketch_alloc<A>::get_seed_hash() const {
 
 template<typename A>
 auto compact_theta_sketch_alloc<A>::begin() -> iterator {
-  return iterator(entries_.data(), entries_.size(), 0);
+  return iterator(entries_.data(), static_cast<uint32_t>(entries_.size()), 0);
 }
 
 template<typename A>
 auto compact_theta_sketch_alloc<A>::end() -> iterator {
-  return iterator(nullptr, 0, entries_.size());
+  return iterator(nullptr, 0, static_cast<uint32_t>(entries_.size()));
 }
 
 template<typename A>
 auto compact_theta_sketch_alloc<A>::begin() const -> const_iterator {
-  return const_iterator(entries_.data(), entries_.size(), 0);
+  return const_iterator(entries_.data(), static_cast<uint32_t>(entries_.size()), 0);
 }
 
 template<typename A>
 auto compact_theta_sketch_alloc<A>::end() const -> const_iterator {
-  return const_iterator(nullptr, 0, entries_.size());
+  return const_iterator(nullptr, 0, static_cast<uint32_t>(entries_.size()));
 }
 
 template<typename A>
@@ -325,33 +327,33 @@ template<typename A>
 void compact_theta_sketch_alloc<A>::serialize(std::ostream& os) const {
   const bool is_single_item = entries_.size() == 1 && !this->is_estimation_mode();
   const uint8_t preamble_longs = this->is_empty() || is_single_item ? 1 : this->is_estimation_mode() ? 3 : 2;
-  os.write(reinterpret_cast<const char*>(&preamble_longs), sizeof(preamble_longs));
+  write(os, preamble_longs);
   const uint8_t serial_version = SERIAL_VERSION;
-  os.write(reinterpret_cast<const char*>(&serial_version), sizeof(serial_version));
+  write(os, serial_version);
   const uint8_t type = SKETCH_TYPE;
-  os.write(reinterpret_cast<const char*>(&type), sizeof(type));
+  write(os, type);
   const uint16_t unused16 = 0;
-  os.write(reinterpret_cast<const char*>(&unused16), sizeof(unused16));
+  write(os, unused16);
   const uint8_t flags_byte(
     (1 << flags::IS_COMPACT) |
     (1 << flags::IS_READ_ONLY) |
     (this->is_empty() ? 1 << flags::IS_EMPTY : 0) |
     (this->is_ordered() ? 1 << flags::IS_ORDERED : 0)
   );
-  os.write(reinterpret_cast<const char*>(&flags_byte), sizeof(flags_byte));
+  write(os, flags_byte);
   const uint16_t seed_hash = get_seed_hash();
-  os.write(reinterpret_cast<const char*>(&seed_hash), sizeof(seed_hash));
+  write(os, seed_hash);
   if (!this->is_empty()) {
     if (!is_single_item) {
-      const uint32_t num_entries = entries_.size();
-      os.write(reinterpret_cast<const char*>(&num_entries), sizeof(num_entries));
+      const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
+      write(os, num_entries);
       const uint32_t unused32 = 0;
-      os.write(reinterpret_cast<const char*>(&unused32), sizeof(unused32));
+      write(os, unused32);
       if (this->is_estimation_mode()) {
-        os.write(reinterpret_cast<const char*>(&(this->theta_)), sizeof(uint64_t));
+        write(os, this->theta_);
       }
     }
-    os.write(reinterpret_cast<const char*>(entries_.data()), entries_.size() * sizeof(uint64_t));
+    write(os, entries_.data(), entries_.size() * sizeof(uint64_t));
   }
 }
 
@@ -364,30 +366,28 @@ auto compact_theta_sketch_alloc<A>::serialize(unsigned header_size_bytes) const
   vector_bytes bytes(size, 0, entries_.get_allocator());
   uint8_t* ptr = bytes.data() + header_size_bytes;
 
-  ptr += copy_to_mem(&preamble_longs, ptr, sizeof(preamble_longs));
+  ptr += copy_to_mem(preamble_longs, ptr);
   const uint8_t serial_version = SERIAL_VERSION;
-  ptr += copy_to_mem(&serial_version, ptr, sizeof(serial_version));
+  ptr += copy_to_mem(serial_version, ptr);
   const uint8_t type = SKETCH_TYPE;
-  ptr += copy_to_mem(&type, ptr, sizeof(type));
-  const uint16_t unused16 = 0;
-  ptr += copy_to_mem(&unused16, ptr, sizeof(unused16));
+  ptr += copy_to_mem(type, ptr);
+  ptr += sizeof(uint16_t); // unused
   const uint8_t flags_byte(
     (1 << flags::IS_COMPACT) |
     (1 << flags::IS_READ_ONLY) |
     (this->is_empty() ? 1 << flags::IS_EMPTY : 0) |
     (this->is_ordered() ? 1 << flags::IS_ORDERED : 0)
   );
-  ptr += copy_to_mem(&flags_byte, ptr, sizeof(flags_byte));
+  ptr += copy_to_mem(flags_byte, ptr);
   const uint16_t seed_hash = get_seed_hash();
-  ptr += copy_to_mem(&seed_hash, ptr, sizeof(seed_hash));
+  ptr += copy_to_mem(seed_hash, ptr);
   if (!this->is_empty()) {
     if (!is_single_item) {
-      const uint32_t num_entries = entries_.size();
-      ptr += copy_to_mem(&num_entries, ptr, sizeof(num_entries));
-      const uint32_t unused32 = 0;
-      ptr += copy_to_mem(&unused32, ptr, sizeof(unused32));
+      const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
+      ptr += copy_to_mem(num_entries, ptr);
+      ptr += sizeof(uint32_t);
       if (this->is_estimation_mode()) {
-        ptr += copy_to_mem(&theta_, ptr, sizeof(uint64_t));
+        ptr += copy_to_mem(theta_, ptr);
       }
     }
     ptr += copy_to_mem(entries_.data(), ptr, entries_.size() * sizeof(uint64_t));
@@ -397,18 +397,12 @@ auto compact_theta_sketch_alloc<A>::serialize(unsigned header_size_bytes) const
 
 template<typename A>
 compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::istream& is, uint64_t seed, const A& allocator) {
-  uint8_t preamble_longs;
-  is.read(reinterpret_cast<char*>(&preamble_longs), sizeof(preamble_longs));
-  uint8_t serial_version;
-  is.read(reinterpret_cast<char*>(&serial_version), sizeof(serial_version));
-  uint8_t type;
-  is.read(reinterpret_cast<char*>(&type), sizeof(type));
-  uint16_t unused16;
-  is.read(reinterpret_cast<char*>(&unused16), sizeof(unused16));
-  uint8_t flags_byte;
-  is.read(reinterpret_cast<char*>(&flags_byte), sizeof(flags_byte));
-  uint16_t seed_hash;
-  is.read(reinterpret_cast<char*>(&seed_hash), sizeof(seed_hash));
+  const auto preamble_longs = read<uint8_t>(is);
+  const auto serial_version = read<uint8_t>(is);
+  const auto type = read<uint8_t>(is);
+  read<uint16_t>(is); // unused
+  const auto flags_byte = read<uint8_t>(is);
+  const auto seed_hash = read<uint16_t>(is);
   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);
@@ -420,16 +414,15 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::is
     if (preamble_longs == 1) {
       num_entries = 1;
     } else {
-      is.read(reinterpret_cast<char*>(&num_entries), sizeof(num_entries));
-      uint32_t unused32;
-      is.read(reinterpret_cast<char*>(&unused32), sizeof(unused32));
+      num_entries = read<uint32_t>(is);
+      read<uint32_t>(is); // unused
       if (preamble_longs > 2) {
-        is.read(reinterpret_cast<char*>(&theta), sizeof(theta));
+        theta = read<uint64_t>(is);
       }
     }
   }
   std::vector<uint64_t, A> entries(num_entries, 0, allocator);
-  if (!is_empty) is.read(reinterpret_cast<char*>(entries.data()), sizeof(uint64_t) * entries.size());
+  if (!is_empty) read(is, entries.data(), sizeof(uint64_t) * entries.size());
 
   const bool is_ordered = flags_byte & (1 << flags::IS_ORDERED);
   if (!is.good()) throw std::runtime_error("error reading from std::istream");
@@ -442,17 +435,16 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(const v
   const char* ptr = static_cast<const char*>(bytes);
   const char* base = ptr;
   uint8_t preamble_longs;
-  ptr += copy_from_mem(ptr, &preamble_longs, sizeof(preamble_longs));
+  ptr += copy_from_mem(ptr, preamble_longs);
   uint8_t serial_version;
-  ptr += copy_from_mem(ptr, &serial_version, sizeof(serial_version));
+  ptr += copy_from_mem(ptr, serial_version);
   uint8_t type;
-  ptr += copy_from_mem(ptr, &type, sizeof(type));
-  uint16_t unused16;
-  ptr += copy_from_mem(ptr, &unused16, sizeof(unused16));
+  ptr += copy_from_mem(ptr, type);
+  ptr += sizeof(uint16_t); // unused
   uint8_t flags_byte;
-  ptr += copy_from_mem(ptr, &flags_byte, sizeof(flags_byte));
+  ptr += copy_from_mem(ptr, flags_byte);
   uint16_t seed_hash;
-  ptr += copy_from_mem(ptr, &seed_hash, sizeof(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);
@@ -465,12 +457,11 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(const v
       num_entries = 1;
     } else {
       ensure_minimum_memory(size, 8); // read the first prelong before this method
-      ptr += copy_from_mem(ptr, &num_entries, sizeof(num_entries));
-      uint32_t unused32;
-      ptr += copy_from_mem(ptr, &unused32, sizeof(unused32));
+      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, sizeof(theta));
+        ptr += copy_from_mem(ptr, theta);
       }
     }
   }
@@ -483,7 +474,65 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(const v
   return compact_theta_sketch_alloc(is_empty, is_ordered, seed_hash, theta, std::move(entries));
 }
 
+// wrapped compact sketch
+
+template<typename A>
+wrapped_compact_theta_sketch_alloc<A>::wrapped_compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint32_t num_entries,
+    uint64_t theta, const uint64_t* entries):
+is_empty_(is_empty),
+is_ordered_(is_ordered),
+seed_hash_(seed_hash),
+num_entries_(num_entries),
+theta_(theta),
+entries_(entries)
+{}
+
+template<typename A>
+const wrapped_compact_theta_sketch_alloc<A> wrapped_compact_theta_sketch_alloc<A>::wrap(const void* bytes, size_t size, uint64_t seed, bool dump_on_error) {
+  auto data = compact_theta_sketch_parser<true>::parse(bytes, size, seed, dump_on_error);
+  return wrapped_compact_theta_sketch_alloc(data.is_empty, data.is_ordered, data.seed_hash, data.num_entries, data.theta, data.entries);
+}
+
+template<typename A>
+A wrapped_compact_theta_sketch_alloc<A>::get_allocator() const {
+  return A();
+}
+
+template<typename A>
+bool wrapped_compact_theta_sketch_alloc<A>::is_empty() const {
+  return is_empty_;
+}
+
+template<typename A>
+bool wrapped_compact_theta_sketch_alloc<A>::is_ordered() const {
+  return is_ordered_;
+}
+
+template<typename A>
+uint64_t wrapped_compact_theta_sketch_alloc<A>::get_theta64() const {
+  return theta_;
+}
+
+template<typename A>
+uint32_t wrapped_compact_theta_sketch_alloc<A>::get_num_retained() const {
+  return static_cast<uint32_t>(num_entries_);
+}
+
+template<typename A>
+uint16_t wrapped_compact_theta_sketch_alloc<A>::get_seed_hash() const {
+  return seed_hash_;
+}
+
+template<typename A>
+auto wrapped_compact_theta_sketch_alloc<A>::begin() const -> const_iterator {
+  return entries_;
+}
+
+template<typename A>
+auto wrapped_compact_theta_sketch_alloc<A>::end() const -> const_iterator {
+  return entries_ + num_entries_;
+}
+
 } /* namespace datasketches */
 
 #endif
-