Update roaring bitmap code

This commit is contained in:
Luca Deri
2023-02-12 12:50:24 +01:00
parent ba4e145aad
commit bf413afba1
3 changed files with 10771 additions and 10115 deletions
-1
View File
@@ -36,7 +36,6 @@
#include "ndpi_encryption.h" #include "ndpi_encryption.h"
#include "third_party/include/roaring.h" #include "third_party/include/roaring.h"
#include "third_party/src/roaring.cc"
/* ******************************************* */ /* ******************************************* */
+279 -100
View File
@@ -1,8 +1,12 @@
// !!! DO NOT EDIT - THIS IS AN AUTO-GENERATED FILE !!! // !!! DO NOT EDIT - THIS IS AN AUTO-GENERATED FILE !!!
// Created by amalgamation.sh on Mer 25 Ago 2021 04:24:41 CEST // Created by amalgamation.sh on 2023-02-12T11:34:02Z
/* /*
* Copyright 2016-2020 The CRoaring authors * The CRoaring project is under a dual license (Apache/MIT).
* Users of the library may choose one or the other license.
*/
/*
* Copyright 2016-2022 The CRoaring authors
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -18,16 +22,47 @@
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
/*
* MIT License
*
* Copyright 2016-2022 The CRoaring authors
*
* Permission is hereby granted, free of charge, to any
* person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the
* Software without restriction, including without
* limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software
* is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice
* shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
* ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
* SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
* IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* SPDX-License-Identifier: MIT
*/
/* begin file include/roaring/roaring_version.h */ /* begin file include/roaring/roaring_version.h */
// /include/roaring/roaring_version.h automatically generated by release.py, do not change by hand // /include/roaring/roaring_version.h automatically generated by release.py, do not change by hand
#ifndef ROARING_INCLUDE_ROARING_VERSION #ifndef ROARING_INCLUDE_ROARING_VERSION
#define ROARING_INCLUDE_ROARING_VERSION #define ROARING_INCLUDE_ROARING_VERSION
#define ROARING_VERSION = 0.3.4, #define ROARING_VERSION "0.9.6"
enum { enum {
ROARING_VERSION_MAJOR = 0, ROARING_VERSION_MAJOR = 0,
ROARING_VERSION_MINOR = 3, ROARING_VERSION_MINOR = 9,
ROARING_VERSION_REVISION = 4 ROARING_VERSION_REVISION = 6
}; };
#endif // ROARING_INCLUDE_ROARING_VERSION #endif // ROARING_INCLUDE_ROARING_VERSION
/* end file include/roaring/roaring_version.h */ /* end file include/roaring/roaring_version.h */
@@ -68,12 +103,6 @@ extern "C" { namespace roaring { namespace api {
#define ROARING_CONTAINER_T void // no compile-time checking #define ROARING_CONTAINER_T void // no compile-time checking
#endif #endif
#define MAX_CONTAINERS 65536
#define SERIALIZATION_ARRAY_UINT32 1
#define SERIALIZATION_CONTAINER 2
#define ROARING_FLAG_COW UINT8_C(0x1) #define ROARING_FLAG_COW UINT8_C(0x1)
#define ROARING_FLAG_FROZEN UINT8_C(0x2) #define ROARING_FLAG_FROZEN UINT8_C(0x2)
@@ -170,7 +199,7 @@ typedef struct roaring_bitmap_s {
* Capacity is a performance hint for how many "containers" the data will need. * Capacity is a performance hint for how many "containers" the data will need.
* Client is responsible for calling `roaring_bitmap_free()`. * Client is responsible for calling `roaring_bitmap_free()`.
*/ */
static roaring_bitmap_t *roaring_bitmap_create_with_capacity(uint32_t cap); roaring_bitmap_t *roaring_bitmap_create_with_capacity(uint32_t cap);
/** /**
* Dynamically allocates a new bitmap (initially empty). * Dynamically allocates a new bitmap (initially empty).
@@ -185,7 +214,7 @@ static inline roaring_bitmap_t *roaring_bitmap_create(void)
* Capacity is a performance hint for how many "containers" the data will need. * 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. * Can return false if auxiliary allocations fail when capacity greater than 0.
*/ */
static bool roaring_bitmap_init_with_capacity(roaring_bitmap_t *r, uint32_t cap); bool roaring_bitmap_init_with_capacity(roaring_bitmap_t *r, uint32_t cap);
/** /**
* Initialize a roaring bitmap structure in memory controlled by client. * Initialize a roaring bitmap structure in memory controlled by client.
@@ -199,13 +228,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 * Add all the values between min (included) and max (excluded) that are at a
* distance k*step from min. * distance k*step from min.
*/ */
static roaring_bitmap_t *roaring_bitmap_from_range(uint64_t min, uint64_t max, roaring_bitmap_t *roaring_bitmap_from_range(uint64_t min, uint64_t max,
uint32_t step); uint32_t step);
/** /**
* Creates a new bitmap from a pointer of uint32_t integers * Creates a new bitmap from a pointer of uint32_t integers
*/ */
static roaring_bitmap_t *roaring_bitmap_of_ptr(size_t n_args, const uint32_t *vals); roaring_bitmap_t *roaring_bitmap_of_ptr(size_t n_args, const uint32_t *vals);
/* /*
* Whether you want to use copy-on-write. * Whether you want to use copy-on-write.
@@ -228,21 +257,23 @@ static inline void roaring_bitmap_set_copy_on_write(roaring_bitmap_t* r,
} }
} }
roaring_bitmap_t *roaring_bitmap_add_offset(const roaring_bitmap_t *bm,
int64_t offset);
/** /**
* Describe the inner structure of the bitmap. * Describe the inner structure of the bitmap.
*/ */
static void roaring_bitmap_printf_describe(const roaring_bitmap_t *r); void roaring_bitmap_printf_describe(const roaring_bitmap_t *r);
/** /**
* Creates a new bitmap from a list of uint32_t integers * Creates a new bitmap from a list of uint32_t integers
*/ */
static roaring_bitmap_t *roaring_bitmap_of(size_t n, ...); roaring_bitmap_t *roaring_bitmap_of(size_t n, ...);
/** /**
* Copies a bitmap (this does memory allocation). * Copies a bitmap (this does memory allocation).
* The caller is responsible for memory management. * The caller is responsible for memory management.
*/ */
static roaring_bitmap_t *roaring_bitmap_copy(const roaring_bitmap_t *r); 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 * Copies a bitmap from src to dest. It is assumed that the pointer dest
@@ -252,37 +283,42 @@ static roaring_bitmap_t *roaring_bitmap_copy(const roaring_bitmap_t *r);
* It might be preferable and simpler to call roaring_bitmap_copy except * It might be preferable and simpler to call roaring_bitmap_copy except
* that roaring_bitmap_overwrite can save on memory allocations. * that roaring_bitmap_overwrite can save on memory allocations.
*/ */
static bool roaring_bitmap_overwrite(roaring_bitmap_t *dest, bool roaring_bitmap_overwrite(roaring_bitmap_t *dest,
const roaring_bitmap_t *src); const roaring_bitmap_t *src);
/** /**
* Print the content of the bitmap. * Print the content of the bitmap.
*/ */
static void roaring_bitmap_printf(const roaring_bitmap_t *r); void roaring_bitmap_printf(const roaring_bitmap_t *r);
/** /**
* Computes the intersection between two bitmaps and returns new bitmap. The * Computes the intersection between two bitmaps and returns new bitmap. The
* caller is responsible for memory management. * caller is responsible for memory management.
*
* Performance hint: if you are computing the intersection between several
* bitmaps, two-by-two, it is best to start with the smallest bitmap.
* You may also rely on roaring_bitmap_and_inplace to avoid creating
* many temporary bitmaps.
*/ */
static roaring_bitmap_t *roaring_bitmap_and(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_and(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Computes the size of the intersection between two bitmaps. * Computes the size of the intersection between two bitmaps.
*/ */
static uint64_t roaring_bitmap_and_cardinality(const roaring_bitmap_t *r1, uint64_t roaring_bitmap_and_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Check whether two bitmaps intersect. * Check whether two bitmaps intersect.
*/ */
static bool roaring_bitmap_intersect(const roaring_bitmap_t *r1, bool roaring_bitmap_intersect(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Check whether a bitmap and a closed range intersect. * Check whether a bitmap and a closed range intersect.
*/ */
static bool roaring_bitmap_intersect_with_range(const roaring_bitmap_t *bm, bool roaring_bitmap_intersect_with_range(const roaring_bitmap_t *bm,
uint64_t x, uint64_t y); uint64_t x, uint64_t y);
/** /**
@@ -291,46 +327,49 @@ static bool roaring_bitmap_intersect_with_range(const roaring_bitmap_t *bm,
* *
* The Jaccard index is undefined if both bitmaps are empty. * The Jaccard index is undefined if both bitmaps are empty.
*/ */
static double roaring_bitmap_jaccard_index(const roaring_bitmap_t *r1, double roaring_bitmap_jaccard_index(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Computes the size of the union between two bitmaps. * Computes the size of the union between two bitmaps.
*/ */
static uint64_t roaring_bitmap_or_cardinality(const roaring_bitmap_t *r1, uint64_t roaring_bitmap_or_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Computes the size of the difference (andnot) between two bitmaps. * Computes the size of the difference (andnot) between two bitmaps.
*/ */
static uint64_t roaring_bitmap_andnot_cardinality(const roaring_bitmap_t *r1, uint64_t roaring_bitmap_andnot_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Computes the size of the symmetric difference (xor) between two bitmaps. * Computes the size of the symmetric difference (xor) between two bitmaps.
*/ */
static uint64_t roaring_bitmap_xor_cardinality(const roaring_bitmap_t *r1, uint64_t roaring_bitmap_xor_cardinality(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Inplace version of `roaring_bitmap_and()`, modifies r1 * Inplace version of `roaring_bitmap_and()`, modifies r1
* r1 == r2 is allowed * r1 == r2 is allowed.
*
* Performance hint: if you are computing the intersection between several
* bitmaps, two-by-two, it is best to start with the smallest bitmap.
*/ */
static void roaring_bitmap_and_inplace(roaring_bitmap_t *r1, void roaring_bitmap_and_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Computes the union between two bitmaps and returns new bitmap. The caller is * Computes the union between two bitmaps and returns new bitmap. The caller is
* responsible for memory management. * responsible for memory management.
*/ */
static roaring_bitmap_t *roaring_bitmap_or(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_or(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Inplace version of `roaring_bitmap_or(), modifies r1. * Inplace version of `roaring_bitmap_or(), modifies r1.
* TODO: decide whether r1 == r2 ok * TODO: decide whether r1 == r2 ok
*/ */
static void roaring_bitmap_or_inplace(roaring_bitmap_t *r1, void roaring_bitmap_or_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
@@ -338,7 +377,7 @@ static void roaring_bitmap_or_inplace(roaring_bitmap_t *r1,
* Caller is responsible for freeing the result. * Caller is responsible for freeing the result.
* See also `roaring_bitmap_or_many_heap()` * See also `roaring_bitmap_or_many_heap()`
*/ */
static roaring_bitmap_t *roaring_bitmap_or_many(size_t number, roaring_bitmap_t *roaring_bitmap_or_many(size_t number,
const roaring_bitmap_t **rs); const roaring_bitmap_t **rs);
/** /**
@@ -346,40 +385,40 @@ static roaring_bitmap_t *roaring_bitmap_or_many(size_t number,
* faster than `roaring_bitmap_or_many() which uses a naive algorithm. * faster than `roaring_bitmap_or_many() which uses a naive algorithm.
* Caller is responsible for freeing the result. * Caller is responsible for freeing the result.
*/ */
static roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number, roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
const roaring_bitmap_t **rs); const roaring_bitmap_t **rs);
/** /**
* Computes the symmetric difference (xor) between two bitmaps * Computes the symmetric difference (xor) between two bitmaps
* and returns new bitmap. The caller is responsible for memory management. * and returns new bitmap. The caller is responsible for memory management.
*/ */
static roaring_bitmap_t *roaring_bitmap_xor(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_xor(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Inplace version of roaring_bitmap_xor, modifies r1, r1 != r2. * Inplace version of roaring_bitmap_xor, modifies r1, r1 != r2.
*/ */
static void roaring_bitmap_xor_inplace(roaring_bitmap_t *r1, void roaring_bitmap_xor_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Compute the xor of 'number' bitmaps. * Compute the xor of 'number' bitmaps.
* Caller is responsible for freeing the result. * Caller is responsible for freeing the result.
*/ */
static roaring_bitmap_t *roaring_bitmap_xor_many(size_t number, roaring_bitmap_t *roaring_bitmap_xor_many(size_t number,
const roaring_bitmap_t **rs); const roaring_bitmap_t **rs);
/** /**
* Computes the difference (andnot) between two bitmaps and returns new bitmap. * Computes the difference (andnot) between two bitmaps and returns new bitmap.
* Caller is responsible for freeing the result. * Caller is responsible for freeing the result.
*/ */
static roaring_bitmap_t *roaring_bitmap_andnot(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_andnot(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Inplace version of roaring_bitmap_andnot, modifies r1, r1 != r2. * Inplace version of roaring_bitmap_andnot, modifies r1, r1 != r2.
*/ */
static void roaring_bitmap_andnot_inplace(roaring_bitmap_t *r1, void roaring_bitmap_andnot_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
@@ -396,30 +435,69 @@ static void roaring_bitmap_andnot_inplace(roaring_bitmap_t *r1,
/** /**
* Frees the memory. * Frees the memory.
*/ */
static void roaring_bitmap_free(const roaring_bitmap_t *r); void roaring_bitmap_free(const roaring_bitmap_t *r);
/**
* A bit of context usable with `roaring_bitmap_*_bulk()` functions
*
* Should be initialized with `{0}` (or `memset()` to all zeros).
* Callers should treat it as an opaque type.
*
* A context may only be used with a single bitmap
* (unless re-initialized to zero), and any modification to a bitmap
* (other than modifications performed with `_bulk()` functions with the context
* passed) will invalidate any contexts associated with that bitmap.
*/
typedef struct roaring_bulk_context_s {
ROARING_CONTAINER_T *container;
int idx;
uint16_t key;
uint8_t typecode;
} roaring_bulk_context_t;
/**
* Add an item, using context from a previous insert for speed optimization.
*
* `context` will be used to store information between calls to make bulk
* operations faster. `*context` should be zero-initialized before the first
* call to this function.
*
* Modifying the bitmap in any way (other than `-bulk` suffixed functions)
* will invalidate the stored context, calling this function with a non-zero
* context after doing any modification invokes undefined behavior.
*
* In order to exploit this optimization, the caller should call this function
* with values with the same "key" (high 16 bits of the value) consecutively.
*/
void roaring_bitmap_add_bulk(roaring_bitmap_t *r,
roaring_bulk_context_t *context, uint32_t val);
/** /**
* Add value n_args from pointer vals, faster than repeatedly calling * Add value n_args from pointer vals, faster than repeatedly calling
* `roaring_bitmap_add()` * `roaring_bitmap_add()`
*
* In order to exploit this optimization, the caller should attempt to keep
* values with the same "key" (high 16 bits of the value) as consecutive
* elements in `vals`
*/ */
static void roaring_bitmap_add_many(roaring_bitmap_t *r, size_t n_args, void roaring_bitmap_add_many(roaring_bitmap_t *r, size_t n_args,
const uint32_t *vals); const uint32_t *vals);
/** /**
* Add value x * Add value x
*/ */
static void roaring_bitmap_add(roaring_bitmap_t *r, uint32_t x); void roaring_bitmap_add(roaring_bitmap_t *r, uint32_t x);
/** /**
* Add value x * Add value x
* Returns true if a new value was added, false if the value already existed. * Returns true if a new value was added, false if the value already existed.
*/ */
static bool roaring_bitmap_add_checked(roaring_bitmap_t *r, uint32_t x); bool roaring_bitmap_add_checked(roaring_bitmap_t *r, uint32_t x);
/** /**
* Add all values in range [min, max] * Add all values in range [min, max]
*/ */
static void roaring_bitmap_add_range_closed(roaring_bitmap_t *r, void roaring_bitmap_add_range_closed(roaring_bitmap_t *r,
uint32_t min, uint32_t max); uint32_t min, uint32_t max);
/** /**
@@ -434,12 +512,12 @@ static inline void roaring_bitmap_add_range(roaring_bitmap_t *r,
/** /**
* Remove value x * Remove value x
*/ */
static void roaring_bitmap_remove(roaring_bitmap_t *r, uint32_t x); void roaring_bitmap_remove(roaring_bitmap_t *r, uint32_t x);
/** /**
* Remove all values in range [min, max] * Remove all values in range [min, max]
*/ */
static void roaring_bitmap_remove_range_closed(roaring_bitmap_t *r, void roaring_bitmap_remove_range_closed(roaring_bitmap_t *r,
uint32_t min, uint32_t max); uint32_t min, uint32_t max);
/** /**
@@ -454,44 +532,63 @@ static inline void roaring_bitmap_remove_range(roaring_bitmap_t *r,
/** /**
* Remove multiple values * Remove multiple values
*/ */
static void roaring_bitmap_remove_many(roaring_bitmap_t *r, size_t n_args, void roaring_bitmap_remove_many(roaring_bitmap_t *r, size_t n_args,
const uint32_t *vals); const uint32_t *vals);
/** /**
* Remove value x * Remove value x
* Returns true if a new value was removed, false if the value was not existing. * Returns true if a new value was removed, false if the value was not existing.
*/ */
static bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x); bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x);
/** /**
* Check if value is present * Check if value is present
*/ */
static bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val); bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val);
/** /**
* Check whether a range of values from range_start (included) * Check whether a range of values from range_start (included)
* to range_end (excluded) is present * to range_end (excluded) is present
*/ */
static bool roaring_bitmap_contains_range(const roaring_bitmap_t *r, bool roaring_bitmap_contains_range(const roaring_bitmap_t *r,
uint64_t range_start, uint64_t range_start,
uint64_t range_end); uint64_t range_end);
/**
* Check if an items is present, using context from a previous insert for speed
* optimization.
*
* `context` will be used to store information between calls to make bulk
* operations faster. `*context` should be zero-initialized before the first
* call to this function.
*
* Modifying the bitmap in any way (other than `-bulk` suffixed functions)
* will invalidate the stored context, calling this function with a non-zero
* context after doing any modification invokes undefined behavior.
*
* In order to exploit this optimization, the caller should call this function
* with values with the same "key" (high 16 bits of the value) consecutively.
*/
bool roaring_bitmap_contains_bulk(const roaring_bitmap_t *r,
roaring_bulk_context_t *context,
uint32_t val);
/** /**
* Get the cardinality of the bitmap (number of elements). * Get the cardinality of the bitmap (number of elements).
*/ */
static uint64_t roaring_bitmap_get_cardinality(const roaring_bitmap_t *r); uint64_t roaring_bitmap_get_cardinality(const roaring_bitmap_t *r);
/** /**
* Returns the number of elements in the range [range_start, range_end). * Returns the number of elements in the range [range_start, range_end).
*/ */
static uint64_t roaring_bitmap_range_cardinality(const roaring_bitmap_t *r, uint64_t roaring_bitmap_range_cardinality(const roaring_bitmap_t *r,
uint64_t range_start, uint64_t range_start,
uint64_t range_end); uint64_t range_end);
/** /**
* Returns true if the bitmap is empty (cardinality is zero). * Returns true if the bitmap is empty (cardinality is zero).
*/ */
static bool roaring_bitmap_is_empty(const roaring_bitmap_t *r); bool roaring_bitmap_is_empty(const roaring_bitmap_t *r);
/** /**
@@ -499,20 +596,20 @@ static bool roaring_bitmap_is_empty(const roaring_bitmap_t *r);
* was initialized in client memory via roaring_bitmap_init(), then a call to * was initialized in client memory via roaring_bitmap_init(), then a call to
* roaring_bitmap_clear() would be enough to "free" it) * roaring_bitmap_clear() would be enough to "free" it)
*/ */
static void roaring_bitmap_clear(roaring_bitmap_t *r); void roaring_bitmap_clear(roaring_bitmap_t *r);
/** /**
* Convert the bitmap to an array, output in `ans`, * Convert the bitmap to a sorted array, output in `ans`.
* *
* Caller is responsible to ensure that there is enough memory allocated, e.g. * Caller is responsible to ensure that there is enough memory allocated, e.g.
* *
* ans = malloc(roaring_bitmap_get_cardinality(bitmap) * sizeof(uint32_t)); * ans = malloc(roaring_bitmap_get_cardinality(bitmap) * sizeof(uint32_t));
*/ */
static void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *r, uint32_t *ans); void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *r, uint32_t *ans);
/** /**
* Convert the bitmap to an array from `offset` by `limit`, output in `ans`. * Convert the bitmap to a sorted array from `offset` by `limit`, output in `ans`.
* *
* Caller is responsible to ensure that there is enough memory allocated, e.g. * Caller is responsible to ensure that there is enough memory allocated, e.g.
* *
@@ -520,7 +617,7 @@ static void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *r, uint32_t *
* *
* Return false in case of failure (e.g., insufficient memory) * Return false in case of failure (e.g., insufficient memory)
*/ */
static bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *r, bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *r,
size_t offset, size_t limit, size_t offset, size_t limit,
uint32_t *ans); uint32_t *ans);
@@ -528,7 +625,7 @@ static bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *r,
* Remove run-length encoding even when it is more space efficient. * Remove run-length encoding even when it is more space efficient.
* Return whether a change was applied. * Return whether a change was applied.
*/ */
static bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r); bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r);
/** /**
* Convert array and bitmap containers to run containers when it is more * Convert array and bitmap containers to run containers when it is more
@@ -537,13 +634,13 @@ static bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r);
* Returns true if the result has at least one run container. * Returns true if the result has at least one run container.
* Additional savings might be possible by calling `shrinkToFit()`. * Additional savings might be possible by calling `shrinkToFit()`.
*/ */
static bool roaring_bitmap_run_optimize(roaring_bitmap_t *r); bool roaring_bitmap_run_optimize(roaring_bitmap_t *r);
/** /**
* If needed, reallocate memory to shrink the memory usage. * If needed, reallocate memory to shrink the memory usage.
* Returns the number of bytes saved. * Returns the number of bytes saved.
*/ */
static size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r); size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r);
/** /**
* Write the bitmap to an output pointer, this output buffer should refer to * Write the bitmap to an output pointer, this output buffer should refer to
@@ -554,22 +651,28 @@ static size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r);
* more space efficient than the portable form, e.g. when the data is sparse. * more space efficient than the portable form, e.g. when the data is sparse.
* *
* Returns how many bytes written, should be `roaring_bitmap_size_in_bytes(r)`. * Returns how many bytes written, should be `roaring_bitmap_size_in_bytes(r)`.
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static size_t roaring_bitmap_serialize(const roaring_bitmap_t *r, char *buf); size_t roaring_bitmap_serialize(const roaring_bitmap_t *r, char *buf);
/** /**
* Use with `roaring_bitmap_serialize()`. * Use with `roaring_bitmap_serialize()`.
* *
* (See `roaring_bitmap_portable_deserialize()` if you want a format that's * (See `roaring_bitmap_portable_deserialize()` if you want a format that's
* compatible with Java and Go implementations) * compatible with Java and Go implementations).
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static roaring_bitmap_t *roaring_bitmap_deserialize(const void *buf); roaring_bitmap_t *roaring_bitmap_deserialize(const void *buf);
/** /**
* How many bytes are required to serialize this bitmap (NOT compatible * How many bytes are required to serialize this bitmap (NOT compatible
* with Java and Go versions) * with Java and Go versions)
*/ */
static size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *r); size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *r);
/** /**
* Read bitmap from a serialized buffer. * Read bitmap from a serialized buffer.
@@ -581,8 +684,11 @@ static size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *r);
* *
* This is meant to be compatible with the Java and Go versions: * This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec * https://github.com/RoaringBitmap/RoaringFormatSpec
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf); roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf);
/** /**
* Read bitmap from a serialized buffer safely (reading up to maxbytes). * Read bitmap from a serialized buffer safely (reading up to maxbytes).
@@ -590,10 +696,34 @@ static roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf);
* *
* This is meant to be compatible with the Java and Go versions: * This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec * https://github.com/RoaringBitmap/RoaringFormatSpec
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf, roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf,
size_t maxbytes); size_t maxbytes);
/**
* Read bitmap from a serialized buffer.
* In case of failure, NULL is returned.
*
* Bitmap returned by this function can be used in all readonly contexts.
* Bitmap must be freed as usual, by calling roaring_bitmap_free().
* Underlying buffer must not be freed or modified while it backs any bitmaps.
*
* The function is unsafe in the following ways:
* 1) It may execute unaligned memory accesses.
* 2) A buffer overflow may occur if buf does not point to a valid serialized
* bitmap.
*
* This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/
roaring_bitmap_t *roaring_bitmap_portable_deserialize_frozen(const char *buf);
/** /**
* Check how many bytes would be read (up to maxbytes) at this pointer if there * Check how many bytes would be read (up to maxbytes) at this pointer if there
* is a bitmap, returns zero if there is no valid bitmap. * is a bitmap, returns zero if there is no valid bitmap.
@@ -601,7 +731,7 @@ static roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *bu
* This is meant to be compatible with the Java and Go versions: * This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec * https://github.com/RoaringBitmap/RoaringFormatSpec
*/ */
static size_t roaring_bitmap_portable_deserialize_size(const char *buf, size_t roaring_bitmap_portable_deserialize_size(const char *buf,
size_t maxbytes); size_t maxbytes);
/** /**
@@ -610,7 +740,7 @@ static size_t roaring_bitmap_portable_deserialize_size(const char *buf,
* This is meant to be compatible with the Java and Go versions: * This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec * https://github.com/RoaringBitmap/RoaringFormatSpec
*/ */
static size_t roaring_bitmap_portable_size_in_bytes(const roaring_bitmap_t *r); 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 * Write a bitmap to a char buffer. The output buffer should refer to at least
@@ -621,8 +751,11 @@ static 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: * This is meant to be compatible with the Java and Go versions:
* https://github.com/RoaringBitmap/RoaringFormatSpec * https://github.com/RoaringBitmap/RoaringFormatSpec
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *r, char *buf); size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *r, char *buf);
/* /*
* "Frozen" serialization format imitates memory layout of roaring_bitmap_t. * "Frozen" serialization format imitates memory layout of roaring_bitmap_t.
@@ -646,13 +779,16 @@ static size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *r, char
/** /**
* Returns number of bytes required to serialize bitmap using frozen format. * Returns number of bytes required to serialize bitmap using frozen format.
*/ */
static size_t roaring_bitmap_frozen_size_in_bytes(const roaring_bitmap_t *r); size_t roaring_bitmap_frozen_size_in_bytes(const roaring_bitmap_t *r);
/** /**
* Serializes bitmap using frozen format. * Serializes bitmap using frozen format.
* Buffer size must be at least roaring_bitmap_frozen_size_in_bytes(). * Buffer size must be at least roaring_bitmap_frozen_size_in_bytes().
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *r, char *buf); void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *r, char *buf);
/** /**
* Creates constant bitmap that is a view of a given buffer. * Creates constant bitmap that is a view of a given buffer.
@@ -664,8 +800,11 @@ static void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *r, char *buf
* Bitmap returned by this function can be used in all readonly contexts. * Bitmap returned by this function can be used in all readonly contexts.
* Bitmap must be freed as usual, by calling roaring_bitmap_free(). * Bitmap must be freed as usual, by calling roaring_bitmap_free().
* Underlying buffer must not be freed or modified while it backs any bitmaps. * Underlying buffer must not be freed or modified while it backs any bitmaps.
*
* This function is endian-sensitive. If you have a big-endian system (e.g., a mainframe IBM s390x),
* the data format is going to be big-endian and not compatible with little-endian systems.
*/ */
static const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf, const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf,
size_t length); size_t length);
/** /**
@@ -681,29 +820,29 @@ static const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf,
* *
* Iteration is ordered: from the smallest to the largest elements. * Iteration is ordered: from the smallest to the largest elements.
*/ */
static bool roaring_iterate(const roaring_bitmap_t *r, roaring_iterator iterator, bool roaring_iterate(const roaring_bitmap_t *r, roaring_iterator iterator,
void *ptr); void *ptr);
static bool roaring_iterate64(const roaring_bitmap_t *r, roaring_iterator64 iterator, bool roaring_iterate64(const roaring_bitmap_t *r, roaring_iterator64 iterator,
uint64_t high_bits, void *ptr); uint64_t high_bits, void *ptr);
/** /**
* Return true if the two bitmaps contain the same elements. * Return true if the two bitmaps contain the same elements.
*/ */
static bool roaring_bitmap_equals(const roaring_bitmap_t *r1, bool roaring_bitmap_equals(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Return true if all the elements of r1 are also in r2. * Return true if all the elements of r1 are also in r2.
*/ */
static bool roaring_bitmap_is_subset(const roaring_bitmap_t *r1, bool roaring_bitmap_is_subset(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
* Return true if all the elements of r1 are also in r2, and r2 is strictly * Return true if all the elements of r1 are also in r2, and r2 is strictly
* greater than r1. * greater than r1.
*/ */
static bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *r1, bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
@@ -721,7 +860,7 @@ static bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *r1,
* `bitsetconversion` is a flag which determines whether container-container * `bitsetconversion` is a flag which determines whether container-container
* operations force a bitset conversion. * operations force a bitset conversion.
*/ */
static roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2, const roaring_bitmap_t *r2,
const bool bitsetconversion); const bool bitsetconversion);
@@ -733,7 +872,7 @@ static roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *r1,
* `bitsetconversion` is a flag which determines whether container-container * `bitsetconversion` is a flag which determines whether container-container
* operations force a bitset conversion. * operations force a bitset conversion.
*/ */
static void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *r1, void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2, const roaring_bitmap_t *r2,
const bool bitsetconversion); const bool bitsetconversion);
@@ -743,7 +882,7 @@ static void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *r1,
* Execute maintenance on a bitmap created from `roaring_bitmap_lazy_or()` * Execute maintenance on a bitmap created from `roaring_bitmap_lazy_or()`
* or modified with `roaring_bitmap_lazy_or_inplace()`. * or modified with `roaring_bitmap_lazy_or_inplace()`.
*/ */
static void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *r1); void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *r1);
/** /**
* Computes the symmetric difference between two bitmaps and returns new bitmap. * Computes the symmetric difference between two bitmaps and returns new bitmap.
@@ -756,7 +895,7 @@ static void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *r1);
* It is safe to repeatedly call `roaring_bitmap_lazy_xor_inplace()` on * It is safe to repeatedly call `roaring_bitmap_lazy_xor_inplace()` on
* the result. * the result.
*/ */
static roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
@@ -764,7 +903,7 @@ static roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *r1,
* *
* Inplace version of roaring_bitmap_lazy_xor, modifies r1. r1 != r2 * Inplace version of roaring_bitmap_lazy_xor, modifies r1. r1 != r2
*/ */
static void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *r1, void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *r1,
const roaring_bitmap_t *r2); const roaring_bitmap_t *r2);
/** /**
@@ -772,7 +911,7 @@ static void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *r1,
* The number of negated values is range_end - range_start. * The number of negated values is range_end - range_start.
* Areas outside the range are passed through unchanged. * Areas outside the range are passed through unchanged.
*/ */
static roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *r1, roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *r1,
uint64_t range_start, uint64_t range_end); uint64_t range_start, uint64_t range_end);
/** /**
@@ -781,7 +920,7 @@ static roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *r1,
* range_end - range_start. * range_end - range_start.
* Areas outside the range are passed through unchanged. * Areas outside the range are passed through unchanged.
*/ */
static void roaring_bitmap_flip_inplace(roaring_bitmap_t *r1, uint64_t range_start, void roaring_bitmap_flip_inplace(roaring_bitmap_t *r1, uint64_t range_start,
uint64_t range_end); uint64_t range_end);
/** /**
@@ -790,7 +929,7 @@ static void roaring_bitmap_flip_inplace(roaring_bitmap_t *r1, uint64_t range_sta
* function returns true and sets element to the element of given rank. * function returns true and sets element to the element of given rank.
* Otherwise, it returns false. * Otherwise, it returns false.
*/ */
static bool roaring_bitmap_select(const roaring_bitmap_t *r, uint32_t rank, bool roaring_bitmap_select(const roaring_bitmap_t *r, uint32_t rank,
uint32_t *element); uint32_t *element);
/** /**
@@ -803,17 +942,17 @@ static bool roaring_bitmap_select(const roaring_bitmap_t *r, uint32_t rank,
* as having index 0, whereas roaring_bitmap_rank returns 1 when ranking * as having index 0, whereas roaring_bitmap_rank returns 1 when ranking
* the smallest value. * the smallest value.
*/ */
static uint64_t roaring_bitmap_rank(const roaring_bitmap_t *r, uint32_t x); 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. * Returns the smallest value in the set, or UINT32_MAX if the set is empty.
*/ */
static uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *r); uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *r);
/** /**
* Returns the greatest value in the set, or 0 if the set is empty. * Returns the greatest value in the set, or 0 if the set is empty.
*/ */
static uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *r); uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *r);
/** /**
* (For advanced users.) * (For advanced users.)
@@ -821,7 +960,7 @@ static uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *r);
* Collect statistics about the bitmap, see roaring_types.h for * Collect statistics about the bitmap, see roaring_types.h for
* a description of roaring_statistics_t * a description of roaring_statistics_t
*/ */
static void roaring_bitmap_statistics(const roaring_bitmap_t *r, void roaring_bitmap_statistics(const roaring_bitmap_t *r,
roaring_statistics_t *stat); roaring_statistics_t *stat);
/********************* /*********************
@@ -865,7 +1004,7 @@ typedef struct roaring_uint32_iterator_s {
* values. If there is a value, then this iterator points to the first value * 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`. * and `it->has_value` is true. The value is in `it->current_value`.
*/ */
static void roaring_init_iterator(const roaring_bitmap_t *r, void roaring_init_iterator(const roaring_bitmap_t *r,
roaring_uint32_iterator_t *newit); roaring_uint32_iterator_t *newit);
/** /**
@@ -873,7 +1012,7 @@ static void roaring_init_iterator(const roaring_bitmap_t *r,
* values. If there is a value, then this iterator points to the last value * 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`. * and `it->has_value` is true. The value is in `it->current_value`.
*/ */
static void roaring_init_iterator_last(const roaring_bitmap_t *r, void roaring_init_iterator_last(const roaring_bitmap_t *r,
roaring_uint32_iterator_t *newit); roaring_uint32_iterator_t *newit);
/** /**
@@ -884,41 +1023,41 @@ static void roaring_init_iterator_last(const roaring_bitmap_t *r,
* If there is a value, then this iterator points to the first value and * 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`. * `it->has_value` is true. The value is in `it->current_value`.
*/ */
static roaring_uint32_iterator_t *roaring_create_iterator(const roaring_bitmap_t *r); 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. * 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 * The new value is in `it->current_value`. Values are traversed in increasing
* orders. For convenience, returns `it->has_value`. * orders. For convenience, returns `it->has_value`.
*/ */
static bool roaring_advance_uint32_iterator(roaring_uint32_iterator_t *it); 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. * 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 * The new value is in `it->current_value`. Values are traversed in decreasing
* order. For convenience, returns `it->has_value`. * order. For convenience, returns `it->has_value`.
*/ */
static bool roaring_previous_uint32_iterator(roaring_uint32_iterator_t *it); 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, * 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`. * then `it->has_value` is true. The new value is in `it->current_value`.
* For convenience, returns `it->has_value`. * For convenience, returns `it->has_value`.
*/ */
static bool roaring_move_uint32_iterator_equalorlarger(roaring_uint32_iterator_t *it, bool roaring_move_uint32_iterator_equalorlarger(roaring_uint32_iterator_t *it,
uint32_t val); uint32_t val);
/** /**
* Creates a copy of an iterator. * Creates a copy of an iterator.
* Caller must free it. * Caller must free it.
*/ */
static roaring_uint32_iterator_t *roaring_copy_uint32_iterator( roaring_uint32_iterator_t *roaring_copy_uint32_iterator(
const roaring_uint32_iterator_t *it); const roaring_uint32_iterator_t *it);
/** /**
* Free memory following `roaring_create_iterator()` * Free memory following `roaring_create_iterator()`
*/ */
static void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it); void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it);
/* /*
* Reads next ${count} values from iterator into user-supplied ${buf}. * Reads next ${count} values from iterator into user-supplied ${buf}.
@@ -930,7 +1069,7 @@ static void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it);
* - first value is copied from ${it}->current_value * - first value is copied from ${it}->current_value
* - after function returns, iterator is positioned at the next element * - after function returns, iterator is positioned at the next element
*/ */
static uint32_t roaring_read_uint32_iterator(roaring_uint32_iterator_t *it, uint32_t roaring_read_uint32_iterator(roaring_uint32_iterator_t *it,
uint32_t* buf, uint32_t count); uint32_t* buf, uint32_t count);
#ifdef __cplusplus #ifdef __cplusplus
@@ -955,5 +1094,45 @@ static uint32_t roaring_read_uint32_iterator(roaring_uint32_iterator_t *it,
using namespace ::roaring::api; using namespace ::roaring::api;
#endif #endif
#endif #endif
/* end file include/roaring/roaring.h */ /* end file include/roaring/roaring.h */
/* begin file include/roaring/memory.h */
#ifndef INCLUDE_ROARING_MEMORY_H_
#define INCLUDE_ROARING_MEMORY_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h> // for size_t
typedef void* (*roaring_malloc_p)(size_t);
typedef void* (*roaring_realloc_p)(void*, size_t);
typedef void* (*roaring_calloc_p)(size_t, size_t);
typedef void (*roaring_free_p)(void*);
typedef void* (*roaring_aligned_malloc_p)(size_t, size_t);
typedef void (*roaring_aligned_free_p)(void*);
typedef struct roaring_memory_s {
roaring_malloc_p malloc;
roaring_realloc_p realloc;
roaring_calloc_p calloc;
roaring_free_p free;
roaring_aligned_malloc_p aligned_malloc;
roaring_aligned_free_p aligned_free;
} roaring_memory_t;
void roaring_init_memory_hook(roaring_memory_t memory_hook);
void* roaring_malloc(size_t);
void* roaring_realloc(void*, size_t);
void* roaring_calloc(size_t, size_t);
void roaring_free(void*);
void* roaring_aligned_malloc(size_t, size_t);
void roaring_aligned_free(void*);
#ifdef __cplusplus
}
#endif
#endif // INCLUDE_ROARING_MEMORY_H_
/* end file include/roaring/memory.h */
File diff suppressed because it is too large Load Diff