[babeltrace.git] / src / lib / integer-range-set.c

/*
 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
 *
 * 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.
 */

#define BT_LOG_TAG "LIB/INT-RANGE-SET"
#include "lib/logging.h"

#include <stdbool.h>

#include <babeltrace2/babeltrace.h>

#include "lib/assert-pre.h"
#include "common/assert.h"
#include "func-status.h"
#include "integer-range-set.h"

uint64_t bt_integer_range_unsigned_get_lower(
		const struct bt_integer_range_unsigned *u_range)
{
	const struct bt_integer_range *range = (const void *) u_range;

	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
	return range->lower.u;
}

uint64_t bt_integer_range_unsigned_get_upper(
		const struct bt_integer_range_unsigned *u_range)
{
	const struct bt_integer_range *range = (const void *) u_range;

	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
	return range->upper.u;
}

int64_t bt_integer_range_signed_get_lower(
		const struct bt_integer_range_signed *i_range)
{
	const struct bt_integer_range *range = (const void *) i_range;

	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
	return range->lower.i;
}

int64_t bt_integer_range_signed_get_upper(
		const struct bt_integer_range_signed *i_range)
{
	const struct bt_integer_range *range = (const void *) i_range;

	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
	return range->upper.i;
}

static
bool compare_ranges(const struct bt_integer_range *range_a,
		const struct bt_integer_range *range_b)
{
	return range_a->lower.u == range_b->lower.u &&
		range_a->upper.u == range_b->upper.u;
}

bt_bool bt_integer_range_unsigned_is_equal(
		const struct bt_integer_range_unsigned *range_a,
		const struct bt_integer_range_unsigned *range_b)
{
	BT_ASSERT_PRE_DEV_NON_NULL(range_a, "Integer range A");
	BT_ASSERT_PRE_DEV_NON_NULL(range_b, "Integer range B");
	return (bt_bool) compare_ranges((const void *) range_a,
		(const void *) range_b);
}

bt_bool bt_integer_range_signed_is_equal(
		const struct bt_integer_range_signed *range_a,
		const struct bt_integer_range_signed *range_b)
{
	BT_ASSERT_PRE_DEV_NON_NULL(range_a, "Integer range A");
	BT_ASSERT_PRE_DEV_NON_NULL(range_b, "Integer range B");
	return (bt_bool) compare_ranges((const void *) range_a,
		(const void *) range_b);
}

uint64_t bt_integer_range_set_get_range_count(
		const bt_integer_range_set *range_set)
{
	BT_ASSERT_PRE_DEV_NON_NULL(range_set, "Integer range set");
	return (uint64_t) range_set->ranges->len;
}

const struct bt_integer_range_unsigned *
bt_integer_range_set_unsigned_borrow_range_by_index_const(
		const bt_integer_range_set_unsigned *u_range_set,
		uint64_t index)
{
	const struct bt_integer_range_set *range_set =
		(const void *) u_range_set;

	BT_ASSERT_PRE_DEV_NON_NULL(range_set, "Integer range set");
	BT_ASSERT_PRE_DEV_VALID_INDEX(index, range_set->ranges->len);
	return (const void *) BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set,
		index);
}

const struct bt_integer_range_signed *
bt_integer_range_set_signed_borrow_range_by_index_const(
		const bt_integer_range_set_signed *i_range_set, uint64_t index)
{
	const struct bt_integer_range_set *range_set =
		(const void *) i_range_set;

	BT_ASSERT_PRE_DEV_NON_NULL(range_set, "Integer range set");
	BT_ASSERT_PRE_DEV_VALID_INDEX(index, range_set->ranges->len);
	return (const void *) BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set,
		index);
}

static
void destroy_range_set(struct bt_object *obj)
{
	struct bt_integer_range_set *range_set = (void *) obj;

	BT_LIB_LOGD("Destroying integer range set: %!+R", range_set);

	if (range_set->ranges) {
		g_array_free(range_set->ranges, TRUE);
		range_set->ranges = NULL;
	}

	g_free(range_set);
}

static
struct bt_integer_range_set *create_range_set(void)
{
	struct bt_integer_range_set *range_set;

	BT_LOGD_STR("Creating empty integer range set.");
	range_set = g_new0(struct bt_integer_range_set, 1);

	if (!range_set) {
		BT_LIB_LOGE_APPEND_CAUSE(
			"Failed to allocate one integer range set.");
		goto error;
	}

	bt_object_init_shared(&range_set->base, destroy_range_set);
	range_set->ranges = g_array_new(FALSE, TRUE,
		sizeof(struct bt_integer_range));
	if (!range_set->ranges) {
		BT_LIB_LOGE_APPEND_CAUSE(
			"Failed to allocate integer range set's range array.");
		goto error;
	}

	BT_LOGD_STR("Created empty integer range set.");
	goto end;

error:
	BT_OBJECT_PUT_REF_AND_RESET(range_set);

end:
	return range_set;
}

struct bt_integer_range_set_unsigned *bt_integer_range_set_unsigned_create(void)
{
	return (void *) create_range_set();
}

struct bt_integer_range_set_signed *bt_integer_range_set_signed_create(void)
{
	return (void *) create_range_set();
}

static
void add_range_to_range_set(struct bt_integer_range_set *range_set,
		uint64_t u_lower, uint64_t u_upper)
{
	struct bt_integer_range range = {
		.lower.u = u_lower,
		.upper.u = u_upper,
	};

	BT_ASSERT_PRE_NON_NULL(range_set, "Integer range set");
	BT_ASSERT_PRE_DEV_HOT(range_set, "Integer range set", ": %!+R",
		range_set);
	g_array_append_val(range_set->ranges, range);
	BT_LIB_LOGD("Added integer range to integer range set: "
		"%![range-set-]+R, lower-unsigned=%" PRIu64 ", "
		"upper-unsigned=%" PRIu64, range_set, u_lower, u_upper);
}

enum bt_integer_range_set_add_range_status
bt_integer_range_set_unsigned_add_range(
		struct bt_integer_range_set_unsigned *range_set,
		uint64_t lower, uint64_t upper)
{
	BT_ASSERT_PRE(lower <= upper,
		"Range's upper bound is less than lower bound: "
		"upper=%" PRIu64 ", lower=%" PRIu64, lower, upper);
	add_range_to_range_set((void *) range_set, lower, upper);
	return BT_FUNC_STATUS_OK;
}

enum bt_integer_range_set_add_range_status
bt_integer_range_set_signed_add_range(
		struct bt_integer_range_set_signed *range_set,
		int64_t lower, int64_t upper)
{
	BT_ASSERT_PRE(lower <= upper,
		"Range's upper bound is less than lower bound: "
		"upper=%" PRId64 ", lower=%" PRId64, lower, upper);
	add_range_to_range_set((void *) range_set,
		(int64_t) lower, (int64_t) upper);
	return BT_FUNC_STATUS_OK;
}

BT_HIDDEN
void _bt_integer_range_set_freeze(const struct bt_integer_range_set *range_set)
{
	BT_ASSERT(range_set);
	BT_LIB_LOGD("Freezing integer range set: %!+R", range_set);
	((struct bt_integer_range_set *) range_set)->frozen = true;
}

BT_HIDDEN
bool bt_integer_range_set_unsigned_has_overlaps(
		const struct bt_integer_range_set *range_set)
{
	uint64_t i, j;
	bool has_overlap = false;

	BT_ASSERT(range_set);

	for (i = 0; i < range_set->ranges->len; i++) {
		const struct bt_integer_range *range_i =
			BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set, i);

		for (j = 0; j < range_set->ranges->len; j++) {
			const struct bt_integer_range *range_j =
				BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(
					range_set, j);

			if (i == j) {
				continue;
			}

			if (range_i->lower.u <= range_j->upper.u &&
					range_j->lower.u <= range_i->upper.u) {
				has_overlap = true;
				goto end;
			}
		}
	}

end:
	return has_overlap;
}

BT_HIDDEN
bool bt_integer_range_set_signed_has_overlaps(
		const struct bt_integer_range_set *range_set)
{
	uint64_t i, j;
	bool has_overlap = false;

	BT_ASSERT(range_set);

	for (i = 0; i < range_set->ranges->len; i++) {
		const struct bt_integer_range *range_i =
			BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set, i);

		for (j = 0; j < range_set->ranges->len; j++) {
			const struct bt_integer_range *range_j =
				BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(
					range_set, j);

			if (i == j) {
				continue;
			}

			if (range_i->lower.i <= range_j->upper.i &&
					range_j->lower.i <= range_i->upper.i) {
				has_overlap = true;
				goto end;
			}
		}
	}

end:
	return has_overlap;
}

static
bool compare_range_sets(const struct bt_integer_range_set *range_set_a,
		const struct bt_integer_range_set *range_set_b)
{
	uint64_t a_i, b_i;
	bool is_equal = true;

	BT_ASSERT_DBG(range_set_a);
	BT_ASSERT_DBG(range_set_b);

	if (range_set_a == range_set_b) {
		goto end;
	}

	/*
	 * Not super effective for the moment: do a O(N²) compare, also
	 * checking that the sizes match.
	 */
	if (range_set_a->ranges->len != range_set_b->ranges->len) {
		is_equal = false;
		goto end;
	}

	for (a_i = 0; a_i < range_set_a->ranges->len; a_i++) {
		const struct bt_integer_range *range_a =
			BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set_a,
				a_i);
		bool b_has_range = false;

		for (b_i = 0; b_i < range_set_b->ranges->len; b_i++) {
			const struct bt_integer_range *range_b =
				BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(
					range_set_b, b_i);

			if (compare_ranges(range_a, range_b)) {
				b_has_range = true;
				break;
			}
		}

		if (!b_has_range) {
			is_equal = false;
			goto end;
		}
	}

end:
	return is_equal;
}

bt_bool bt_integer_range_set_unsigned_is_equal(
		const struct bt_integer_range_set_unsigned *range_set_a,
		const struct bt_integer_range_set_unsigned *range_set_b)
{
	BT_ASSERT_PRE_DEV_NON_NULL(range_set_a, "Range set A");
	BT_ASSERT_PRE_DEV_NON_NULL(range_set_b, "Range set B");
	return (bt_bool) compare_range_sets((const void *) range_set_a,
		(const void *) range_set_b);
}

bt_bool bt_integer_range_set_signed_is_equal(
		const struct bt_integer_range_set_signed *range_set_a,
		const struct bt_integer_range_set_signed *range_set_b)
{
	BT_ASSERT_PRE_DEV_NON_NULL(range_set_a, "Range set A");
	BT_ASSERT_PRE_DEV_NON_NULL(range_set_b, "Range set B");
	return (bt_bool) compare_range_sets((const void *) range_set_a,
		(const void *) range_set_b);
}

void bt_integer_range_set_unsigned_get_ref(
		const struct bt_integer_range_set_unsigned *range_set)
{
	bt_object_get_ref(range_set);
}

void bt_integer_range_set_unsigned_put_ref(
		const struct bt_integer_range_set_unsigned *range_set)
{
	bt_object_put_ref(range_set);
}

void bt_integer_range_set_signed_get_ref(
		const struct bt_integer_range_set_signed *range_set)
{
	bt_object_get_ref(range_set);
}

void bt_integer_range_set_signed_put_ref(
		const struct bt_integer_range_set_signed *range_set)
{
	bt_object_put_ref(range_set);
}
Commit	Line	Data
fb91c0ef PP	1	/*
	2	* Copyright 2019 Philippe Proulx <pproulx@efficios.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	17	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	18	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	19	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	20	* SOFTWARE.
	21	*/
	22
	23	#define BT_LOG_TAG "LIB/INT-RANGE-SET"
	24	#include "lib/logging.h"
	25
c4f23e30 FD	26	#include <stdbool.h>
c4f23e30 FD	27
fb91c0ef	28	#include <babeltrace2/babeltrace.h>
c4f23e30	29
fb91c0ef PP	30	#include "lib/assert-pre.h"
	31	#include "common/assert.h"
	32	#include "func-status.h"
	33	#include "integer-range-set.h"
	34
6769570a PP	35	uint64_t bt_integer_range_unsigned_get_lower(
6769570a PP	36	const struct bt_integer_range_unsigned *u_range)
fb91c0ef PP	37	{
	38	const struct bt_integer_range range = (const void ) u_range;
	39
6769570a	40	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
fb91c0ef PP	41	return range->lower.u;
	42	}
	43
6769570a PP	44	uint64_t bt_integer_range_unsigned_get_upper(
6769570a PP	45	const struct bt_integer_range_unsigned *u_range)
fb91c0ef PP	46	{
	47	const struct bt_integer_range range = (const void ) u_range;
	48
6769570a	49	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
fb91c0ef PP	50	return range->upper.u;
	51	}
	52
6769570a PP	53	int64_t bt_integer_range_signed_get_lower(
6769570a PP	54	const struct bt_integer_range_signed *i_range)
fb91c0ef PP	55	{
	56	const struct bt_integer_range range = (const void ) i_range;
	57
6769570a	58	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
fb91c0ef PP	59	return range->lower.i;
	60	}
	61
6769570a PP	62	int64_t bt_integer_range_signed_get_upper(
6769570a PP	63	const struct bt_integer_range_signed *i_range)
fb91c0ef PP	64	{
	65	const struct bt_integer_range range = (const void ) i_range;
	66
6769570a	67	BT_ASSERT_PRE_DEV_NON_NULL(range, "Integer range");
fb91c0ef PP	68	return range->upper.i;
	69	}
	70
	71	static
	72	bool compare_ranges(const struct bt_integer_range *range_a,
	73	const struct bt_integer_range *range_b)
	74	{
	75	return range_a->lower.u == range_b->lower.u &&
	76	range_a->upper.u == range_b->upper.u;
	77	}
	78
cd933d89	79	bt_bool bt_integer_range_unsigned_is_equal(
fb91c0ef PP	80	const struct bt_integer_range_unsigned *range_a,
	81	const struct bt_integer_range_unsigned *range_b)
	82	{
6769570a PP	83	BT_ASSERT_PRE_DEV_NON_NULL(range_a, "Integer range A");
6769570a PP	84	BT_ASSERT_PRE_DEV_NON_NULL(range_b, "Integer range B");
fb91c0ef PP	85	return (bt_bool) compare_ranges((const void *) range_a,
	86	(const void *) range_b);
	87	}
	88
cd933d89	89	bt_bool bt_integer_range_signed_is_equal(
fb91c0ef PP	90	const struct bt_integer_range_signed *range_a,
	91	const struct bt_integer_range_signed *range_b)
	92	{
6769570a PP	93	BT_ASSERT_PRE_DEV_NON_NULL(range_a, "Integer range A");
6769570a PP	94	BT_ASSERT_PRE_DEV_NON_NULL(range_b, "Integer range B");
fb91c0ef PP	95	return (bt_bool) compare_ranges((const void *) range_a,
	96	(const void *) range_b);
	97	}
	98
	99	uint64_t bt_integer_range_set_get_range_count(
	100	const bt_integer_range_set *range_set)
	101	{
6769570a	102	BT_ASSERT_PRE_DEV_NON_NULL(range_set, "Integer range set");
fb91c0ef PP	103	return (uint64_t) range_set->ranges->len;
	104	}
	105
6769570a PP	106	const struct bt_integer_range_unsigned *
	107	bt_integer_range_set_unsigned_borrow_range_by_index_const(
	108	const bt_integer_range_set_unsigned *u_range_set,
	109	uint64_t index)
fb91c0ef	110	{
6769570a PP	111	const struct bt_integer_range_set *range_set =
6769570a PP	112	(const void *) u_range_set;
fb91c0ef	113
6769570a	114	BT_ASSERT_PRE_DEV_NON_NULL(range_set, "Integer range set");
fb91c0ef	115	BT_ASSERT_PRE_DEV_VALID_INDEX(index, range_set->ranges->len);
6769570a PP	116	return (const void *) BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set,
6769570a PP	117	index);
fb91c0ef PP	118	}
fb91c0ef PP	119
6769570a PP	120	const struct bt_integer_range_signed *
6769570a PP	121	bt_integer_range_set_signed_borrow_range_by_index_const(
fb91c0ef PP	122	const bt_integer_range_set_signed *i_range_set, uint64_t index)
fb91c0ef PP	123	{
6769570a PP	124	const struct bt_integer_range_set *range_set =
6769570a PP	125	(const void *) i_range_set;
fb91c0ef	126
6769570a	127	BT_ASSERT_PRE_DEV_NON_NULL(range_set, "Integer range set");
fb91c0ef	128	BT_ASSERT_PRE_DEV_VALID_INDEX(index, range_set->ranges->len);
6769570a PP	129	return (const void *) BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set,
6769570a PP	130	index);
fb91c0ef PP	131	}
	132
	133	static
	134	void destroy_range_set(struct bt_object *obj)
	135	{
	136	struct bt_integer_range_set range_set = (void ) obj;
	137
6769570a PP	138	BT_LIB_LOGD("Destroying integer range set: %!+R", range_set);
6769570a PP	139
fb91c0ef PP	140	if (range_set->ranges) {
	141	g_array_free(range_set->ranges, TRUE);
	142	range_set->ranges = NULL;
	143	}
	144
	145	g_free(range_set);
	146	}
	147
	148	static
	149	struct bt_integer_range_set *create_range_set(void)
	150	{
6769570a PP	151	struct bt_integer_range_set *range_set;
	152
	153	BT_LOGD_STR("Creating empty integer range set.");
	154	range_set = g_new0(struct bt_integer_range_set, 1);
fb91c0ef PP	155
fb91c0ef PP	156	if (!range_set) {
6769570a PP	157	BT_LIB_LOGE_APPEND_CAUSE(
6769570a PP	158	"Failed to allocate one integer range set.");
fb91c0ef PP	159	goto error;
	160	}
	161
	162	bt_object_init_shared(&range_set->base, destroy_range_set);
	163	range_set->ranges = g_array_new(FALSE, TRUE,
	164	sizeof(struct bt_integer_range));
	165	if (!range_set->ranges) {
	166	BT_LIB_LOGE_APPEND_CAUSE(
6769570a	167	"Failed to allocate integer range set's range array.");
fb91c0ef PP	168	goto error;
	169	}
	170
6769570a	171	BT_LOGD_STR("Created empty integer range set.");
fb91c0ef PP	172	goto end;
	173
	174	error:
	175	BT_OBJECT_PUT_REF_AND_RESET(range_set);
	176
	177	end:
	178	return range_set;
	179	}
	180
	181	struct bt_integer_range_set_unsigned *bt_integer_range_set_unsigned_create(void)
	182	{
	183	return (void *) create_range_set();
	184	}
	185
	186	struct bt_integer_range_set_signed *bt_integer_range_set_signed_create(void)
	187	{
	188	return (void *) create_range_set();
	189	}
	190
7c7301d5	191	static
fb91c0ef PP	192	void add_range_to_range_set(struct bt_integer_range_set *range_set,
	193	uint64_t u_lower, uint64_t u_upper)
	194	{
	195	struct bt_integer_range range = {
	196	.lower.u = u_lower,
	197	.upper.u = u_upper,
	198	};
	199
6769570a PP	200	BT_ASSERT_PRE_NON_NULL(range_set, "Integer range set");
	201	BT_ASSERT_PRE_DEV_HOT(range_set, "Integer range set", ": %!+R",
	202	range_set);
fb91c0ef	203	g_array_append_val(range_set->ranges, range);
6769570a PP	204	BT_LIB_LOGD("Added integer range to integer range set: "
	205	"%![range-set-]+R, lower-unsigned=%" PRIu64 ", "
	206	"upper-unsigned=%" PRIu64, range_set, u_lower, u_upper);
fb91c0ef PP	207	}
fb91c0ef PP	208
6769570a PP	209	enum bt_integer_range_set_add_range_status
6769570a PP	210	bt_integer_range_set_unsigned_add_range(
fb91c0ef PP	211	struct bt_integer_range_set_unsigned *range_set,
	212	uint64_t lower, uint64_t upper)
	213	{
	214	BT_ASSERT_PRE(lower <= upper,
	215	"Range's upper bound is less than lower bound: "
	216	"upper=%" PRIu64 ", lower=%" PRIu64, lower, upper);
	217	add_range_to_range_set((void *) range_set, lower, upper);
	218	return BT_FUNC_STATUS_OK;
	219	}
	220
6769570a PP	221	enum bt_integer_range_set_add_range_status
6769570a PP	222	bt_integer_range_set_signed_add_range(
fb91c0ef PP	223	struct bt_integer_range_set_signed *range_set,
	224	int64_t lower, int64_t upper)
	225	{
	226	BT_ASSERT_PRE(lower <= upper,
	227	"Range's upper bound is less than lower bound: "
	228	"upper=%" PRId64 ", lower=%" PRId64, lower, upper);
	229	add_range_to_range_set((void *) range_set,
	230	(int64_t) lower, (int64_t) upper);
	231	return BT_FUNC_STATUS_OK;
	232	}
	233
	234	BT_HIDDEN
	235	void _bt_integer_range_set_freeze(const struct bt_integer_range_set *range_set)
	236	{
	237	BT_ASSERT(range_set);
6769570a	238	BT_LIB_LOGD("Freezing integer range set: %!+R", range_set);
fb91c0ef PP	239	((struct bt_integer_range_set *) range_set)->frozen = true;
	240	}
	241
	242	BT_HIDDEN
6769570a PP	243	bool bt_integer_range_set_unsigned_has_overlaps(
6769570a PP	244	const struct bt_integer_range_set *range_set)
fb91c0ef PP	245	{
	246	uint64_t i, j;
	247	bool has_overlap = false;
	248
	249	BT_ASSERT(range_set);
	250
	251	for (i = 0; i < range_set->ranges->len; i++) {
	252	const struct bt_integer_range *range_i =
	253	BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set, i);
	254
	255	for (j = 0; j < range_set->ranges->len; j++) {
	256	const struct bt_integer_range *range_j =
6769570a PP	257	BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(
6769570a PP	258	range_set, j);
fb91c0ef PP	259
	260	if (i == j) {
	261	continue;
	262	}
	263
	264	if (range_i->lower.u <= range_j->upper.u &&
	265	range_j->lower.u <= range_i->upper.u) {
	266	has_overlap = true;
	267	goto end;
	268	}
	269	}
	270	}
	271
	272	end:
	273	return has_overlap;
	274	}
	275
	276	BT_HIDDEN
6769570a PP	277	bool bt_integer_range_set_signed_has_overlaps(
6769570a PP	278	const struct bt_integer_range_set *range_set)
fb91c0ef PP	279	{
	280	uint64_t i, j;
	281	bool has_overlap = false;
	282
	283	BT_ASSERT(range_set);
	284
	285	for (i = 0; i < range_set->ranges->len; i++) {
	286	const struct bt_integer_range *range_i =
	287	BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set, i);
	288
	289	for (j = 0; j < range_set->ranges->len; j++) {
	290	const struct bt_integer_range *range_j =
6769570a PP	291	BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(
6769570a PP	292	range_set, j);
fb91c0ef PP	293
	294	if (i == j) {
	295	continue;
	296	}
	297
	298	if (range_i->lower.i <= range_j->upper.i &&
	299	range_j->lower.i <= range_i->upper.i) {
	300	has_overlap = true;
	301	goto end;
	302	}
	303	}
	304	}
	305
	306	end:
	307	return has_overlap;
	308	}
	309
	310	static
	311	bool compare_range_sets(const struct bt_integer_range_set *range_set_a,
	312	const struct bt_integer_range_set *range_set_b)
	313	{
	314	uint64_t a_i, b_i;
	315	bool is_equal = true;
	316
98b15851 PP	317	BT_ASSERT_DBG(range_set_a);
98b15851 PP	318	BT_ASSERT_DBG(range_set_b);
fb91c0ef PP	319
	320	if (range_set_a == range_set_b) {
	321	goto end;
	322	}
	323
	324	/*
	325	* Not super effective for the moment: do a O(N²) compare, also
	326	* checking that the sizes match.
	327	*/
	328	if (range_set_a->ranges->len != range_set_b->ranges->len) {
	329	is_equal = false;
	330	goto end;
	331	}
	332
	333	for (a_i = 0; a_i < range_set_a->ranges->len; a_i++) {
	334	const struct bt_integer_range *range_a =
	335	BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(range_set_a,
	336	a_i);
	337	bool b_has_range = false;
	338
	339	for (b_i = 0; b_i < range_set_b->ranges->len; b_i++) {
	340	const struct bt_integer_range *range_b =
	341	BT_INTEGER_RANGE_SET_RANGE_AT_INDEX(
	342	range_set_b, b_i);
	343
	344	if (compare_ranges(range_a, range_b)) {
	345	b_has_range = true;
	346	break;
	347	}
	348	}
	349
	350	if (!b_has_range) {
	351	is_equal = false;
	352	goto end;
	353	}
	354	}
	355
	356	end:
	357	return is_equal;
	358	}
	359
cd933d89	360	bt_bool bt_integer_range_set_unsigned_is_equal(
fb91c0ef PP	361	const struct bt_integer_range_set_unsigned *range_set_a,
	362	const struct bt_integer_range_set_unsigned *range_set_b)
	363	{
	364	BT_ASSERT_PRE_DEV_NON_NULL(range_set_a, "Range set A");
	365	BT_ASSERT_PRE_DEV_NON_NULL(range_set_b, "Range set B");
	366	return (bt_bool) compare_range_sets((const void *) range_set_a,
	367	(const void *) range_set_b);
	368	}
	369
cd933d89	370	bt_bool bt_integer_range_set_signed_is_equal(
fb91c0ef PP	371	const struct bt_integer_range_set_signed *range_set_a,
	372	const struct bt_integer_range_set_signed *range_set_b)
	373	{
	374	BT_ASSERT_PRE_DEV_NON_NULL(range_set_a, "Range set A");
	375	BT_ASSERT_PRE_DEV_NON_NULL(range_set_b, "Range set B");
	376	return (bt_bool) compare_range_sets((const void *) range_set_a,
	377	(const void *) range_set_b);
	378	}
	379
	380	void bt_integer_range_set_unsigned_get_ref(
	381	const struct bt_integer_range_set_unsigned *range_set)
	382	{
	383	bt_object_get_ref(range_set);
	384	}
	385
	386	void bt_integer_range_set_unsigned_put_ref(
	387	const struct bt_integer_range_set_unsigned *range_set)
	388	{
	389	bt_object_put_ref(range_set);
	390	}
	391
6769570a PP	392	void bt_integer_range_set_signed_get_ref(
6769570a PP	393	const struct bt_integer_range_set_signed *range_set)
fb91c0ef PP	394	{
	395	bt_object_get_ref(range_set);
	396	}
	397
6769570a PP	398	void bt_integer_range_set_signed_put_ref(
6769570a PP	399	const struct bt_integer_range_set_signed *range_set)
fb91c0ef PP	400	{
	401	bt_object_put_ref(range_set);
	402	}