datasketches 0.2.0 → 0.2.4

data/vendor/datasketches-cpp/hll/include/HllArray.hpp

@@ -31,7 +31,7 @@ class AuxHashMap;
 template<typename A>
 class HllArray : public HllSketchImpl<A> {
   public:
-    HllArray(int lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator);
+    HllArray(uint8_t lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator);
 
     static HllArray* newHll(const void* bytes, size_t len, const A& allocator);
     static HllArray* newHll(std::istream& is, const A& allocator);
@@ -45,25 +45,25 @@ class HllArray : public HllSketchImpl<A> {
     virtual HllArray* copy() const = 0;
     virtual HllArray* copyAs(target_hll_type tgtHllType) const;
 
-    virtual HllSketchImpl<A>* couponUpdate(int coupon) = 0;
+    virtual HllSketchImpl<A>* couponUpdate(uint32_t coupon) = 0;
 
     virtual double getEstimate() const;
     virtual double getCompositeEstimate() const;
-    virtual double getLowerBound(int numStdDev) const;
-    virtual double getUpperBound(int numStdDev) const;
+    virtual double getLowerBound(uint8_t numStdDev) const;
+    virtual double getUpperBound(uint8_t numStdDev) const;
 
     inline void addToHipAccum(double delta);
 
     inline void decNumAtCurMin();
 
-    inline int getCurMin() const;
-    inline int getNumAtCurMin() const;
+    inline uint8_t getCurMin() const;
+    inline uint32_t getNumAtCurMin() const;
     inline double getHipAccum() const;
 
-    virtual int getHllByteArrBytes() const = 0;
+    virtual uint32_t getHllByteArrBytes() const = 0;
 
-    virtual int getUpdatableSerializationBytes() const;
-    virtual int getCompactSerializationBytes() const;
+    virtual uint32_t getUpdatableSerializationBytes() const;
+    virtual uint32_t getCompactSerializationBytes() const;
 
     virtual bool isOutOfOrderFlag() const;
     virtual bool isEmpty() const;
@@ -74,19 +74,19 @@ class HllArray : public HllSketchImpl<A> {
     inline double getKxQ0() const;
     inline double getKxQ1() const;
 
-    virtual int getMemDataStart() const;
-    virtual int getPreInts() const;
+    virtual uint32_t getMemDataStart() const;
+    virtual uint8_t getPreInts() const;
 
-    void putCurMin(int curMin);
+    void putCurMin(uint8_t curMin);
     void putHipAccum(double hipAccum);
     inline void putKxQ0(double kxq0);
     inline void putKxQ1(double kxq1);
-    void putNumAtCurMin(int numAtCurMin);
+    void putNumAtCurMin(uint32_t numAtCurMin);
 
-    static int hllArrBytes(target_hll_type tgtHllType, int lgConfigK);
-    static int hll4ArrBytes(int lgConfigK);
-    static int hll6ArrBytes(int lgConfigK);
-    static int hll8ArrBytes(int lgConfigK);
+    static uint32_t hllArrBytes(target_hll_type tgtHllType, uint8_t lgConfigK);
+    static uint32_t hll4ArrBytes(uint8_t lgConfigK);
+    static uint32_t hll6ArrBytes(uint8_t lgConfigK);
+    static uint32_t hll8ArrBytes(uint8_t lgConfigK);
 
     virtual AuxHashMap<A>* getAuxHashMap() const;
 
@@ -98,16 +98,16 @@ class HllArray : public HllSketchImpl<A> {
 
   protected:
     void hipAndKxQIncrementalUpdate(uint8_t oldValue, uint8_t newValue);
-    double getHllBitMapEstimate(int lgConfigK, int curMin, int numAtCurMin) const;
-    double getHllRawEstimate(int lgConfigK, double kxqSum) const;
+    double getHllBitMapEstimate() const;
+    double getHllRawEstimate() const;
 
-    double hipAccum;
-    double kxq0;
-    double kxq1;
-    vector_u8<A> hllByteArr; //init by sub-classes
-    int curMin; //always zero for Hll6 and Hll8, only tracked by Hll4Array
-    int numAtCurMin; //interpreted as num zeros when curMin == 0
-    bool oooFlag; //Out-Of-Order Flag
+    double hipAccum_;
+    double kxq0_;
+    double kxq1_;
+    vector_u8<A> hllByteArr_; //init by sub-classes
+    uint8_t curMin_; //always zero for Hll6 and Hll8, only tracked by Hll4Array
+    uint32_t numAtCurMin_; //interpreted as num zeros when curMin == 0
+    bool oooFlag_; //Out-Of-Order Flag
 
     friend class HllSketchImplFactory<A>;
 };
@@ -115,20 +115,20 @@ class HllArray : public HllSketchImpl<A> {
 template<typename A>
 class HllArray<A>::const_iterator: public std::iterator<std::input_iterator_tag, uint32_t> {
 public:
-  const_iterator(const uint8_t* array, size_t array_slze, size_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset, bool all);
+  const_iterator(const uint8_t* array, uint32_t array_slze, uint32_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset, bool all);
   const_iterator& operator++();
   bool operator!=(const const_iterator& other) const;
   uint32_t operator*() const;
 private:
-  const uint8_t* array;
-  size_t array_size;
-  size_t index;
-  target_hll_type hll_type;
-  const AuxHashMap<A>* exceptions;
-  uint8_t offset;
-  bool all;
-  uint8_t value; // cached value to avoid computing in operator++ and in operator*()
-  static inline uint8_t get_value(const uint8_t* array, size_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset);
+  const uint8_t* array_;
+  uint32_t array_size_;
+  uint32_t index_;
+  target_hll_type hll_type_;
+  const AuxHashMap<A>* exceptions_;
+  uint8_t offset_;
+  bool all_;
+  uint8_t value_; // cached value to avoid computing in operator++ and in operator*()
+  static inline uint8_t get_value(const uint8_t* array, uint32_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset);
 };
 
 }

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

@@ -42,7 +42,7 @@ typedef union {
 } longDoubleUnion;
 
 template<typename A>
-hll_sketch_alloc<A>::hll_sketch_alloc(int lg_config_k, target_hll_type tgt_type, bool start_full_size, const A& allocator) {
+hll_sketch_alloc<A>::hll_sketch_alloc(uint8_t lg_config_k, target_hll_type tgt_type, bool start_full_size, const A& allocator) {
   HllUtil<A>::checkLgK(lg_config_k);
   if (start_full_size) {
     sketch_impl = HllSketchImplFactory<A>::newHll(lg_config_k, tgt_type, start_full_size, allocator);
@@ -122,7 +122,7 @@ void hll_sketch_alloc<A>::update(const std::string& datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint64_t datum) {
+void hll_sketch_alloc<A>::update(uint64_t datum) {
   // no sign extension with 64 bits so no need to cast to signed value
   HashState hashResult;
   HllUtil<A>::hash(&datum, sizeof(uint64_t), DEFAULT_SEED, hashResult);
@@ -130,53 +130,53 @@ void hll_sketch_alloc<A>::update(const uint64_t datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint32_t datum) {
+void hll_sketch_alloc<A>::update(uint32_t datum) {
   update(static_cast<int32_t>(datum));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint16_t datum) {
+void hll_sketch_alloc<A>::update(uint16_t datum) {
   update(static_cast<int16_t>(datum));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint8_t datum) {
+void hll_sketch_alloc<A>::update(uint8_t datum) {
   update(static_cast<int8_t>(datum));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int64_t datum) {
+void hll_sketch_alloc<A>::update(int64_t datum) {
   HashState hashResult;
   HllUtil<A>::hash(&datum, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int32_t datum) {
-  int64_t val = static_cast<int64_t>(datum);
+void hll_sketch_alloc<A>::update(int32_t datum) {
+  const int64_t val = static_cast<int64_t>(datum);
   HashState hashResult;
   HllUtil<A>::hash(&val, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int16_t datum) {
-  int64_t val = static_cast<int64_t>(datum);
+void hll_sketch_alloc<A>::update(int16_t datum) {
+  const int64_t val = static_cast<int64_t>(datum);
   HashState hashResult;
   HllUtil<A>::hash(&val, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int8_t datum) {
-  int64_t val = static_cast<int64_t>(datum);
+void hll_sketch_alloc<A>::update(int8_t datum) {
+  const int64_t val = static_cast<int64_t>(datum);
   HashState hashResult;
   HllUtil<A>::hash(&val, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const double datum) {
+void hll_sketch_alloc<A>::update(double datum) {
   longDoubleUnion d;
   d.doubleBytes = static_cast<double>(datum);
   if (datum == 0.0) {
@@ -190,7 +190,7 @@ void hll_sketch_alloc<A>::update(const double datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const float datum) {
+void hll_sketch_alloc<A>::update(float datum) {
   longDoubleUnion d;
   d.doubleBytes = static_cast<double>(datum);
   if (datum == 0.0) {
@@ -204,7 +204,7 @@ void hll_sketch_alloc<A>::update(const float datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const void* data, const size_t lengthBytes) {
+void hll_sketch_alloc<A>::update(const void* data, size_t lengthBytes) {
   if (data == nullptr) { return; }
   HashState hashResult;
   HllUtil<A>::hash(data, lengthBytes, DEFAULT_SEED, hashResult);
@@ -212,8 +212,8 @@ void hll_sketch_alloc<A>::update(const void* data, const size_t lengthBytes) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::coupon_update(int coupon) {
-  if (coupon == HllUtil<A>::EMPTY) { return; }
+void hll_sketch_alloc<A>::coupon_update(uint32_t coupon) {
+  if (coupon == hll_constants::EMPTY) { return; }
   HllSketchImpl<A>* result = this->sketch_impl->couponUpdate(coupon);
   if (result != this->sketch_impl) {
     this->sketch_impl->get_deleter()(this->sketch_impl);
@@ -246,10 +246,12 @@ string<A> hll_sketch_alloc<A>::to_string(const bool summary,
                                          const bool detail,
                                          const bool aux_detail,
                                          const bool all) 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::stringstream os;
   if (summary) {
     os << "### HLL sketch summary:" << std::endl
-       << "  Log Config K   : " << get_lg_config_k() << std::endl
+       << "  Log Config K   : " << std::to_string(get_lg_config_k()) << std::endl
        << "  Hll Target     : " << type_as_string() << std::endl
        << "  Current Mode   : " << mode_as_string() << std::endl
        << "  LB             : " << get_lower_bound(1) << std::endl
@@ -258,7 +260,7 @@ string<A> hll_sketch_alloc<A>::to_string(const bool summary,
        << "  OutOfOrder flag: " << (is_out_of_order_flag() ? "true" : "false") << std::endl;
     if (get_current_mode() == HLL) {
       HllArray<A>* hllArray = (HllArray<A>*) sketch_impl;
-      os << "  CurMin         : " << hllArray->getCurMin() << std::endl
+      os << "  CurMin         : " << std::to_string(hllArray->getCurMin()) << std::endl
          << "  NumAtCurMin    : " << hllArray->getNumAtCurMin() << std::endl
          << "  HipAccum       : " << hllArray->getHipAccum() << std::endl
          << "  KxQ0           : " << hllArray->getKxQ0() << std::endl
@@ -338,7 +340,7 @@ string<A> hll_sketch_alloc<A>::to_string(const bool summary,
     }
   }
 
-  return os.str();
+  return string<A>(os.str().c_str(), sketch_impl->getAllocator());
 }
 
 template<typename A>
@@ -352,12 +354,12 @@ double hll_sketch_alloc<A>::get_composite_estimate() const {
 }
 
 template<typename A>
-double hll_sketch_alloc<A>::get_lower_bound(int numStdDev) const {
+double hll_sketch_alloc<A>::get_lower_bound(uint8_t numStdDev) const {
   return sketch_impl->getLowerBound(numStdDev);
 }
 
 template<typename A>
-double hll_sketch_alloc<A>::get_upper_bound(int numStdDev) const {
+double hll_sketch_alloc<A>::get_upper_bound(uint8_t numStdDev) const {
   return sketch_impl->getUpperBound(numStdDev);
 }
 
@@ -367,7 +369,7 @@ hll_mode hll_sketch_alloc<A>::get_current_mode() const {
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_lg_config_k() const {
+uint8_t hll_sketch_alloc<A>::get_lg_config_k() const {
   return sketch_impl->getLgConfigK();
 }
 
@@ -387,12 +389,12 @@ bool hll_sketch_alloc<A>::is_estimation_mode() const {
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_updatable_serialization_bytes() const {
+uint32_t hll_sketch_alloc<A>::get_updatable_serialization_bytes() const {
   return sketch_impl->getUpdatableSerializationBytes();
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_compact_serialization_bytes() const {
+uint32_t hll_sketch_alloc<A>::get_compact_serialization_bytes() const {
   return sketch_impl->getCompactSerializationBytes();
 }
 
@@ -435,23 +437,23 @@ std::string hll_sketch_alloc<A>::mode_as_string() const {
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_max_updatable_serialization_bytes(const int lg_config_k,
+uint32_t hll_sketch_alloc<A>::get_max_updatable_serialization_bytes(uint8_t lg_config_k,
     const target_hll_type tgtHllType) {
-  int arrBytes;
+  uint32_t arrBytes;
   if (tgtHllType == target_hll_type::HLL_4) {
-    const int auxBytes = 4 << HllUtil<A>::LG_AUX_ARR_INTS[lg_config_k];
+    const uint32_t auxBytes = 4 << hll_constants::LG_AUX_ARR_INTS[lg_config_k];
     arrBytes = HllArray<A>::hll4ArrBytes(lg_config_k) + auxBytes;
   } else if (tgtHllType == target_hll_type::HLL_6) {
     arrBytes = HllArray<A>::hll6ArrBytes(lg_config_k);
   } else { //HLL_8
     arrBytes = HllArray<A>::hll8ArrBytes(lg_config_k);
   }
-  return HllUtil<A>::HLL_BYTE_ARR_START + arrBytes;
+  return hll_constants::HLL_BYTE_ARR_START + arrBytes;
 }
 
 template<typename A>
-double hll_sketch_alloc<A>::get_rel_err(const bool upperBound, const bool unioned,
-                           const int lg_config_k, const int numStdDev) {
+double hll_sketch_alloc<A>::get_rel_err(bool upperBound, bool unioned,
+                           uint8_t lg_config_k, uint8_t numStdDev) {
   return HllUtil<A>::getRelErr(upperBound, unioned, lg_config_k, numStdDev);
 }
 

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

@@ -26,12 +26,12 @@
 namespace datasketches {
 
 template<typename A>
-HllSketchImpl<A>::HllSketchImpl(const int lgConfigK, const target_hll_type tgtHllType,
-                                const hll_mode mode, const bool startFullSize)
-  : lgConfigK(lgConfigK),
-    tgtHllType(tgtHllType),
-    mode(mode),
-    startFullSize(startFullSize)
+HllSketchImpl<A>::HllSketchImpl(uint8_t lgConfigK, target_hll_type tgtHllType,
+                                hll_mode mode, bool startFullSize)
+  : lgConfigK_(lgConfigK),
+    tgtHllType_(tgtHllType),
+    mode_(mode),
+    startFullSize_(startFullSize)
 {
 }
 
@@ -40,7 +40,7 @@ HllSketchImpl<A>::~HllSketchImpl() {
 }
 
 template<typename A>
-target_hll_type HllSketchImpl<A>::extractTgtHllType(const uint8_t modeByte) {
+target_hll_type HllSketchImpl<A>::extractTgtHllType(uint8_t modeByte) {
   switch ((modeByte >> 2) & 0x3) {
   case 0:
     return target_hll_type::HLL_4;
@@ -54,7 +54,7 @@ target_hll_type HllSketchImpl<A>::extractTgtHllType(const uint8_t modeByte) {
 }
 
 template<typename A>
-hll_mode HllSketchImpl<A>::extractCurMode(const uint8_t modeByte) {
+hll_mode HllSketchImpl<A>::extractCurMode(uint8_t modeByte) {
   switch (modeByte & 0x3) {
   case 0:
     return hll_mode::LIST;
@@ -68,12 +68,12 @@ hll_mode HllSketchImpl<A>::extractCurMode(const uint8_t modeByte) {
 }
 
 template<typename A>
-uint8_t HllSketchImpl<A>::makeFlagsByte(const bool compact) const {
-  uint8_t flags(0);
-  flags |= (isEmpty() ? HllUtil<A>::EMPTY_FLAG_MASK : 0);
-  flags |= (compact ? HllUtil<A>::COMPACT_FLAG_MASK : 0);
-  flags |= (isOutOfOrderFlag() ? HllUtil<A>::OUT_OF_ORDER_FLAG_MASK : 0);
-  flags |= (startFullSize ? HllUtil<A>::FULL_SIZE_FLAG_MASK : 0);
+uint8_t HllSketchImpl<A>::makeFlagsByte(bool compact) const {
+  uint8_t flags = 0;
+  flags |= (isEmpty() ? hll_constants::EMPTY_FLAG_MASK : 0);
+  flags |= (compact ? hll_constants::COMPACT_FLAG_MASK : 0);
+  flags |= (isOutOfOrderFlag() ? hll_constants::OUT_OF_ORDER_FLAG_MASK : 0);
+  flags |= (startFullSize_ ? hll_constants::FULL_SIZE_FLAG_MASK : 0);
   return flags;
 }
 
@@ -92,7 +92,7 @@ template<typename A>
 uint8_t HllSketchImpl<A>::makeModeByte() const {
   uint8_t byte = 0;
 
-  switch (mode) {
+  switch (mode_) {
   case LIST:
     byte = 0;
     break;
@@ -104,7 +104,7 @@ uint8_t HllSketchImpl<A>::makeModeByte() const {
     break;
   }
 
-  switch (tgtHllType) {
+  switch (tgtHllType_) {
   case HLL_4:
     byte |= (0 << 2);  // for completeness
     break;
@@ -121,27 +121,27 @@ uint8_t HllSketchImpl<A>::makeModeByte() const {
 
 template<typename A>
 HllSketchImpl<A>* HllSketchImpl<A>::reset() {
-  return HllSketchImplFactory<A>::reset(this, startFullSize);
+  return HllSketchImplFactory<A>::reset(this, startFullSize_);
 }
 
 template<typename A>
 target_hll_type HllSketchImpl<A>::getTgtHllType() const {
-  return tgtHllType;
+  return tgtHllType_;
 }
 
 template<typename A>
-int HllSketchImpl<A>::getLgConfigK() const {
-  return lgConfigK;
+uint8_t HllSketchImpl<A>::getLgConfigK() const {
+  return lgConfigK_;
 }
 
 template<typename A>
 hll_mode HllSketchImpl<A>::getCurMode() const {
-  return mode;
+  return mode_;
 }
 
 template<typename A>
 bool HllSketchImpl<A>::isStartFullSize() const {
-  return startFullSize;
+  return startFullSize_;
 }
 
 }

data/vendor/datasketches-cpp/hll/include/HllSketchImpl.hpp

@@ -30,7 +30,7 @@ namespace datasketches {
 template<typename A>
 class HllSketchImpl {
   public:
-    HllSketchImpl(int lgConfigK, target_hll_type tgtHllType, hll_mode mode, bool startFullSize);
+    HllSketchImpl(uint8_t lgConfigK, target_hll_type tgtHllType, hll_mode mode, bool startFullSize);
     virtual ~HllSketchImpl();
 
     virtual void serialize(std::ostream& os, bool compact) const = 0;
@@ -42,25 +42,25 @@ class HllSketchImpl {
 
     virtual std::function<void(HllSketchImpl<A>*)> get_deleter() const = 0;
 
-    virtual HllSketchImpl* couponUpdate(int coupon) = 0;
+    virtual HllSketchImpl* couponUpdate(uint32_t coupon) = 0;
 
     hll_mode getCurMode() const;
 
     virtual double getEstimate() const = 0;
     virtual double getCompositeEstimate() const = 0;
-    virtual double getUpperBound(int numStdDev) const = 0;
-    virtual double getLowerBound(int numStdDev) const = 0;
+    virtual double getUpperBound(uint8_t numStdDev) const = 0;
+    virtual double getLowerBound(uint8_t numStdDev) const = 0;
 
-    inline int getLgConfigK() const;
+    inline uint8_t getLgConfigK() const;
 
-    virtual int getMemDataStart() const = 0;
+    virtual uint32_t getMemDataStart() const = 0;
 
-    virtual int getPreInts() const = 0;
+    virtual uint8_t getPreInts() const = 0;
 
     target_hll_type getTgtHllType() const;
 
-    virtual int getUpdatableSerializationBytes() const = 0;
-    virtual int getCompactSerializationBytes() const = 0;
+    virtual uint32_t getUpdatableSerializationBytes() const = 0;
+    virtual uint32_t getCompactSerializationBytes() const = 0;
 
     virtual bool isCompact() const = 0;
     virtual bool isEmpty() const = 0;
@@ -75,10 +75,10 @@ class HllSketchImpl {
     uint8_t makeFlagsByte(bool compact) const;
     uint8_t makeModeByte() const;
 
-    const int lgConfigK;
-    const target_hll_type tgtHllType;
-    const hll_mode mode;
-    const bool startFullSize;
+    const uint8_t lgConfigK_;
+    const target_hll_type tgtHllType_;
+    const hll_mode mode_;
+    const bool startFullSize_;
 };
 
 }

data/vendor/datasketches-cpp/hll/include/HllSketchImplFactory.hpp

@@ -39,7 +39,7 @@ public:
 
   static CouponHashSet<A>* promoteListToSet(const CouponList<A>& list);
   static HllArray<A>* promoteListOrSetToHll(const CouponList<A>& list);
-  static HllArray<A>* newHll(int lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator);
+  static HllArray<A>* newHll(uint8_t lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator);
   
   // resets the input impl, deleting the input pointer and returning a new pointer
   static HllSketchImpl<A>* reset(HllSketchImpl<A>* impl, bool startFullSize);
@@ -53,7 +53,7 @@ template<typename A>
 CouponHashSet<A>* HllSketchImplFactory<A>::promoteListToSet(const CouponList<A>& list) {
   using ChsAlloc = typename std::allocator_traits<A>::template rebind_alloc<CouponHashSet<A>>;
   CouponHashSet<A>* chSet = new (ChsAlloc(list.getAllocator()).allocate(1)) CouponHashSet<A>(list.getLgConfigK(), list.getTgtHllType(), list.getAllocator());
-  for (auto coupon: list) {
+  for (const auto coupon: list) {
     chSet->couponUpdate(coupon);
   }
   return chSet;
@@ -63,7 +63,7 @@ template<typename A>
 HllArray<A>* HllSketchImplFactory<A>::promoteListOrSetToHll(const CouponList<A>& src) {
   HllArray<A>* tgtHllArr = HllSketchImplFactory<A>::newHll(src.getLgConfigK(), src.getTgtHllType(), false, src.getAllocator());
   tgtHllArr->putKxQ0(1 << src.getLgConfigK());
-  for (auto coupon: src) {
+  for (const auto coupon: src) {
     tgtHllArr->couponUpdate(coupon);
   }
   tgtHllArr->putHipAccum(src.getEstimate());
@@ -75,12 +75,12 @@ template<typename A>
 HllSketchImpl<A>* HllSketchImplFactory<A>::deserialize(std::istream& is, const A& allocator) {
   // we'll hand off the sketch based on PreInts so we don't need
   // to move the stream pointer back and forth -- perhaps somewhat fragile?
-  const int preInts = is.peek();
-  if (preInts == HllUtil<A>::HLL_PREINTS) {
+  const uint8_t preInts = static_cast<uint8_t>(is.peek());
+  if (preInts == hll_constants::HLL_PREINTS) {
     return HllArray<A>::newHll(is, allocator);
-  } else if (preInts == HllUtil<A>::HASH_SET_PREINTS) {
+  } else if (preInts == hll_constants::HASH_SET_PREINTS) {
     return CouponHashSet<A>::newSet(is, allocator);
-  } else if (preInts == HllUtil<A>::LIST_PREINTS) {
+  } else if (preInts == hll_constants::LIST_PREINTS) {
     return CouponList<A>::newList(is, allocator);
   } else {
     throw std::invalid_argument("Attempt to deserialize unknown object type");
@@ -90,12 +90,12 @@ HllSketchImpl<A>* HllSketchImplFactory<A>::deserialize(std::istream& is, const A
 template<typename A>
 HllSketchImpl<A>* HllSketchImplFactory<A>::deserialize(const void* bytes, size_t len, const A& allocator) {
   // read current mode directly
-  const int preInts = static_cast<const uint8_t*>(bytes)[0];
-  if (preInts == HllUtil<A>::HLL_PREINTS) {
+  const uint8_t preInts = static_cast<const uint8_t*>(bytes)[0];
+  if (preInts == hll_constants::HLL_PREINTS) {
     return HllArray<A>::newHll(bytes, len, allocator);
-  } else if (preInts == HllUtil<A>::HASH_SET_PREINTS) {
+  } else if (preInts == hll_constants::HASH_SET_PREINTS) {
     return CouponHashSet<A>::newSet(bytes, len, allocator);
-  } else if (preInts == HllUtil<A>::LIST_PREINTS) {
+  } else if (preInts == hll_constants::LIST_PREINTS) {
     return CouponList<A>::newList(bytes, len, allocator);
   } else {
     throw std::invalid_argument("Attempt to deserialize unknown object type");
@@ -103,7 +103,7 @@ HllSketchImpl<A>* HllSketchImplFactory<A>::deserialize(const void* bytes, size_t
 }
 
 template<typename A>
-HllArray<A>* HllSketchImplFactory<A>::newHll(int lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator) {
+HllArray<A>* HllSketchImplFactory<A>::newHll(uint8_t lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator) {
   switch (tgtHllType) {
     case HLL_8:
       using Hll8Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>>;
@@ -134,7 +134,7 @@ HllSketchImpl<A>* HllSketchImplFactory<A>::reset(HllSketchImpl<A>* impl, bool st
 
 template<typename A>
 Hll4Array<A>* HllSketchImplFactory<A>::convertToHll4(const HllArray<A>& srcHllArr) {
-  const int lgConfigK = srcHllArr.getLgConfigK();
+  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll4Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll4Array<A>>;
   Hll4Array<A>* hll4Array = new (Hll4Alloc(srcHllArr.getAllocator()).allocate(1))
       Hll4Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
@@ -146,7 +146,7 @@ Hll4Array<A>* HllSketchImplFactory<A>::convertToHll4(const HllArray<A>& srcHllAr
 
 template<typename A>
 Hll6Array<A>* HllSketchImplFactory<A>::convertToHll6(const HllArray<A>& srcHllArr) {
-  const int lgConfigK = srcHllArr.getLgConfigK();
+  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll6Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll6Array<A>>;
   Hll6Array<A>* hll6Array = new (Hll6Alloc(srcHllArr.getAllocator()).allocate(1))
       Hll6Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
@@ -158,7 +158,7 @@ Hll6Array<A>* HllSketchImplFactory<A>::convertToHll6(const HllArray<A>& srcHllAr
 
 template<typename A>
 Hll8Array<A>* HllSketchImplFactory<A>::convertToHll8(const HllArray<A>& srcHllArr) {
-  const int lgConfigK = srcHllArr.getLgConfigK();
+  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll8Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>>;
   Hll8Array<A>* hll8Array = new (Hll8Alloc(srcHllArr.getAllocator()).allocate(1))
       Hll8Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());