Add C++ wrapper class in .h file

Author: sipa

include/minisketch.h

@@ -151,6 +151,154 @@ size_t minisketch_compute_max_elements(uint32_t bits, size_t capacity, uint32_t
 
 #ifdef __cplusplus
 }
-#endif
 
-#endif
+#if __cplusplus >= 201103L
+#include <memory>
+#include <vector>
+#if __cplusplus >= 201703L
+#include <optional>
+#endif // __cplusplus >= 201703L
+#include <cassert>
+
+/** Simple RAII C++11 wrapper around the minisketch API. */
+class Minisketch
+{
+    struct Deleter
+    {
+        void operator()(minisketch* ptr) const
+        {
+            minisketch_destroy(ptr);
+        }
+    };
+
+    std::unique_ptr<minisketch, Deleter> m_minisketch;
+
+public:
+    /** See minisketch_bits_supported(). */
+    static bool BitsSupported(uint32_t bits) { return minisketch_bits_supported(bits); }
+
+    /** See minisketch_implementation_max(). */
+    static uint32_t MaxImplementation() { return minisketch_implementation_max(); }
+
+    /** See minisketch_compute_capacity(). */
+    static size_t ComputeCapacity(uint32_t bits, size_t max_elements, uint32_t fpbits) { return minisketch_compute_capacity(bits, max_elements, fpbits); }
+
+    /** See minisketch_compute_max_elements(). */
+    static size_t ComputeMaxElements(uint32_t bits, size_t capacity, uint32_t fpbits) { return minisketch_compute_max_elements(bits, capacity, fpbits); }
+
+    /** Construct a clone of the specified sketch. */
+    Minisketch(const Minisketch& sketch)
+    {
+        m_minisketch = std::unique_ptr<minisketch, Deleter>(minisketch_clone(sketch.m_minisketch.get()));
+    }
+
+    /** Make this Minisketch a clone of the specified one. */
+    Minisketch& operator=(const Minisketch& sketch)
+    {
+        m_minisketch = std::unique_ptr<minisketch, Deleter>(minisketch_clone(sketch.m_minisketch.get()));
+        return *this;
+    }
+
+    Minisketch() = default;
+    Minisketch(Minisketch&&) = default;
+    Minisketch& operator=(Minisketch&&) = default;
+
+    /** Construct a Minisketch object with the specified parameters. */
+    Minisketch(uint32_t bits, uint32_t implementation, size_t capacity)
+    {
+        m_minisketch = std::unique_ptr<minisketch, Deleter>(minisketch_create(bits, implementation, capacity));
+    }
+
+    /** Create a Minisketch object sufficiently large for the specified number of elements at given fpbits. */
+    static Minisketch CreateFP(uint32_t bits, uint32_t implementation, size_t max_elements, uint32_t fpbits)
+    {
+        return Minisketch(bits, implementation, ComputeCapacity(bits, max_elements, fpbits));
+    }
+
+    /** See minisketch_get_bits(). */
+    uint32_t GetBits() const { return minisketch_bits(m_minisketch.get()); }
+
+    /** See minisketch_get_capacity(). */
+    size_t GetCapacity() const { return minisketch_capacity(m_minisketch.get()); }
+
+    /** See minisketch_get_implementation(). */
+    uint32_t GetImplementation() const { return minisketch_implementation(m_minisketch.get()); }
+
+    /** See minisketch_set_seed(). */
+    Minisketch& SetSeed(uint64_t seed)
+    {
+        minisketch_set_seed(m_minisketch.get(), seed);
+        return *this;
+    }
+
+    /** See miniksetch_add_element(). */
+    Minisketch& Add(uint64_t element)
+    {
+        minisketch_add_uint64(m_minisketch.get(), element);
+        return *this;
+    }
+
+    /** See minisketch_merge(). */
+    Minisketch& Merge(const Minisketch& sketch)
+    {
+        minisketch_merge(m_minisketch.get(), sketch.m_minisketch.get());
+        return *this;
+    }
+
+    /** Decode this sketch into the result vector, which must have a size equal to the maximum allowed elements. */
+    bool Decode(std::vector<uint64_t>& result) const
+    {
+        ssize_t ret = minisketch_decode(m_minisketch.get(), result.size(), result.data());
+        if (ret == -1) return false;
+        result.resize(ret);
+        return true;
+    }
+
+    /** See minisketch_serialized_size(). */
+    size_t GetSerializedSize() const { return minisketch_serialized_size(m_minisketch.get()); }
+
+    /** Serialize the sketch as a byte vector. */
+    std::vector<unsigned char> Serialize() const
+    {
+        std::vector<unsigned char> result(GetSerializedSize());
+        minisketch_serialize(m_minisketch.get(), result.data());
+        return result;
+    }
+
+    /** Deserialize into this sketch from an object containing its bytes (which has data() and size() members). */
+    template<typename T>
+    Minisketch& Deserialize(
+        const T& obj,
+        typename std::enable_if<
+            std::is_convertible<typename std::remove_pointer<decltype(obj.data())>::type (*)[], const unsigned char (*)[]>::value &&
+            std::is_convertible<decltype(obj.size()), std::size_t>::value,
+            std::nullptr_t
+        >::type = nullptr)
+    {
+        assert(GetSerializedSize() == obj.size());
+        minisketch_deserialize(m_minisketch.get(), obj.data());
+        return *this;
+    }
+
+#if __cplusplus >= 201703L
+    /** C++17 only: decode with a specified number of max elements into an optional vector. */
+    std::optional<std::vector<uint64_t>> Decode(size_t max_elements) const
+    {
+        std::vector<uint64_t> result(max_elements);
+        ssize_t ret = minisketch_decode(m_minisketch.get(), max_elements, result.data());
+        if (ret == -1) return {};
+        result.resize(ret);
+        return std::move(result);
+    }
+
+    /** C++17 only: decode with a specified fpbits into an optional vector. */
+    std::optional<std::vector<uint64_t>> DecodeFP(uint32_t fpbits) const
+    {
+        return Decode(ComputeMaxElements(GetBits(), GetCapacity(), fpbits));
+    }
+#endif // __cplusplus >= 201703L
+};
+#endif // __cplusplus >= 201103L
+#endif // __cplusplus
+
+#endif  // _MINISKETCH_H_