oidset.c

#include "git-compat-util.h"
#include "oidset.h"
#include "hex.h"
#include "strbuf.h"

void oidset_init(struct oidset *set, size_t initial_size)
{
	memset(&set->set, 0, sizeof(set->set));
	if (initial_size)
		kh_resize_oid_set(&set->set, initial_size);
}

int oidset_contains(const struct oidset *set, const struct object_id *oid)
{
	khiter_t pos = kh_get_oid_set(&set->set, *oid);
	return pos != kh_end(&set->set);
}

bool oidset_equal(const struct oidset *a, const struct oidset *b)
{
	struct oidset_iter iter;
	struct object_id *a_oid;

	if (oidset_size(a) != oidset_size(b))
		return false;

	oidset_iter_init(a, &iter);
	while ((a_oid = oidset_iter_next(&iter)))
		if (!oidset_contains(b, a_oid))
			return false;

	return true;
}

int oidset_insert(struct oidset *set, const struct object_id *oid)
{
	int added;
	kh_put_oid_set(&set->set, *oid, &added);
	return !added;
}

void oidset_insert_from_set(struct oidset *dest, struct oidset *src)
{
	struct oidset_iter iter;
	struct object_id *src_oid;

	oidset_iter_init(src, &iter);
	while ((src_oid = oidset_iter_next(&iter)))
		oidset_insert(dest, src_oid);
}

int oidset_remove(struct oidset *set, const struct object_id *oid)
{
	khiter_t pos = kh_get_oid_set(&set->set, *oid);
	if (pos == kh_end(&set->set))
		return 0;
	kh_del_oid_set(&set->set, pos);
	return 1;
}

void oidset_clear(struct oidset *set)
{
	kh_release_oid_set(&set->set);
	oidset_init(set, 0);
}

void oidset_parse_file(struct oidset *set, const char *path,
		       const struct git_hash_algo *algop)
{
	oidset_parse_file_carefully(set, path, algop, NULL, NULL);
}

static void parse_oidset_line(struct oidset *set, struct strbuf *sb,
			      const struct git_hash_algo *algop,
			      oidset_parse_tweak_fn fn, void *cbdata)
{
	const char *p;
	const char *name;
	struct object_id oid;

	if (memchr(sb->buf, '\0', sb->len))
		die("invalid object name: %s", sb->buf);

	/*
	 * Allow trailing comments, leading whitespace
	 * (including before commits), and empty or whitespace
	 * only lines.
	 */
	name = strchr(sb->buf, '#');
	if (name)
		strbuf_setlen(sb, name - sb->buf);
	strbuf_trim(sb);
	if (!sb->len)
		return;

	if (parse_oid_hex_algop(sb->buf, &oid, &p, algop) || *p != '\0')
		die("invalid object name: %s", sb->buf);
	if (fn && fn(&oid, cbdata))
		return;
	oidset_insert(set, &oid);
}

void oidset_parse_file_carefully(struct oidset *set, const char *path,
				 const struct git_hash_algo *algop,
				 oidset_parse_tweak_fn fn, void *cbdata)
{
	FILE *fp;
	struct strbuf sb = STRBUF_INIT;

	fp = fopen(path, "r");
	if (!fp)
		die("could not open object name list: %s", path);
	while (!strbuf_getline(&sb, fp))
		parse_oidset_line(set, &sb, algop, fn, cbdata);
	if (ferror(fp))
		die_errno("Could not read '%s'", path);
	fclose(fp);
	strbuf_release(&sb);
}

void oidset_parse_buffer_carefully(struct oidset *set, const char *buf,
				   size_t size,
				   const struct git_hash_algo *algop,
				   oidset_parse_tweak_fn fn, void *cbdata)
{
	struct strbuf sb = STRBUF_INIT;
	const char *p = buf, *end;

	if (!size)
		return;
	end = buf + size;

	while (p < end) {
		const char *nl = memchr(p, '\n', end - p);
		size_t len = (nl ? nl : end) - p;

		strbuf_reset(&sb);
		if (len && p[len - 1] == '\r')
			len--;
		strbuf_add(&sb, p, len);
		parse_oidset_line(set, &sb, algop, fn, cbdata);
		p = nl ? nl + 1 : end;
	}
	strbuf_release(&sb);
}