roaring.hh

Go to the documentation of this file.

/*
A C++ header for Roaring Bitmaps.
*/
#ifndef INCLUDE_ROARING_HH_
#define INCLUDE_ROARING_HH_
 
#include <algorithm>
#include <cstdarg>
#include <initializer_list>
#include <limits>
#include <new>
#include <stdexcept>
#include <string>
 
#if !defined(ROARING_EXCEPTIONS)
// __cpp_exceptions is required by C++98 and we require C++11 or better.
#ifndef __cpp_exceptions
#error "__cpp_exceptions should be defined"
#endif
#if __cpp_exceptions
#define ROARING_EXCEPTIONS 1
#else
#define ROARING_EXCEPTIONS 0
#endif
#endif
 
#ifndef ROARING_TERMINATE
#if ROARING_EXCEPTIONS
#define ROARING_TERMINATE(_s) throw std::runtime_error(_s)
#else
#define ROARING_TERMINATE(_s) std::terminate()
#endif
#endif
 
#define ROARING_API_NOT_IN_GLOBAL_NAMESPACE  // see remarks in roaring.h
#include <roaring/roaring.h>
#undef ROARING_API_NOT_IN_GLOBAL_NAMESPACE
 
#include <roaring/roaring_array.h>  // roaring::internal array functions used
 
namespace roaring {
 
class RoaringSetBitBiDirectionalIterator;
 
using RoaringSetBitForwardIterator = RoaringSetBitBiDirectionalIterator;
 
class BulkContext {
   public:
    friend class Roaring;
    using roaring_bitmap_bulk_context_t = api::roaring_bulk_context_t;
    BulkContext() : context_{nullptr, 0, 0, 0} {}
 
    BulkContext(const BulkContext &) = delete;
    BulkContext &operator=(const BulkContext &) = delete;
    BulkContext(BulkContext &&) noexcept = default;
    BulkContext &operator=(BulkContext &&) noexcept = default;
 
   private:
    roaring_bitmap_bulk_context_t context_;
};
 
class Roaring {
    typedef api::roaring_bitmap_t roaring_bitmap_t;  // class-local name alias
 
   public:
    Roaring() : roaring{} {
        // The empty constructor roaring{} silences warnings from pedantic
        // static analyzers.
        api::roaring_bitmap_init_cleared(&roaring);
    }
 
    Roaring(size_t n, const uint32_t *data) : Roaring() {
        api::roaring_bitmap_add_many(&roaring, n, data);
    }
 
    Roaring(std::initializer_list<uint32_t> l) : Roaring() {
        addMany(l.size(), l.begin());
    }
 
    explicit Roaring(roaring_bitmap_t *s) noexcept : roaring(*s) {
        roaring_free(s);  // deallocate the passed-in pointer
    }
 
    Roaring(const Roaring &r) : Roaring() {
        if (!api::roaring_bitmap_overwrite(&roaring, &r.roaring)) {
            ROARING_TERMINATE("failed roaring_bitmap_overwrite in constructor");
        }
        api::roaring_bitmap_set_copy_on_write(
            &roaring, api::roaring_bitmap_get_copy_on_write(&r.roaring));
    }
 
    Roaring(Roaring &&r) noexcept : roaring(r.roaring) {
        //
        // !!! This clones the bits of the roaring structure to a new location
        // and then overwrites the old bits...assuming that this will still
        // work.  There are scenarios where this could break; e.g. if some of
        // those bits were pointers into the structure memory itself.  If such
        // things were possible, a roaring_bitmap_move() API would be needed.
        //
        api::roaring_bitmap_init_cleared(&r.roaring);
    }
 
    static Roaring bitmapOf(size_t n, ...) {
        Roaring ans;
        va_list vl;
        va_start(vl, n);
        for (size_t i = 0; i < n; i++) {
            ans.add(va_arg(vl, uint32_t));
        }
        va_end(vl);
        return ans;
    }
 
    Roaring &operator=(const Roaring &r) {
        if (!api::roaring_bitmap_overwrite(&roaring, &r.roaring)) {
            ROARING_TERMINATE("failed memory alloc in assignment");
        }
        api::roaring_bitmap_set_copy_on_write(
            &roaring, api::roaring_bitmap_get_copy_on_write(&r.roaring));
        return *this;
    }
 
    Roaring &operator=(Roaring &&r) noexcept {
        api::roaring_bitmap_clear(&roaring);  // free this class's allocations
 
        // !!! See notes in the Move Constructor regarding roaring_bitmap_move()
        //
        roaring = r.roaring;
        api::roaring_bitmap_init_cleared(&r.roaring);
 
        return *this;
    }
 
    Roaring &operator=(std::initializer_list<uint32_t> l) {
        // Delegate to move assignment operator
        *this = Roaring(l);
        return *this;
    }
 
    static Roaring bitmapOfList(std::initializer_list<uint32_t> l) {
        Roaring ans;
        ans.addMany(l.size(), l.begin());
        return ans;
    }
 
    void add(uint32_t x) noexcept { api::roaring_bitmap_add(&roaring, x); }
 
    bool addChecked(uint32_t x) noexcept {
        return api::roaring_bitmap_add_checked(&roaring, x);
    }
 
    void addRange(const uint64_t min, const uint64_t max) noexcept {
        return api::roaring_bitmap_add_range(&roaring, min, max);
    }
 
    void addRangeClosed(const uint32_t min, const uint32_t max) noexcept {
        return api::roaring_bitmap_add_range_closed(&roaring, min, max);
    }
 
    void addMany(size_t n_args, const uint32_t *vals) noexcept {
        api::roaring_bitmap_add_many(&roaring, n_args, vals);
    }
 
    void addBulk(BulkContext &context, uint32_t x) noexcept {
        api::roaring_bitmap_add_bulk(&roaring, &context.context_, x);
    }
 
    bool containsBulk(BulkContext &context, uint32_t x) const noexcept {
        return api::roaring_bitmap_contains_bulk(&roaring, &context.context_,
                                                 x);
    }
 
    void remove(uint32_t x) noexcept {
        api::roaring_bitmap_remove(&roaring, x);
    }
 
    bool removeChecked(uint32_t x) noexcept {
        return api::roaring_bitmap_remove_checked(&roaring, x);
    }
 
    void removeRange(uint64_t min, uint64_t max) noexcept {
        return api::roaring_bitmap_remove_range(&roaring, min, max);
    }
 
    void removeRangeClosed(uint32_t min, uint32_t max) noexcept {
        return api::roaring_bitmap_remove_range_closed(&roaring, min, max);
    }
 
    void clear() { api::roaring_bitmap_clear(&roaring); }
 
    uint32_t maximum() const noexcept {
        return api::roaring_bitmap_maximum(&roaring);
    }
 
    uint32_t minimum() const noexcept {
        return api::roaring_bitmap_minimum(&roaring);
    }
 
    bool contains(uint32_t x) const noexcept {
        return api::roaring_bitmap_contains(&roaring, x);
    }
 
    bool containsRange(const uint64_t x, const uint64_t y) const noexcept {
        return api::roaring_bitmap_contains_range(&roaring, x, y);
    }
 
    bool containsRangeClosed(const uint32_t x,
                             const uint32_t y) const noexcept {
        return api::roaring_bitmap_contains_range_closed(&roaring, x, y);
    }
 
    Roaring &operator&=(const Roaring &r) noexcept {
        api::roaring_bitmap_and_inplace(&roaring, &r.roaring);
        return *this;
    }
 
    Roaring &operator-=(const Roaring &r) noexcept {
        api::roaring_bitmap_andnot_inplace(&roaring, &r.roaring);
        return *this;
    }
 
    Roaring &operator|=(const Roaring &r) noexcept {
        api::roaring_bitmap_or_inplace(&roaring, &r.roaring);
        return *this;
    }
 
    Roaring &operator^=(const Roaring &r) noexcept {
        api::roaring_bitmap_xor_inplace(&roaring, &r.roaring);
        return *this;
    }
 
    void swap(Roaring &r) noexcept { std::swap(r.roaring, roaring); }
 
    uint64_t cardinality() const noexcept {
        return api::roaring_bitmap_get_cardinality(&roaring);
    }
 
    bool isEmpty() const noexcept {
        return api::roaring_bitmap_is_empty(&roaring);
    }
 
    bool isFull() const noexcept {
        return api::roaring_bitmap_get_cardinality(&roaring) ==
               ((uint64_t)(std::numeric_limits<uint32_t>::max)()) + 1;
    }
 
    bool isSubset(const Roaring &r) const noexcept {
        return api::roaring_bitmap_is_subset(&roaring, &r.roaring);
    }
 
    bool isStrictSubset(const Roaring &r) const noexcept {
        return api::roaring_bitmap_is_strict_subset(&roaring, &r.roaring);
    }
 
    void toUint32Array(uint32_t *ans) const noexcept {
        api::roaring_bitmap_to_uint32_array(&roaring, ans);
    }
    void rangeUint32Array(uint32_t *ans, size_t offset,
                          size_t limit) const noexcept {
        api::roaring_bitmap_range_uint32_array(&roaring, offset, limit, ans);
    }
 
    bool operator==(const Roaring &r) const noexcept {
        return api::roaring_bitmap_equals(&roaring, &r.roaring);
    }
 
    void flip(uint64_t range_start, uint64_t range_end) noexcept {
        api::roaring_bitmap_flip_inplace(&roaring, range_start, range_end);
    }
 
    void flipClosed(uint32_t range_start, uint32_t range_end) noexcept {
        api::roaring_bitmap_flip_inplace_closed(&roaring, range_start,
                                                range_end);
    }
 
    bool removeRunCompression() noexcept {
        return api::roaring_bitmap_remove_run_compression(&roaring);
    }
 
    bool runOptimize() noexcept {
        return api::roaring_bitmap_run_optimize(&roaring);
    }
 
    size_t shrinkToFit() noexcept {
        return api::roaring_bitmap_shrink_to_fit(&roaring);
    }
 
    void iterate(api::roaring_iterator iterator, void *ptr) const {
        api::roaring_iterate(&roaring, iterator, ptr);
    }
 
    bool select(uint32_t rnk, uint32_t *element) const noexcept {
        return api::roaring_bitmap_select(&roaring, rnk, element);
    }
 
    uint64_t and_cardinality(const Roaring &r) const noexcept {
        return api::roaring_bitmap_and_cardinality(&roaring, &r.roaring);
    }
 
    bool intersect(const Roaring &r) const noexcept {
        return api::roaring_bitmap_intersect(&roaring, &r.roaring);
    }
 
    double jaccard_index(const Roaring &r) const noexcept {
        return api::roaring_bitmap_jaccard_index(&roaring, &r.roaring);
    }
 
    uint64_t or_cardinality(const Roaring &r) const noexcept {
        return api::roaring_bitmap_or_cardinality(&roaring, &r.roaring);
    }
 
    uint64_t andnot_cardinality(const Roaring &r) const noexcept {
        return api::roaring_bitmap_andnot_cardinality(&roaring, &r.roaring);
    }
 
    uint64_t xor_cardinality(const Roaring &r) const noexcept {
        return api::roaring_bitmap_xor_cardinality(&roaring, &r.roaring);
    }
 
    uint64_t rank(uint32_t x) const noexcept {
        return api::roaring_bitmap_rank(&roaring, x);
    }
 
    void rank_many(const uint32_t *begin, const uint32_t *end,
                   uint64_t *ans) const noexcept {
        return api::roaring_bitmap_rank_many(&roaring, begin, end, ans);
    }
 
    int64_t getIndex(uint32_t x) const noexcept {
        return api::roaring_bitmap_get_index(&roaring, x);
    }
 
    size_t write(char *buf, bool portable = true) const noexcept {
        if (portable) {
            return api::roaring_bitmap_portable_serialize(&roaring, buf);
        } else {
            return api::roaring_bitmap_serialize(&roaring, buf);
        }
    }
 
    static Roaring read(const char *buf, bool portable = true) {
        roaring_bitmap_t *r =
            portable ? api::roaring_bitmap_portable_deserialize(buf)
                     : api::roaring_bitmap_deserialize(buf);
        if (r == NULL) {
            ROARING_TERMINATE("failed alloc while reading");
        }
        return Roaring(r);
    }
 
    static Roaring readSafe(const char *buf, size_t maxbytes) {
        roaring_bitmap_t *r =
            api::roaring_bitmap_portable_deserialize_safe(buf, maxbytes);
        if (r == NULL) {
            ROARING_TERMINATE("failed alloc while reading");
        }
        return Roaring(r);
    }
 
    size_t getSizeInBytes(bool portable = true) const noexcept {
        if (portable) {
            return api::roaring_bitmap_portable_size_in_bytes(&roaring);
        } else {
            return api::roaring_bitmap_size_in_bytes(&roaring);
        }
    }
 
    static const Roaring frozenView(const char *buf, size_t length) {
        const roaring_bitmap_t *s =
            api::roaring_bitmap_frozen_view(buf, length);
        if (s == NULL) {
            ROARING_TERMINATE("failed to read frozen bitmap");
        }
        Roaring r;
        r.roaring = *s;
        return r;
    }
 
    static const Roaring portableDeserializeFrozen(const char *buf) {
        const roaring_bitmap_t *s =
            api::roaring_bitmap_portable_deserialize_frozen(buf);
        if (s == NULL) {
            ROARING_TERMINATE("failed to read portable frozen bitmap");
        }
        Roaring r;
        r.roaring = *s;
        return r;
    }
 
    void writeFrozen(char *buf) const noexcept {
        roaring_bitmap_frozen_serialize(&roaring, buf);
    }
 
    size_t getFrozenSizeInBytes() const noexcept {
        return roaring_bitmap_frozen_size_in_bytes(&roaring);
    }
 
    Roaring operator&(const Roaring &o) const {
        roaring_bitmap_t *r = api::roaring_bitmap_and(&roaring, &o.roaring);
        if (r == NULL) {
            ROARING_TERMINATE("failed materalization in and");
        }
        return Roaring(r);
    }
 
    Roaring operator-(const Roaring &o) const {
        roaring_bitmap_t *r = api::roaring_bitmap_andnot(&roaring, &o.roaring);
        if (r == NULL) {
            ROARING_TERMINATE("failed materalization in andnot");
        }
        return Roaring(r);
    }
 
    Roaring operator|(const Roaring &o) const {
        roaring_bitmap_t *r = api::roaring_bitmap_or(&roaring, &o.roaring);
        if (r == NULL) {
            ROARING_TERMINATE("failed materalization in or");
        }
        return Roaring(r);
    }
 
    Roaring operator^(const Roaring &o) const {
        roaring_bitmap_t *r = api::roaring_bitmap_xor(&roaring, &o.roaring);
        if (r == NULL) {
            ROARING_TERMINATE("failed materalization in xor");
        }
        return Roaring(r);
    }
 
    void setCopyOnWrite(bool val) noexcept {
        api::roaring_bitmap_set_copy_on_write(&roaring, val);
    }
 
    void printf() const noexcept { api::roaring_bitmap_printf(&roaring); }
 
    std::string toString() const noexcept {
        struct iter_data {
            std::string str{};  // The empty constructor silences warnings from
                                // pedantic static analyzers.
            char first_char = '{';
        } outer_iter_data;
        if (!isEmpty()) {
            iterate(
                [](uint32_t value, void *inner_iter_data) -> bool {
                    ((iter_data *)inner_iter_data)->str +=
                        ((iter_data *)inner_iter_data)->first_char;
                    ((iter_data *)inner_iter_data)->str +=
                        std::to_string(value);
                    ((iter_data *)inner_iter_data)->first_char = ',';
                    return true;
                },
                (void *)&outer_iter_data);
        } else
            outer_iter_data.str = '{';
        outer_iter_data.str += '}';
        return outer_iter_data.str;
    }
 
    bool getCopyOnWrite() const noexcept {
        return api::roaring_bitmap_get_copy_on_write(&roaring);
    }
 
    static Roaring fastunion(size_t n, const Roaring **inputs) {
        const roaring_bitmap_t **x = (const roaring_bitmap_t **)roaring_malloc(
            n * sizeof(roaring_bitmap_t *));
        if (x == NULL) {
            ROARING_TERMINATE("failed memory alloc in fastunion");
        }
        for (size_t k = 0; k < n; ++k) x[k] = &inputs[k]->roaring;
 
        roaring_bitmap_t *c_ans = api::roaring_bitmap_or_many(n, x);
        if (c_ans == NULL) {
            roaring_free(x);
            ROARING_TERMINATE("failed memory alloc in fastunion");
        }
        Roaring ans(c_ans);
        roaring_free(x);
        return ans;
    }
 
    ~Roaring() {
        if (!(roaring.high_low_container.flags & ROARING_FLAG_FROZEN)) {
            api::roaring_bitmap_clear(&roaring);
        } else {
            // The roaring member variable copies the `roaring_bitmap_t` and
            // nested `roaring_array_t` structures by value and is freed in the
            // constructor, however the underlying memory arena used for the
            // container data is not freed with it. Here we derive the arena
            // pointer from the second arena allocation in
            // `roaring_bitmap_frozen_view` and free it as well.
            roaring_bitmap_free(
                (roaring_bitmap_t *)((char *)
                                         roaring.high_low_container.containers -
                                     sizeof(roaring_bitmap_t)));
        }
    }
 
    friend class RoaringSetBitBiDirectionalIterator;
    typedef RoaringSetBitBiDirectionalIterator const_iterator;
    typedef RoaringSetBitBiDirectionalIterator const_bidirectional_iterator;
 
    const_iterator begin() const;
 
    const_iterator &end() const;
 
    roaring_bitmap_t roaring;
};
 
class RoaringSetBitBiDirectionalIterator final {
   public:
    typedef std::bidirectional_iterator_tag iterator_category;
    typedef uint32_t *pointer;
    typedef uint32_t &reference_type;
    typedef uint32_t value_type;
    typedef int32_t difference_type;
    typedef RoaringSetBitBiDirectionalIterator type_of_iterator;
 
    explicit RoaringSetBitBiDirectionalIterator(const Roaring &parent,
                                                bool exhausted = false) {
        if (exhausted) {
            i.parent = &parent.roaring;
            i.container_index = INT32_MAX;
            i.has_value = false;
            i.current_value = UINT32_MAX;
        } else {
            api::roaring_iterator_init(&parent.roaring, &i);
        }
    }
 
    value_type operator*() const { return i.current_value; }
 
    bool operator<(const type_of_iterator &o) const {
        if (!i.has_value) return false;
        if (!o.i.has_value) return true;
        return i.current_value < *o;
    }
 
    bool operator<=(const type_of_iterator &o) const {
        if (!o.i.has_value) return true;
        if (!i.has_value) return false;
        return i.current_value <= *o;
    }
 
    bool operator>(const type_of_iterator &o) const {
        if (!o.i.has_value) return false;
        if (!i.has_value) return true;
        return i.current_value > *o;
    }
 
    bool operator>=(const type_of_iterator &o) const {
        if (!i.has_value) return true;
        if (!o.i.has_value) return false;
        return i.current_value >= *o;
    }
 
    type_of_iterator &operator++() {  // ++i, must returned inc. value
        api::roaring_uint32_iterator_advance(&i);
        return *this;
    }
 
    type_of_iterator operator++(int) {  // i++, must return orig. value
        RoaringSetBitBiDirectionalIterator orig(*this);
        api::roaring_uint32_iterator_advance(&i);
        return orig;
    }
 
    bool move_equalorlarger(value_type val) {
        return api::roaring_uint32_iterator_move_equalorlarger(&i, val);
    }
 
    CROARING_DEPRECATED void equalorlarger(uint32_t val) {
        api::roaring_uint32_iterator_move_equalorlarger(&i, val);
    }
 
    type_of_iterator &operator--() {  // prefix --
        api::roaring_uint32_iterator_previous(&i);
        return *this;
    }
 
    type_of_iterator operator--(int) {  // postfix --
        RoaringSetBitBiDirectionalIterator orig(*this);
        api::roaring_uint32_iterator_previous(&i);
        return orig;
    }
 
    bool operator==(const RoaringSetBitBiDirectionalIterator &o) const {
        return i.current_value == *o && i.has_value == o.i.has_value;
    }
 
    bool operator!=(const RoaringSetBitBiDirectionalIterator &o) const {
        return i.current_value != *o || i.has_value != o.i.has_value;
    }
 
    api::roaring_uint32_iterator_t
        i{};  // The empty constructor silences warnings from pedantic static
              // analyzers.
};
 
inline RoaringSetBitBiDirectionalIterator Roaring::begin() const {
    return RoaringSetBitBiDirectionalIterator(*this);
}
 
inline RoaringSetBitBiDirectionalIterator &Roaring::end() const {
    static RoaringSetBitBiDirectionalIterator e(*this, true);
    return e;
}
 
}  // namespace roaring
 
#endif /* INCLUDE_ROARING_HH_ */