JError_t err;
const char *errstr;
};
-const char *COLD_ATTRIBUTE jbit_error_(struct jbitset *set);
+const char *COLD jbit_error_(struct jbitset *set);
/**
* jbit_error - test for an error in the a previous jbit_ operation.
* Example:
* assert(!jbit_test(set, 0));
*/
-static inline bool jbit_test(const struct jbitset *set, size_t index)
+static inline bool jbit_test(const struct jbitset *set, unsigned long index)
{
return Judy1Test(set->judy, index, (JError_t *)&set->err);
}
* if (jbit_set(set, 0))
* err(1, "Bit 0 was already set?!");
*/
-static inline bool jbit_set(struct jbitset *set, size_t index)
+static inline bool jbit_set(struct jbitset *set, unsigned long index)
{
return Judy1Set(&set->judy, index, &set->err);
}
* if (jbit_clear(set, 0))
* err(1, "Bit 0 was already clear?!");
*/
-static inline bool jbit_clear(struct jbitset *set, size_t index)
+static inline bool jbit_clear(struct jbitset *set, unsigned long index)
{
return Judy1Unset(&set->judy, index, &set->err);
}
* Example:
* assert(jbit_popcount(set, 0, 1000) <= jbit_popcount(set, 0, 2000));
*/
-static inline size_t jbit_popcount(const struct jbitset *set,
- size_t start, size_t end_incl)
+static inline unsigned long jbit_popcount(const struct jbitset *set,
+ unsigned long start,
+ unsigned long end_incl)
{
return Judy1Count(set->judy, start, end_incl, (JError_t *)&set->err);
}
* convenient known-invalid value (ie. something which is never in the
* set). Otherwise, and a wrapper function like this can be used:
*
- * static bool jbit_nth_index(struct jbitset *set, size_t n, size_t *idx)
+ * static bool jbit_nth_index(struct jbitset *set,
+ * unsigned long n, unsigned long *idx)
* {
* // Zero might be valid, if it's first in set.
* if (n == 0 && jbit_test(set, 0)) {
* }
*
* Example:
- * size_t i, val;
+ * unsigned long i, val;
*
* // We know 0 isn't in set.
* assert(!jbit_test(set, 0));
* printf("Value %zu = %zu\n", i, val);
* }
*/
-static inline size_t jbit_nth(const struct jbitset *set,
- size_t n, size_t invalid)
+static inline unsigned long jbit_nth(const struct jbitset *set,
+ unsigned long n, unsigned long invalid)
{
- Word_t index;
+ unsigned long index;
if (!Judy1ByCount(set->judy, n+1, &index, (JError_t *)&set->err))
index = invalid;
return index;
* printf(" %zu", i);
* printf("\n");
*/
-static inline size_t jbit_first(const struct jbitset *set, size_t invalid)
+static inline unsigned long jbit_first(const struct jbitset *set,
+ unsigned long invalid)
{
- Word_t index = 0;
+ unsigned long index = 0;
if (!Judy1First(set->judy, &index, (JError_t *)&set->err))
index = invalid;
else
* This is usually used to find an adjacent bit which is set, after
* jbit_first.
*/
-static inline size_t jbit_next(const struct jbitset *set, size_t prev,
- size_t invalid)
+static inline unsigned long jbit_next(const struct jbitset *set,
+ unsigned long prev,
+ unsigned long invalid)
{
- if (!Judy1Next(set->judy, (Word_t *)&prev, (JError_t *)&set->err))
+ if (!Judy1Next(set->judy, &prev, (JError_t *)&set->err))
prev = invalid;
else
assert(prev != invalid);
* printf(" %zu", i);
* printf("\n");
*/
-static inline size_t jbit_last(const struct jbitset *set, size_t invalid)
+static inline unsigned long jbit_last(const struct jbitset *set,
+ unsigned long invalid)
{
- Word_t index = -1;
+ unsigned long index = -1;
if (!Judy1Last(set->judy, &index, (JError_t *)&set->err))
index = invalid;
else
* This is usually used to find an adjacent bit which is set, after
* jbit_last.
*/
-static inline size_t jbit_prev(const struct jbitset *set, size_t prev,
- size_t invalid)
+static inline unsigned long jbit_prev(const struct jbitset *set,
+ unsigned long prev,
+ unsigned long invalid)
{
- if (!Judy1Prev(set->judy, (Word_t *)&prev, (JError_t *)&set->err))
+ if (!Judy1Prev(set->judy, &prev, (JError_t *)&set->err))
prev = invalid;
else
assert(prev != invalid);
*
* This allows for iterating the inverse of the bitmap.
*/
-static inline size_t jbit_first_clear(const struct jbitset *set,
- size_t invalid)
+static inline unsigned long jbit_first_clear(const struct jbitset *set,
+ unsigned long invalid)
{
- Word_t index = 0;
+ unsigned long index = 0;
if (!Judy1FirstEmpty(set->judy, &index, (JError_t *)&set->err))
index = invalid;
else
return index;
}
-static inline size_t jbit_next_clear(const struct jbitset *set, size_t prev,
- size_t invalid)
+static inline unsigned long jbit_next_clear(const struct jbitset *set,
+ unsigned long prev,
+ unsigned long invalid)
{
- if (!Judy1NextEmpty(set->judy, (Word_t *)&prev, (JError_t *)&set->err))
+ if (!Judy1NextEmpty(set->judy, &prev, (JError_t *)&set->err))
prev = invalid;
else
assert(prev != invalid);
return prev;
}
-static inline size_t jbit_last_clear(const struct jbitset *set, size_t invalid)
+static inline unsigned long jbit_last_clear(const struct jbitset *set,
+ unsigned long invalid)
{
- Word_t index = -1;
+ unsigned long index = -1;
if (!Judy1LastEmpty(set->judy, &index, (JError_t *)&set->err))
index = invalid;
else
return index;
}
-static inline size_t jbit_prev_clear(const struct jbitset *set, size_t prev,
- size_t invalid)
+static inline unsigned long jbit_prev_clear(const struct jbitset *set,
+ unsigned long prev,
+ unsigned long invalid)
{
- if (!Judy1PrevEmpty(set->judy, (Word_t *)&prev, (JError_t *)&set->err))
+ if (!Judy1PrevEmpty(set->judy, &prev, (JError_t *)&set->err))
prev = invalid;
else
assert(prev != invalid);