datasketches 0.3.2 → 0.4.0

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

@@ -30,23 +30,56 @@
 
 namespace datasketches {
 
-// serialize and deserialize
+/// Interface for serializing and deserializing items
 template<typename T, typename Enable = void> struct serde {
-  // stream serialization
+  /**
+   * Stream serialization
+   * @param os output stream
+   * @param items pointer to array of items
+   * @param num number of items
+   */
   void serialize(std::ostream& os, const T* items, unsigned num) const;
-  void deserialize(std::istream& is, T* items, unsigned num) const; // items allocated but not initialized
 
-  // raw bytes serialization
-  size_t size_of_item(const T& item) const;
+  /**
+   * Stream deserialization
+   * @param is input stream
+   * @param items pointer to array of items (items in the array are allocated but not initialized)
+   * @param num number of items
+   */
+  void deserialize(std::istream& is, T* items, unsigned num) const;
+
+  /**
+   * Raw bytes serialization
+   * @param ptr pointer to output buffer
+   * @param capacity size of the buffer in bytes
+   * @param items pointer to array of items
+   * @param num number of items
+   */
   size_t serialize(void* ptr, size_t capacity, const T* items, unsigned num) const;
-  size_t deserialize(const void* ptr, size_t capacity, T* items, unsigned num) const; // items allocated but not initialized
+
+  /**
+   * Raw bytes deserialization
+   * @param ptr pointer to input buffer
+   * @param capacity size of the buffer in bytes
+   * @param items pointer to array of items (items in the array are allocated but not initialized)
+   * @param num number of items
+   */
+  size_t deserialize(const void* ptr, size_t capacity, T* items, unsigned num) const;
+
+  /**
+   * Size of the given item
+   * @param item to be sized
+   * @return size of the given item in bytes
+   */
+  size_t size_of_item(const T& item) const;
 };
 
-// serde for all fixed-size arithmetic types (int and float of different sizes)
-// in particular, kll_sketch<int64_t> should produce sketches binary-compatible
-// with LongsSketch and ItemsSketch<Long> with ArrayOfLongsSerDe in Java
+/// serde for all fixed-size arithmetic types (int and float of different sizes).
+/// in particular, kll_sketch<int64_t> should produce sketches binary-compatible
+/// with LongsSketch and ItemsSketch<Long> with ArrayOfLongsSerDe in Java
 template<typename T>
 struct serde<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
+  /// @copydoc serde::serialize
   void serialize(std::ostream& os, const T* items, unsigned num) const {
     bool failure = false;
     try {
@@ -58,6 +91,7 @@ struct serde<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
       throw std::runtime_error("error writing to std::ostream with " + std::to_string(num) + " items");
     }
   }
+
   void deserialize(std::istream& is, T* items, unsigned num) const {
     bool failure = false;
     try {
@@ -70,30 +104,37 @@ struct serde<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
     }
   }
 
-  size_t size_of_item(const T&) const {
-    return sizeof(T);
-  }
+  /// @copydoc serde::serialize(void*,size_t,const T*,unsigned) const
   size_t serialize(void* ptr, size_t capacity, const T* items, unsigned num) const {
     const size_t bytes_written = sizeof(T) * num;
     check_memory_size(bytes_written, capacity);
     memcpy(ptr, items, bytes_written);
     return bytes_written;
   }
+
+  /// @copydoc serde::deserialize(const void*,size_t,T*,unsigned) const
   size_t deserialize(const void* ptr, size_t capacity, T* items, unsigned num) const {
     const size_t bytes_read = sizeof(T) * num;
     check_memory_size(bytes_read, capacity);
     memcpy(items, ptr, bytes_read);
     return bytes_read;
   }
+
+  /// @copydoc serde::size_of_item
+  size_t size_of_item(const T& item) const {
+    unused(item);
+    return sizeof(T);
+  }
 };
 
-// serde for std::string items
-// This should produce sketches binary-compatible with
-// ItemsSketch<String> with ArrayOfStringsSerDe in Java.
-// The length of each string is stored as a 32-bit integer (historically),
-// which may be too wasteful. Treat this as an example.
+/// serde for std::string items.
+/// This should produce sketches binary-compatible with
+/// ItemsSketch<String> with ArrayOfStringsSerDe in Java.
+/// The length of each string is stored as a 32-bit integer (historically),
+/// which may be too wasteful. Treat this as an example.
 template<>
 struct serde<std::string> {
+  /// @copydoc serde::serialize
   void serialize(std::ostream& os, const std::string* items, unsigned num) const {
     unsigned i = 0;
     bool failure = false;
@@ -110,6 +151,8 @@ struct serde<std::string> {
       throw std::runtime_error("error writing to std::ostream at item " + std::to_string(i));
     }
   }
+
+  /// @copydoc serde::deserialize
   void deserialize(std::istream& is, std::string* items, unsigned num) const {
     unsigned i = 0;
     bool failure = false;
@@ -137,9 +180,8 @@ struct serde<std::string> {
       throw std::runtime_error("error reading from std::istream at item " + std::to_string(i)); 
     }
   }
-  size_t size_of_item(const std::string& item) const {
-    return sizeof(uint32_t) + item.size();
-  }
+
+  /// @copydoc serde::serialize(void*,size_t,const T*,unsigned) const
   size_t serialize(void* ptr, size_t capacity, const std::string* items, unsigned num) const {
     size_t bytes_written = 0;
     for (unsigned i = 0; i < num; ++i) {
@@ -154,6 +196,8 @@ struct serde<std::string> {
     }
     return bytes_written;
   }
+
+  /// @copydoc serde::deserialize(const void*,size_t,T*,unsigned) const
   size_t deserialize(const void* ptr, size_t capacity, std::string* items, unsigned num) const {
     size_t bytes_read = 0;
     unsigned i = 0;
@@ -189,6 +233,11 @@ struct serde<std::string> {
 
     return bytes_read;
   }
+
+  /// @copydoc serde::size_of_item
+  size_t size_of_item(const std::string& item) const {
+    return sizeof(uint32_t) + item.size();
+  }
 };
 
 } /* namespace datasketches */

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

@@ -34,7 +34,6 @@ FetchContent_MakeAvailable(Catch2)
 target_link_libraries(common_test_lib PUBLIC Catch2::Catch2)
 
 set_target_properties(common_test_lib PROPERTIES
-  CXX_STANDARD 11
   CXX_STANDARD_REQUIRED YES
 )
 
@@ -69,6 +68,7 @@ add_test(
 target_sources(common_test
   PRIVATE
     quantiles_sorted_view_test.cpp
+    optional_test.cpp
 )
 
 # now the integration test part

data/vendor/datasketches-cpp/common/test/optional_test.cpp

@@ -0,0 +1,85 @@
+/*
+ * 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.
+ */
+
+#include <catch2/catch.hpp>
+
+#include <iostream>
+
+#include "optional.hpp"
+
+namespace datasketches {
+
+class tt {
+public:
+  tt() = delete; // make sure it cannot be default constructed
+  tt(int val): val_(val) {}
+  tt(const tt& other): val_(other.val_) { std::cout << "tt copy constructor\n"; }
+  tt(tt&& other): val_(other.val_) { std::cout << "tt move constructor\n"; }
+  tt& operator=(const tt& other) { val_ = other.val_; std::cout << "tt copy assignment\n"; return *this; }
+  tt& operator=(tt&& other) { val_ = other.val_; std::cout << "tt move assignment\n"; return *this; }
+  int get_val() const { return val_; }
+private:
+  int val_;
+};
+
+TEST_CASE("optional", "[common]") {
+  optional<tt> opt;
+  REQUIRE_FALSE(opt);
+  opt.emplace(5);
+  REQUIRE(bool(opt));
+  REQUIRE((*opt).get_val() == 5);
+  REQUIRE(opt->get_val() == 5);
+  opt.reset();
+  REQUIRE_FALSE(opt);
+
+  optional<tt> opt2(opt);
+  REQUIRE_FALSE(opt2);
+
+  opt2.emplace(3);
+  if (opt2) *opt2 = 6; // good if it is initialized
+  REQUIRE(opt2->get_val() == 6);
+
+  opt.reset();
+  REQUIRE_FALSE(opt);
+  optional<tt> opt3(std::move(opt));
+  REQUIRE_FALSE(opt3);
+  *opt3 = 7; // don't do this! may be dangerous for arbitrary T, and it still thinks it is not initialized
+  REQUIRE_FALSE(opt3);
+  opt3.emplace(8);
+  REQUIRE(bool(opt3));
+  REQUIRE(opt3->get_val() == 8);
+
+  std::swap(opt2, opt3);
+  REQUIRE(opt2->get_val() == 8);
+  REQUIRE(opt3->get_val() == 6);
+
+  std::swap(opt2, opt);
+  REQUIRE_FALSE(opt2);
+  REQUIRE(bool(opt));
+  REQUIRE(opt->get_val() == 8);
+}
+
+TEST_CASE("optional conversion", "[common]") {
+  optional<float> opt_f(1);
+  optional<double> opt_d(opt_f);
+  REQUIRE(bool(opt_d));
+  REQUIRE(*opt_d == static_cast<double>(*opt_f));
+}
+
+} /* namespace datasketches */

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

@@ -33,16 +33,16 @@ extern long long test_allocator_net_allocations;
 
 template <class T> class test_allocator {
 public:
-  typedef T                 value_type;
-  typedef value_type*       pointer;
-  typedef const value_type* const_pointer;
-  typedef value_type&       reference;
-  typedef const value_type& const_reference;
-  typedef std::size_t       size_type;
-  typedef std::ptrdiff_t    difference_type;
+  using value_type = T;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
 
   template <class U>
-  struct rebind { typedef test_allocator<U> other; };
+  struct rebind { using other = test_allocator<U>; };
 
   // this is to test that a given instance of an allocator is used instead of instantiating
   static const bool DISALLOW_DEFAULT_CONSTRUCTOR = true;
@@ -66,7 +66,7 @@ public:
   }
 
   pointer allocate(size_type n, const_pointer = 0) {
-    void* p = new char[n * sizeof(value_type)];
+    void* p = ::operator new(n * sizeof(value_type));
     if (!p) throw std::bad_alloc();
     test_allocator_total_bytes += n * sizeof(value_type);
     ++test_allocator_net_allocations;
@@ -74,7 +74,7 @@ public:
   }
 
   void deallocate(pointer p, size_type n) {
-    if (p) delete[] (char*) p;
+    if (p) ::operator delete(p);
     test_allocator_total_bytes -= n * sizeof(value_type);
     --test_allocator_net_allocations;
   }
@@ -92,12 +92,12 @@ public:
 
 template<> class test_allocator<void> {
 public:
-  typedef void        value_type;
-  typedef void*       pointer;
-  typedef const void* const_pointer;
+  using value_type = void;
+  using pointer = void*;
+  using const_pointer = const void*;
 
   template <class U>
-  struct rebind { typedef test_allocator<U> other; };
+  struct rebind { using other = test_allocator<U>; };
 };