Reworked bitmap code

This commit is contained in:
Luca Deri
2021-09-27 10:29:03 +02:00
parent 72df138a7d
commit 519c69c5cc
4 changed files with 794 additions and 759 deletions
+101
View File
@@ -0,0 +1,101 @@
/*
* ndpi_utils.c
*
* Copyright (C) 2011-21 - ntop.org
*
* This file is part of nDPI, an open source deep packet inspection
* library based on the OpenDPI and PACE technology by ipoque GmbH
*
* nDPI is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* nDPI is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with nDPI. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include <stdlib.h>
#include <errno.h>
#include <math.h>
#include <sys/types.h>
#define NDPI_CURRENT_PROTO NDPI_PROTOCOL_UNKNOWN
#include "ndpi_config.h"
#include "ndpi_api.h"
#include "ndpi_includes.h"
#include "ndpi_encryption.h"
#include "third_party/include/roaring.h"
#include "third_party/src/roaring.cc"
/* ******************************************* */
ndpi_bitmap* ndpi_bitmap_alloc() {
return((ndpi_bitmap*)roaring_bitmap_create());
}
/* ******************************************* */
void ndpi_bitmap_free(ndpi_bitmap* b) {
roaring_bitmap_free((const roaring_bitmap_t *)b);
}
/* ******************************************* */
u_int64_t ndpi_bitmap_cardinality(ndpi_bitmap* b) {
return(roaring_bitmap_get_cardinality((const roaring_bitmap_t *)b));
}
/* ******************************************* */
void ndpi_bitmap_set(ndpi_bitmap* b, u_int32_t value) {
roaring_bitmap_add((roaring_bitmap_t *)b, value);
}
/* ******************************************* */
void ndpi_bitmap_unset(ndpi_bitmap* b, u_int32_t value) {
roaring_bitmap_remove((roaring_bitmap_t *)b, value);
}
/* ******************************************* */
bool ndpi_bitmap_isset(ndpi_bitmap* b, u_int32_t value) {
return(roaring_bitmap_contains((const roaring_bitmap_t *)b, value));
}
/* ******************************************* */
void ndpi_bitmap_clear(ndpi_bitmap* b) {
roaring_bitmap_clear((roaring_bitmap_t *)b);
}
/* ******************************************* */
size_t ndpi_bitmap_serialize(ndpi_bitmap* b, char **buf) {
const roaring_bitmap_t *r = (const roaring_bitmap_t *)b;
size_t s = roaring_bitmap_size_in_bytes(r);
*buf = (char*)ndpi_malloc(s);
if((*buf) == NULL) return(0);
return(roaring_bitmap_serialize(r, *buf));
}
/* ******************************************* */
ndpi_bitmap* ndpi_bitmap_deserialize(char *buf) {
return((ndpi_bitmap*)roaring_bitmap_deserialize(buf));
}
-63
View File
@@ -53,8 +53,6 @@
#include "third_party/include/libinjection_xss.h"
#include "third_party/include/rce_injection.h"
#include "third_party/include/roaring.h"
#define NDPI_CONST_GENERIC_PROTOCOL_NAME "GenericProtocol"
// #define MATCH_DEBUG 1
@@ -2262,64 +2260,3 @@ u_int8_t ndpi_is_encrypted_proto(struct ndpi_detection_module_struct *ndpi_str,
return(0);
}
/* ******************************************* */
ndpi_bitmap* ndpi_bitmap_alloc() {
return((ndpi_bitmap*)roaring_bitmap_create());
}
/* ******************************************* */
void ndpi_bitmap_free(ndpi_bitmap* b) {
roaring_bitmap_free((const roaring_bitmap_t *)b);
}
/* ******************************************* */
u_int64_t ndpi_bitmap_cardinality(ndpi_bitmap* b) {
return(roaring_bitmap_get_cardinality((const roaring_bitmap_t *)b));
}
/* ******************************************* */
void ndpi_bitmap_set(ndpi_bitmap* b, u_int32_t value) {
roaring_bitmap_add((roaring_bitmap_t *)b, value);
}
/* ******************************************* */
void ndpi_bitmap_unset(ndpi_bitmap* b, u_int32_t value) {
roaring_bitmap_remove((roaring_bitmap_t *)b, value);
}
/* ******************************************* */
bool ndpi_bitmap_isset(ndpi_bitmap* b, u_int32_t value) {
return(roaring_bitmap_contains((const roaring_bitmap_t *)b, value));
}
/* ******************************************* */
void ndpi_bitmap_clear(ndpi_bitmap* b) {
roaring_bitmap_clear((roaring_bitmap_t *)b);
}
/* ******************************************* */
size_t ndpi_bitmap_serialize(ndpi_bitmap* b, char **buf) {
const roaring_bitmap_t *r = (const roaring_bitmap_t *)b;
size_t s = roaring_bitmap_size_in_bytes(r);
*buf = (char*)ndpi_malloc(s);
if((*buf) == NULL) return(0);
return(roaring_bitmap_serialize(r, *buf));
}
/* ******************************************* */
ndpi_bitmap* ndpi_bitmap_deserialize(char *buf) {
return((ndpi_bitmap*)roaring_bitmap_deserialize(buf));
}
+84 -84
View File
@@ -170,7 +170,7 @@ typedef struct roaring_bitmap_s {
* Capacity is a performance hint for how many "containers" the data will need.
* Client is responsible for calling `roaring_bitmap_free()`.
*/
roaring_bitmap_t *roaring_bitmap_create_with_capacity(uint32_t cap);
static roaring_bitmap_t *roaring_bitmap_create_with_capacity(uint32_t cap);
/**
* Dynamically allocates a new bitmap (initially empty).
@@ -185,7 +185,7 @@ static inline roaring_bitmap_t *roaring_bitmap_create(void)
* Capacity is a performance hint for how many "containers" the data will need.
* Can return false if auxiliary allocations fail when capacity greater than 0.
*/
bool roaring_bitmap_init_with_capacity(roaring_bitmap_t *r, uint32_t cap);
static bool roaring_bitmap_init_with_capacity(roaring_bitmap_t *r, uint32_t cap);
/**
* Initialize a roaring bitmap structure in memory controlled by client.
@@ -199,13 +199,13 @@ static inline void roaring_bitmap_init_cleared(roaring_bitmap_t *r)
* Add all the values between min (included) and max (excluded) that are at a
* distance k*step from min.
*/
roaring_bitmap_t *roaring_bitmap_from_range(uint64_t min, uint64_t max,
static roaring_bitmap_t *roaring_bitmap_from_range(uint64_t min, uint64_t max,
uint32_t step);
/**
* Creates a new bitmap from a pointer of uint32_t integers
*/
roaring_bitmap_t *roaring_bitmap_of_ptr(size_t n_args, const uint32_t *vals);
static roaring_bitmap_t *roaring_bitmap_of_ptr(size_t n_args, const uint32_t *vals);
/*
* Whether you want to use copy-on-write.
@@ -231,18 +231,18 @@ static inline void roaring_bitmap_set_copy_on_write(roaring_bitmap_t* r,
/**
* Describe the inner structure of the bitmap.
*/
void roaring_bitmap_printf_describe(const roaring_bitmap_t *r);
static void roaring_bitmap_printf_describe(const roaring_bitmap_t *r);
/**
* Creates a new bitmap from a list of uint32_t integers
*/
roaring_bitmap_t *roaring_bitmap_of(size_t n, ...);
static roaring_bitmap_t *roaring_bitmap_of(size_t n, ...);
/**
* Copies a bitmap (this does memory allocation).
* The caller is responsible for memory management.
*/
roaring_bitmap_t *roaring_bitmap_copy(const roaring_bitmap_t *r);
static roaring_bitmap_t *roaring_bitmap_copy(const roaring_bitmap_t *r);
/**
* Copies a bitmap from src to dest. It is assumed that the pointer dest
@@ -252,37 +252,37 @@ roaring_bitmap_t *roaring_bitmap_copy(const roaring_bitmap_t *r);
* It might be preferable and simpler to call roaring_bitmap_copy except
* that roaring_bitmap_overwrite can save on memory allocations.
*/
bool roaring_bitmap_overwrite(roaring_bitmap_t *dest,
static bool roaring_bitmap_overwrite(roaring_bitmap_t *dest,
const roaring_bitmap_t *src);
/**
* Print the content of the bitmap.
*/
void roaring_bitmap_printf(const roaring_bitmap_t *r);
static void roaring_bitmap_printf(const roaring_bitmap_t *r);
/**
* Computes the intersection between two bitmaps and returns new bitmap. The
* caller is responsible for memory management.
*/
roaring_bitmap_t *roaring_bitmap_and(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_and(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Computes the size of the intersection between two bitmaps.
*/
uint64_t roaring_bitmap_and_cardinality(const roaring_bitmap_t *r1,
static uint64_t roaring_bitmap_and_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Check whether two bitmaps intersect.
*/
bool roaring_bitmap_intersect(const roaring_bitmap_t *r1,
static bool roaring_bitmap_intersect(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Check whether a bitmap and a closed range intersect.
*/
bool roaring_bitmap_intersect_with_range(const roaring_bitmap_t *bm,
static bool roaring_bitmap_intersect_with_range(const roaring_bitmap_t *bm,
uint64_t x, uint64_t y);
/**
@@ -291,46 +291,46 @@ bool roaring_bitmap_intersect_with_range(const roaring_bitmap_t *bm,
*
* The Jaccard index is undefined if both bitmaps are empty.
*/
double roaring_bitmap_jaccard_index(const roaring_bitmap_t *r1,
static double roaring_bitmap_jaccard_index(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Computes the size of the union between two bitmaps.
*/
uint64_t roaring_bitmap_or_cardinality(const roaring_bitmap_t *r1,
static uint64_t roaring_bitmap_or_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Computes the size of the difference (andnot) between two bitmaps.
*/
uint64_t roaring_bitmap_andnot_cardinality(const roaring_bitmap_t *r1,
static uint64_t roaring_bitmap_andnot_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Computes the size of the symmetric difference (xor) between two bitmaps.
*/
uint64_t roaring_bitmap_xor_cardinality(const roaring_bitmap_t *r1,
static uint64_t roaring_bitmap_xor_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Inplace version of `roaring_bitmap_and()`, modifies r1
* r1 == r2 is allowed
*/
void roaring_bitmap_and_inplace(roaring_bitmap_t *r1,
static void roaring_bitmap_and_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Computes the union between two bitmaps and returns new bitmap. The caller is
* responsible for memory management.
*/
roaring_bitmap_t *roaring_bitmap_or(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_or(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Inplace version of `roaring_bitmap_or(), modifies r1.
* TODO: decide whether r1 == r2 ok
*/
void roaring_bitmap_or_inplace(roaring_bitmap_t *r1,
static void roaring_bitmap_or_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
@@ -338,7 +338,7 @@ void roaring_bitmap_or_inplace(roaring_bitmap_t *r1,
* Caller is responsible for freeing the result.
* See also `roaring_bitmap_or_many_heap()`
*/
roaring_bitmap_t *roaring_bitmap_or_many(size_t number,
static roaring_bitmap_t *roaring_bitmap_or_many(size_t number,
const roaring_bitmap_t **rs);
/**
@@ -346,40 +346,40 @@ roaring_bitmap_t *roaring_bitmap_or_many(size_t number,
* faster than `roaring_bitmap_or_many() which uses a naive algorithm.
* Caller is responsible for freeing the result.
*/
roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
static roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
const roaring_bitmap_t **rs);
/**
* Computes the symmetric difference (xor) between two bitmaps
* and returns new bitmap. The caller is responsible for memory management.
*/
roaring_bitmap_t *roaring_bitmap_xor(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_xor(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Inplace version of roaring_bitmap_xor, modifies r1, r1 != r2.
*/
void roaring_bitmap_xor_inplace(roaring_bitmap_t *r1,
static void roaring_bitmap_xor_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Compute the xor of 'number' bitmaps.
* Caller is responsible for freeing the result.
*/
roaring_bitmap_t *roaring_bitmap_xor_many(size_t number,
static roaring_bitmap_t *roaring_bitmap_xor_many(size_t number,
const roaring_bitmap_t **rs);
/**
* Computes the difference (andnot) between two bitmaps and returns new bitmap.
* Caller is responsible for freeing the result.
*/
roaring_bitmap_t *roaring_bitmap_andnot(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_andnot(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Inplace version of roaring_bitmap_andnot, modifies r1, r1 != r2.
*/
void roaring_bitmap_andnot_inplace(roaring_bitmap_t *r1,
static void roaring_bitmap_andnot_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
@@ -396,30 +396,30 @@ void roaring_bitmap_andnot_inplace(roaring_bitmap_t *r1,
/**
* Frees the memory.
*/
void roaring_bitmap_free(const roaring_bitmap_t *r);
static void roaring_bitmap_free(const roaring_bitmap_t *r);
/**
* Add value n_args from pointer vals, faster than repeatedly calling
* `roaring_bitmap_add()`
*/
void roaring_bitmap_add_many(roaring_bitmap_t *r, size_t n_args,
static void roaring_bitmap_add_many(roaring_bitmap_t *r, size_t n_args,
const uint32_t *vals);
/**
* Add value x
*/
void roaring_bitmap_add(roaring_bitmap_t *r, uint32_t x);
static void roaring_bitmap_add(roaring_bitmap_t *r, uint32_t x);
/**
* Add value x
* Returns true if a new value was added, false if the value already existed.
*/
bool roaring_bitmap_add_checked(roaring_bitmap_t *r, uint32_t x);
static bool roaring_bitmap_add_checked(roaring_bitmap_t *r, uint32_t x);
/**
* Add all values in range [min, max]
*/
void roaring_bitmap_add_range_closed(roaring_bitmap_t *r,
static void roaring_bitmap_add_range_closed(roaring_bitmap_t *r,
uint32_t min, uint32_t max);
/**
@@ -434,12 +434,12 @@ static inline void roaring_bitmap_add_range(roaring_bitmap_t *r,
/**
* Remove value x
*/
void roaring_bitmap_remove(roaring_bitmap_t *r, uint32_t x);
static void roaring_bitmap_remove(roaring_bitmap_t *r, uint32_t x);
/**
* Remove all values in range [min, max]
*/
void roaring_bitmap_remove_range_closed(roaring_bitmap_t *r,
static void roaring_bitmap_remove_range_closed(roaring_bitmap_t *r,
uint32_t min, uint32_t max);
/**
@@ -454,44 +454,44 @@ static inline void roaring_bitmap_remove_range(roaring_bitmap_t *r,
/**
* Remove multiple values
*/
void roaring_bitmap_remove_many(roaring_bitmap_t *r, size_t n_args,
static void roaring_bitmap_remove_many(roaring_bitmap_t *r, size_t n_args,
const uint32_t *vals);
/**
* Remove value x
* Returns true if a new value was removed, false if the value was not existing.
*/
bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x);
static bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x);
/**
* Check if value is present
*/
bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val);
static bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val);
/**
* Check whether a range of values from range_start (included)
* to range_end (excluded) is present
*/
bool roaring_bitmap_contains_range(const roaring_bitmap_t *r,
static bool roaring_bitmap_contains_range(const roaring_bitmap_t *r,
uint64_t range_start,
uint64_t range_end);
/**
* Get the cardinality of the bitmap (number of elements).
*/
uint64_t roaring_bitmap_get_cardinality(const roaring_bitmap_t *r);
static uint64_t roaring_bitmap_get_cardinality(const roaring_bitmap_t *r);
/**
* Returns the number of elements in the range [range_start, range_end).
*/
uint64_t roaring_bitmap_range_cardinality(const roaring_bitmap_t *r,
static uint64_t roaring_bitmap_range_cardinality(const roaring_bitmap_t *r,
uint64_t range_start,
uint64_t range_end);
/**
* Returns true if the bitmap is empty (cardinality is zero).
*/
bool roaring_bitmap_is_empty(const roaring_bitmap_t *r);
static bool roaring_bitmap_is_empty(const roaring_bitmap_t *r);
/**
@@ -499,7 +499,7 @@ bool roaring_bitmap_is_empty(const roaring_bitmap_t *r);
* was initialized in client memory via roaring_bitmap_init(), then a call to
* roaring_bitmap_clear() would be enough to "free" it)
*/
void roaring_bitmap_clear(roaring_bitmap_t *r);
static void roaring_bitmap_clear(roaring_bitmap_t *r);
/**
* Convert the bitmap to an array, output in `ans`,
@@ -508,7 +508,7 @@ void roaring_bitmap_clear(roaring_bitmap_t *r);
*
* ans = malloc(roaring_bitmap_get_cardinality(bitmap) * sizeof(uint32_t));
*/
void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *r, uint32_t *ans);
static void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *r, uint32_t *ans);
/**
@@ -520,7 +520,7 @@ void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *r, uint32_t *ans);
*
* Return false in case of failure (e.g., insufficient memory)
*/
bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *r,
static bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *r,
size_t offset, size_t limit,
uint32_t *ans);
@@ -528,7 +528,7 @@ bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *r,
* Remove run-length encoding even when it is more space efficient.
* Return whether a change was applied.
*/
bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r);
static bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r);
/**
* Convert array and bitmap containers to run containers when it is more
@@ -537,13 +537,13 @@ bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r);
* Returns true if the result has at least one run container.
* Additional savings might be possible by calling `shrinkToFit()`.
*/
bool roaring_bitmap_run_optimize(roaring_bitmap_t *r);
static bool roaring_bitmap_run_optimize(roaring_bitmap_t *r);
/**
* If needed, reallocate memory to shrink the memory usage.
* Returns the number of bytes saved.
*/
size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r);
static size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r);
/**
* Write the bitmap to an output pointer, this output buffer should refer to
@@ -555,7 +555,7 @@ size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r);
*
* Returns how many bytes written, should be `roaring_bitmap_size_in_bytes(r)`.
*/
size_t roaring_bitmap_serialize(const roaring_bitmap_t *r, char *buf);
static size_t roaring_bitmap_serialize(const roaring_bitmap_t *r, char *buf);
/**
* Use with `roaring_bitmap_serialize()`.
@@ -563,13 +563,13 @@ size_t roaring_bitmap_serialize(const roaring_bitmap_t *r, char *buf);
* (See `roaring_bitmap_portable_deserialize()` if you want a format that's
* compatible with Java and Go implementations)
*/
roaring_bitmap_t *roaring_bitmap_deserialize(const void *buf);
static roaring_bitmap_t *roaring_bitmap_deserialize(const void *buf);
/**
* How many bytes are required to serialize this bitmap (NOT compatible
* with Java and Go versions)
*/
size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *r);
static size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *r);
/**
* Read bitmap from a serialized buffer.
@@ -582,7 +582,7 @@ size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *r);
* This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec
*/
roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf);
static roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf);
/**
* Read bitmap from a serialized buffer safely (reading up to maxbytes).
@@ -591,7 +591,7 @@ roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf);
* This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec
*/
roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf,
static roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf,
size_t maxbytes);
/**
@@ -601,7 +601,7 @@ roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf,
* This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec
*/
size_t roaring_bitmap_portable_deserialize_size(const char *buf,
static size_t roaring_bitmap_portable_deserialize_size(const char *buf,
size_t maxbytes);
/**
@@ -610,7 +610,7 @@ size_t roaring_bitmap_portable_deserialize_size(const char *buf,
* This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec
*/
size_t roaring_bitmap_portable_size_in_bytes(const roaring_bitmap_t *r);
static size_t roaring_bitmap_portable_size_in_bytes(const roaring_bitmap_t *r);
/**
* Write a bitmap to a char buffer. The output buffer should refer to at least
@@ -622,7 +622,7 @@ size_t roaring_bitmap_portable_size_in_bytes(const roaring_bitmap_t *r);
* This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec
*/
size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *r, char *buf);
static size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *r, char *buf);
/*
* "Frozen" serialization format imitates memory layout of roaring_bitmap_t.
@@ -646,13 +646,13 @@ size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *r, char *buf);
/**
* Returns number of bytes required to serialize bitmap using frozen format.
*/
size_t roaring_bitmap_frozen_size_in_bytes(const roaring_bitmap_t *r);
static size_t roaring_bitmap_frozen_size_in_bytes(const roaring_bitmap_t *r);
/**
* Serializes bitmap using frozen format.
* Buffer size must be at least roaring_bitmap_frozen_size_in_bytes().
*/
void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *r, char *buf);
static void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *r, char *buf);
/**
* Creates constant bitmap that is a view of a given buffer.
@@ -665,7 +665,7 @@ void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *r, char *buf);
* Bitmap must be freed as usual, by calling roaring_bitmap_free().
* Underlying buffer must not be freed or modified while it backs any bitmaps.
*/
const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf,
static const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf,
size_t length);
/**
@@ -681,29 +681,29 @@ const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf,
*
* Iteration is ordered: from the smallest to the largest elements.
*/
bool roaring_iterate(const roaring_bitmap_t *r, roaring_iterator iterator,
static bool roaring_iterate(const roaring_bitmap_t *r, roaring_iterator iterator,
void *ptr);
bool roaring_iterate64(const roaring_bitmap_t *r, roaring_iterator64 iterator,
static bool roaring_iterate64(const roaring_bitmap_t *r, roaring_iterator64 iterator,
uint64_t high_bits, void *ptr);
/**
* Return true if the two bitmaps contain the same elements.
*/
bool roaring_bitmap_equals(const roaring_bitmap_t *r1,
static bool roaring_bitmap_equals(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Return true if all the elements of r1 are also in r2.
*/
bool roaring_bitmap_is_subset(const roaring_bitmap_t *r1,
static bool roaring_bitmap_is_subset(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
* Return true if all the elements of r1 are also in r2, and r2 is strictly
* greater than r1.
*/
bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *r1,
static bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
@@ -721,7 +721,7 @@ bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *r1,
* `bitsetconversion` is a flag which determines whether container-container
* operations force a bitset conversion.
*/
roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2,
const bool bitsetconversion);
@@ -733,7 +733,7 @@ roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *r1,
* `bitsetconversion` is a flag which determines whether container-container
* operations force a bitset conversion.
*/
void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *r1,
static void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2,
const bool bitsetconversion);
@@ -743,7 +743,7 @@ void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *r1,
* Execute maintenance on a bitmap created from `roaring_bitmap_lazy_or()`
* or modified with `roaring_bitmap_lazy_or_inplace()`.
*/
void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *r1);
static void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *r1);
/**
* Computes the symmetric difference between two bitmaps and returns new bitmap.
@@ -756,7 +756,7 @@ void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *r1);
* It is safe to repeatedly call `roaring_bitmap_lazy_xor_inplace()` on
* the result.
*/
roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
@@ -764,7 +764,7 @@ roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *r1,
*
* Inplace version of roaring_bitmap_lazy_xor, modifies r1. r1 != r2
*/
void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *r1,
static void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2);
/**
@@ -772,7 +772,7 @@ void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *r1,
* The number of negated values is range_end - range_start.
* Areas outside the range are passed through unchanged.
*/
roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *r1,
static roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *r1,
uint64_t range_start, uint64_t range_end);
/**
@@ -781,7 +781,7 @@ roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *r1,
* range_end - range_start.
* Areas outside the range are passed through unchanged.
*/
void roaring_bitmap_flip_inplace(roaring_bitmap_t *r1, uint64_t range_start,
static void roaring_bitmap_flip_inplace(roaring_bitmap_t *r1, uint64_t range_start,
uint64_t range_end);
/**
@@ -790,7 +790,7 @@ void roaring_bitmap_flip_inplace(roaring_bitmap_t *r1, uint64_t range_start,
* function returns true and sets element to the element of given rank.
* Otherwise, it returns false.
*/
bool roaring_bitmap_select(const roaring_bitmap_t *r, uint32_t rank,
static bool roaring_bitmap_select(const roaring_bitmap_t *r, uint32_t rank,
uint32_t *element);
/**
@@ -803,17 +803,17 @@ bool roaring_bitmap_select(const roaring_bitmap_t *r, uint32_t rank,
* as having index 0, whereas roaring_bitmap_rank returns 1 when ranking
* the smallest value.
*/
uint64_t roaring_bitmap_rank(const roaring_bitmap_t *r, uint32_t x);
static uint64_t roaring_bitmap_rank(const roaring_bitmap_t *r, uint32_t x);
/**
* Returns the smallest value in the set, or UINT32_MAX if the set is empty.
*/
uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *r);
static uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *r);
/**
* Returns the greatest value in the set, or 0 if the set is empty.
*/
uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *r);
static uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *r);
/**
* (For advanced users.)
@@ -821,7 +821,7 @@ uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *r);
* Collect statistics about the bitmap, see roaring_types.h for
* a description of roaring_statistics_t
*/
void roaring_bitmap_statistics(const roaring_bitmap_t *r,
static void roaring_bitmap_statistics(const roaring_bitmap_t *r,
roaring_statistics_t *stat);
/*********************
@@ -865,7 +865,7 @@ typedef struct roaring_uint32_iterator_s {
* values. If there is a value, then this iterator points to the first value
* and `it->has_value` is true. The value is in `it->current_value`.
*/
void roaring_init_iterator(const roaring_bitmap_t *r,
static void roaring_init_iterator(const roaring_bitmap_t *r,
roaring_uint32_iterator_t *newit);
/**
@@ -873,7 +873,7 @@ void roaring_init_iterator(const roaring_bitmap_t *r,
* values. If there is a value, then this iterator points to the last value
* and `it->has_value` is true. The value is in `it->current_value`.
*/
void roaring_init_iterator_last(const roaring_bitmap_t *r,
static void roaring_init_iterator_last(const roaring_bitmap_t *r,
roaring_uint32_iterator_t *newit);
/**
@@ -884,41 +884,41 @@ void roaring_init_iterator_last(const roaring_bitmap_t *r,
* If there is a value, then this iterator points to the first value and
* `it->has_value` is true. The value is in `it->current_value`.
*/
roaring_uint32_iterator_t *roaring_create_iterator(const roaring_bitmap_t *r);
static roaring_uint32_iterator_t *roaring_create_iterator(const roaring_bitmap_t *r);
/**
* Advance the iterator. If there is a new value, then `it->has_value` is true.
* The new value is in `it->current_value`. Values are traversed in increasing
* orders. For convenience, returns `it->has_value`.
*/
bool roaring_advance_uint32_iterator(roaring_uint32_iterator_t *it);
static bool roaring_advance_uint32_iterator(roaring_uint32_iterator_t *it);
/**
* Decrement the iterator. If there's a new value, then `it->has_value` is true.
* The new value is in `it->current_value`. Values are traversed in decreasing
* order. For convenience, returns `it->has_value`.
*/
bool roaring_previous_uint32_iterator(roaring_uint32_iterator_t *it);
static bool roaring_previous_uint32_iterator(roaring_uint32_iterator_t *it);
/**
* Move the iterator to the first value >= `val`. If there is a such a value,
* then `it->has_value` is true. The new value is in `it->current_value`.
* For convenience, returns `it->has_value`.
*/
bool roaring_move_uint32_iterator_equalorlarger(roaring_uint32_iterator_t *it,
static bool roaring_move_uint32_iterator_equalorlarger(roaring_uint32_iterator_t *it,
uint32_t val);
/**
* Creates a copy of an iterator.
* Caller must free it.
*/
roaring_uint32_iterator_t *roaring_copy_uint32_iterator(
static roaring_uint32_iterator_t *roaring_copy_uint32_iterator(
const roaring_uint32_iterator_t *it);
/**
* Free memory following `roaring_create_iterator()`
*/
void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it);
static void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it);
/*
* Reads next ${count} values from iterator into user-supplied ${buf}.
@@ -930,7 +930,7 @@ void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it);
* - first value is copied from ${it}->current_value
* - after function returns, iterator is positioned at the next element
*/
uint32_t roaring_read_uint32_iterator(roaring_uint32_iterator_t *it,
static uint32_t roaring_read_uint32_iterator(roaring_uint32_iterator_t *it,
uint32_t* buf, uint32_t count);
#ifdef __cplusplus
File diff suppressed because it is too large Load Diff