[thirdparty/git.git] / list-objects-filter.c

#include "cache.h"
#include "dir.h"
#include "tag.h"
#include "commit.h"
#include "tree.h"
#include "blob.h"
#include "diff.h"
#include "tree-walk.h"
#include "revision.h"
#include "list-objects.h"
#include "list-objects-filter.h"
#include "list-objects-filter-options.h"
#include "oidset.h"

/* Remember to update object flag allocation in object.h */
/*
 * FILTER_SHOWN_BUT_REVISIT -- we set this bit on tree objects
 * that have been shown, but should be revisited if they appear
 * in the traversal (until we mark it SEEN).  This is a way to
 * let us silently de-dup calls to show() in the caller.  This
 * is subtly different from the "revision.h:SHOWN" and the
 * "sha1_name.c:ONELINE_SEEN" bits.  And also different from
 * the non-de-dup usage in pack-bitmap.c
 */
#define FILTER_SHOWN_BUT_REVISIT (1<<21)

/*
 * A filter for list-objects to omit ALL blobs from the traversal.
 * And to OPTIONALLY collect a list of the omitted OIDs.
 */
struct filter_blobs_none_data {
	struct oidset *omits;
};

static enum list_objects_filter_result filter_blobs_none(
	enum list_objects_filter_situation filter_situation,
	struct object *obj,
	const char *pathname,
	const char *filename,
	void *filter_data_)
{
	struct filter_blobs_none_data *filter_data = filter_data_;

	switch (filter_situation) {
	default:
		die("unknown filter_situation");
		return LOFR_ZERO;

	case LOFS_BEGIN_TREE:
		assert(obj->type == OBJ_TREE);
		/* always include all tree objects */
		return LOFR_MARK_SEEN | LOFR_DO_SHOW;

	case LOFS_END_TREE:
		assert(obj->type == OBJ_TREE);
		return LOFR_ZERO;

	case LOFS_BLOB:
		assert(obj->type == OBJ_BLOB);
		assert((obj->flags & SEEN) == 0);

		if (filter_data->omits)
			oidset_insert(filter_data->omits, &obj->oid);
		return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
	}
}

static void *filter_blobs_none__init(
	struct oidset *omitted,
	struct list_objects_filter_options *filter_options,
	filter_object_fn *filter_fn,
	filter_free_fn *filter_free_fn)
{
	struct filter_blobs_none_data *d = xcalloc(1, sizeof(*d));
	d->omits = omitted;

	*filter_fn = filter_blobs_none;
	*filter_free_fn = free;
	return d;
}

/*
 * A filter for list-objects to omit large blobs.
 * And to OPTIONALLY collect a list of the omitted OIDs.
 */
struct filter_blobs_limit_data {
	struct oidset *omits;
	unsigned long max_bytes;
};

static enum list_objects_filter_result filter_blobs_limit(
	enum list_objects_filter_situation filter_situation,
	struct object *obj,
	const char *pathname,
	const char *filename,
	void *filter_data_)
{
	struct filter_blobs_limit_data *filter_data = filter_data_;
	unsigned long object_length;
	enum object_type t;

	switch (filter_situation) {
	default:
		die("unknown filter_situation");
		return LOFR_ZERO;

	case LOFS_BEGIN_TREE:
		assert(obj->type == OBJ_TREE);
		/* always include all tree objects */
		return LOFR_MARK_SEEN | LOFR_DO_SHOW;

	case LOFS_END_TREE:
		assert(obj->type == OBJ_TREE);
		return LOFR_ZERO;

	case LOFS_BLOB:
		assert(obj->type == OBJ_BLOB);
		assert((obj->flags & SEEN) == 0);

		t = sha1_object_info(obj->oid.hash, &object_length);
		if (t != OBJ_BLOB) { /* probably OBJ_NONE */
			/*
			 * We DO NOT have the blob locally, so we cannot
			 * apply the size filter criteria.  Be conservative
			 * and force show it (and let the caller deal with
			 * the ambiguity).
			 */
			goto include_it;
		}

		if (object_length < filter_data->max_bytes)
			goto include_it;

		if (filter_data->omits)
			oidset_insert(filter_data->omits, &obj->oid);
		return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
	}

include_it:
	if (filter_data->omits)
		oidset_remove(filter_data->omits, &obj->oid);
	return LOFR_MARK_SEEN | LOFR_DO_SHOW;
}

static void *filter_blobs_limit__init(
	struct oidset *omitted,
	struct list_objects_filter_options *filter_options,
	filter_object_fn *filter_fn,
	filter_free_fn *filter_free_fn)
{
	struct filter_blobs_limit_data *d = xcalloc(1, sizeof(*d));
	d->omits = omitted;
	d->max_bytes = filter_options->blob_limit_value;

	*filter_fn = filter_blobs_limit;
	*filter_free_fn = free;
	return d;
}

/*
 * A filter driven by a sparse-checkout specification to only
 * include blobs that a sparse checkout would populate.
 *
 * The sparse-checkout spec can be loaded from a blob with the
 * given OID or from a local pathname.  We allow an OID because
 * the repo may be bare or we may be doing the filtering on the
 * server.
 */
struct frame {
	/*
	 * defval is the usual default include/exclude value that
	 * should be inherited as we recurse into directories based
	 * upon pattern matching of the directory itself or of a
	 * containing directory.
	 */
	int defval;

	/*
	 * 1 if the directory (recursively) contains any provisionally
	 * omitted objects.
	 *
	 * 0 if everything (recursively) contained in this directory
	 * has been explicitly included (SHOWN) in the result and
	 * the directory may be short-cut later in the traversal.
	 */
	unsigned child_prov_omit : 1;
};

struct filter_sparse_data {
	struct oidset *omits;
	struct exclude_list el;

	size_t nr, alloc;
	struct frame *array_frame;
};

static enum list_objects_filter_result filter_sparse(
	enum list_objects_filter_situation filter_situation,
	struct object *obj,
	const char *pathname,
	const char *filename,
	void *filter_data_)
{
	struct filter_sparse_data *filter_data = filter_data_;
	int val, dtype;
	struct frame *frame;

	switch (filter_situation) {
	default:
		die("unknown filter_situation");
		return LOFR_ZERO;

	case LOFS_BEGIN_TREE:
		assert(obj->type == OBJ_TREE);
		dtype = DT_DIR;
		val = is_excluded_from_list(pathname, strlen(pathname),
					    filename, &dtype, &filter_data->el,
					    &the_index);
		if (val < 0)
			val = filter_data->array_frame[filter_data->nr].defval;

		ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1,
			   filter_data->alloc);
		filter_data->nr++;
		filter_data->array_frame[filter_data->nr].defval = val;
		filter_data->array_frame[filter_data->nr].child_prov_omit = 0;

		/*
		 * A directory with this tree OID may appear in multiple
		 * places in the tree. (Think of a directory move or copy,
		 * with no other changes, so the OID is the same, but the
		 * full pathnames of objects within this directory are new
		 * and may match is_excluded() patterns differently.)
		 * So we cannot mark this directory as SEEN (yet), since
		 * that will prevent process_tree() from revisiting this
		 * tree object with other pathname prefixes.
		 *
		 * Only _DO_SHOW the tree object the first time we visit
		 * this tree object.
		 *
		 * We always show all tree objects.  A future optimization
		 * may want to attempt to narrow this.
		 */
		if (obj->flags & FILTER_SHOWN_BUT_REVISIT)
			return LOFR_ZERO;
		obj->flags |= FILTER_SHOWN_BUT_REVISIT;
		return LOFR_DO_SHOW;

	case LOFS_END_TREE:
		assert(obj->type == OBJ_TREE);
		assert(filter_data->nr > 0);

		frame = &filter_data->array_frame[filter_data->nr];
		filter_data->nr--;

		/*
		 * Tell our parent directory if any of our children were
		 * provisionally omitted.
		 */
		filter_data->array_frame[filter_data->nr].child_prov_omit |=
			frame->child_prov_omit;

		/*
		 * If there are NO provisionally omitted child objects (ALL child
		 * objects in this folder were INCLUDED), then we can mark the
		 * folder as SEEN (so we will not have to revisit it again).
		 */
		if (!frame->child_prov_omit)
			return LOFR_MARK_SEEN;
		return LOFR_ZERO;

	case LOFS_BLOB:
		assert(obj->type == OBJ_BLOB);
		assert((obj->flags & SEEN) == 0);

		frame = &filter_data->array_frame[filter_data->nr];

		dtype = DT_REG;
		val = is_excluded_from_list(pathname, strlen(pathname),
					    filename, &dtype, &filter_data->el,
					    &the_index);
		if (val < 0)
			val = frame->defval;
		if (val > 0) {
			if (filter_data->omits)
				oidset_remove(filter_data->omits, &obj->oid);
			return LOFR_MARK_SEEN | LOFR_DO_SHOW;
		}

		/*
		 * Provisionally omit it.  We've already established that
		 * this pathname is not in the sparse-checkout specification
		 * with the CURRENT pathname, so we *WANT* to omit this blob.
		 *
		 * However, a pathname elsewhere in the tree may also
		 * reference this same blob, so we cannot reject it yet.
		 * Leave the LOFR_ bits unset so that if the blob appears
		 * again in the traversal, we will be asked again.
		 */
		if (filter_data->omits)
			oidset_insert(filter_data->omits, &obj->oid);

		/*
		 * Remember that at least 1 blob in this tree was
		 * provisionally omitted.  This prevents us from short
		 * cutting the tree in future iterations.
		 */
		frame->child_prov_omit = 1;
		return LOFR_ZERO;
	}
}


static void filter_sparse_free(void *filter_data)
{
	struct filter_sparse_data *d = filter_data;
	/* TODO free contents of 'd' */
	free(d);
}

static void *filter_sparse_oid__init(
	struct oidset *omitted,
	struct list_objects_filter_options *filter_options,
	filter_object_fn *filter_fn,
	filter_free_fn *filter_free_fn)
{
	struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
	d->omits = omitted;
	if (add_excludes_from_blob_to_list(filter_options->sparse_oid_value,
					   NULL, 0, &d->el) < 0)
		die("could not load filter specification");

	ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
	d->array_frame[d->nr].defval = 0; /* default to include */
	d->array_frame[d->nr].child_prov_omit = 0;

	*filter_fn = filter_sparse;
	*filter_free_fn = filter_sparse_free;
	return d;
}

static void *filter_sparse_path__init(
	struct oidset *omitted,
	struct list_objects_filter_options *filter_options,
	filter_object_fn *filter_fn,
	filter_free_fn *filter_free_fn)
{
	struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
	d->omits = omitted;
	if (add_excludes_from_file_to_list(filter_options->sparse_path_value,
					   NULL, 0, &d->el, NULL) < 0)
		die("could not load filter specification");

	ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
	d->array_frame[d->nr].defval = 0; /* default to include */
	d->array_frame[d->nr].child_prov_omit = 0;

	*filter_fn = filter_sparse;
	*filter_free_fn = filter_sparse_free;
	return d;
}

typedef void *(*filter_init_fn)(
	struct oidset *omitted,
	struct list_objects_filter_options *filter_options,
	filter_object_fn *filter_fn,
	filter_free_fn *filter_free_fn);

/*
 * Must match "enum list_objects_filter_choice".
 */
static filter_init_fn s_filters[] = {
	NULL,
	filter_blobs_none__init,
	filter_blobs_limit__init,
	filter_sparse_oid__init,
	filter_sparse_path__init,
};

void *list_objects_filter__init(
	struct oidset *omitted,
	struct list_objects_filter_options *filter_options,
	filter_object_fn *filter_fn,
	filter_free_fn *filter_free_fn)
{
	filter_init_fn init_fn;

	assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);

	if (filter_options->choice >= LOFC__COUNT)
		die("invalid list-objects filter choice: %d",
		    filter_options->choice);

	init_fn = s_filters[filter_options->choice];
	if (init_fn)
		return init_fn(omitted, filter_options,
			       filter_fn, filter_free_fn);
	*filter_fn = NULL;
	*filter_free_fn = NULL;
	return NULL;
}
Commit	Line	Data
25ec7bca JH	1	#include "cache.h"
	2	#include "dir.h"
	3	#include "tag.h"
	4	#include "commit.h"
	5	#include "tree.h"
	6	#include "blob.h"
	7	#include "diff.h"
	8	#include "tree-walk.h"
	9	#include "revision.h"
	10	#include "list-objects.h"
	11	#include "list-objects-filter.h"
	12	#include "list-objects-filter-options.h"
	13	#include "oidset.h"
	14
	15	/* Remember to update object flag allocation in object.h */
	16	/*
	17	* FILTER_SHOWN_BUT_REVISIT -- we set this bit on tree objects
	18	* that have been shown, but should be revisited if they appear
	19	* in the traversal (until we mark it SEEN). This is a way to
	20	* let us silently de-dup calls to show() in the caller. This
	21	* is subtly different from the "revision.h:SHOWN" and the
	22	* "sha1_name.c:ONELINE_SEEN" bits. And also different from
	23	* the non-de-dup usage in pack-bitmap.c
	24	*/
	25	#define FILTER_SHOWN_BUT_REVISIT (1<<21)
	26
	27	/*
	28	* A filter for list-objects to omit ALL blobs from the traversal.
	29	* And to OPTIONALLY collect a list of the omitted OIDs.
	30	*/
	31	struct filter_blobs_none_data {
	32	struct oidset *omits;
	33	};
	34
	35	static enum list_objects_filter_result filter_blobs_none(
	36	enum list_objects_filter_situation filter_situation,
	37	struct object *obj,
	38	const char *pathname,
	39	const char *filename,
	40	void *filter_data_)
	41	{
	42	struct filter_blobs_none_data *filter_data = filter_data_;
	43
	44	switch (filter_situation) {
	45	default:
	46	die("unknown filter_situation");
	47	return LOFR_ZERO;
	48
	49	case LOFS_BEGIN_TREE:
	50	assert(obj->type == OBJ_TREE);
	51	/* always include all tree objects */
	52	return LOFR_MARK_SEEN \| LOFR_DO_SHOW;
	53
	54	case LOFS_END_TREE:
	55	assert(obj->type == OBJ_TREE);
	56	return LOFR_ZERO;
	57
	58	case LOFS_BLOB:
	59	assert(obj->type == OBJ_BLOB);
	60	assert((obj->flags & SEEN) == 0);
	61
	62	if (filter_data->omits)
	63	oidset_insert(filter_data->omits, &obj->oid);
	64	return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
65	}
66	}
67
68	static void *filter_blobs_none__init(
69	struct oidset *omitted,
70	struct list_objects_filter_options *filter_options,
71	filter_object_fn *filter_fn,
72	filter_free_fn *filter_free_fn)
73	{
74	struct filter_blobs_none_data d = xcalloc(1, sizeof(d));
75	d->omits = omitted;
76
77	*filter_fn = filter_blobs_none;
78	*filter_free_fn = free;
79	return d;
80	}
81
82	/*
83	* A filter for list-objects to omit large blobs.
84	* And to OPTIONALLY collect a list of the omitted OIDs.
85	*/
86	struct filter_blobs_limit_data {
87	struct oidset *omits;
88	unsigned long max_bytes;
89	};
90
91	static enum list_objects_filter_result filter_blobs_limit(
92	enum list_objects_filter_situation filter_situation,
93	struct object *obj,
94	const char *pathname,
95	const char *filename,
96	void *filter_data_)
97	{
98	struct filter_blobs_limit_data *filter_data = filter_data_;
99	unsigned long object_length;
100	enum object_type t;
101
102	switch (filter_situation) {
103	default:
104	die("unknown filter_situation");
105	return LOFR_ZERO;
106
107	case LOFS_BEGIN_TREE:
108	assert(obj->type == OBJ_TREE);
109	/* always include all tree objects */
110	return LOFR_MARK_SEEN \| LOFR_DO_SHOW;
111
112	case LOFS_END_TREE:
113	assert(obj->type == OBJ_TREE);
114	return LOFR_ZERO;
115
116	case LOFS_BLOB:
117	assert(obj->type == OBJ_BLOB);
118	assert((obj->flags & SEEN) == 0);
119
120	t = sha1_object_info(obj->oid.hash, &object_length);
121	if (t != OBJ_BLOB) { /* probably OBJ_NONE */
122	/*
123	* We DO NOT have the blob locally, so we cannot
124	* apply the size filter criteria. Be conservative
125	* and force show it (and let the caller deal with
126	* the ambiguity).
127	*/
128	goto include_it;
129	}
130
131	if (object_length < filter_data->max_bytes)
132	goto include_it;
133
134	if (filter_data->omits)
135	oidset_insert(filter_data->omits, &obj->oid);
136	return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
137	}
138
139	include_it:
140	if (filter_data->omits)
141	oidset_remove(filter_data->omits, &obj->oid);
142	return LOFR_MARK_SEEN \| LOFR_DO_SHOW;
143	}
144
145	static void *filter_blobs_limit__init(
146	struct oidset *omitted,
147	struct list_objects_filter_options *filter_options,
148	filter_object_fn *filter_fn,
149	filter_free_fn *filter_free_fn)
150	{
151	struct filter_blobs_limit_data d = xcalloc(1, sizeof(d));
152	d->omits = omitted;
153	d->max_bytes = filter_options->blob_limit_value;
154
155	*filter_fn = filter_blobs_limit;
156	*filter_free_fn = free;
157	return d;
158	}
159
160	/*
161	* A filter driven by a sparse-checkout specification to only
162	* include blobs that a sparse checkout would populate.
163	*
164	* The sparse-checkout spec can be loaded from a blob with the
165	* given OID or from a local pathname. We allow an OID because
166	* the repo may be bare or we may be doing the filtering on the
167	* server.
168	*/
169	struct frame {
170	/*
171	* defval is the usual default include/exclude value that
172	* should be inherited as we recurse into directories based
173	* upon pattern matching of the directory itself or of a
174	* containing directory.
175	*/
176	int defval;
177
178	/*
179	* 1 if the directory (recursively) contains any provisionally
180	* omitted objects.
181	*
182	* 0 if everything (recursively) contained in this directory
183	* has been explicitly included (SHOWN) in the result and
184	* the directory may be short-cut later in the traversal.
185	*/
186	unsigned child_prov_omit : 1;
187	};
188
189	struct filter_sparse_data {
190	struct oidset *omits;
191	struct exclude_list el;
192
193	size_t nr, alloc;
194	struct frame *array_frame;
195	};
196
197	static enum list_objects_filter_result filter_sparse(
198	enum list_objects_filter_situation filter_situation,
199	struct object *obj,
200	const char *pathname,
201	const char *filename,
202	void *filter_data_)
203	{
204	struct filter_sparse_data *filter_data = filter_data_;
205	int val, dtype;
206	struct frame *frame;
207
208	switch (filter_situation) {
209	default:
210	die("unknown filter_situation");
211	return LOFR_ZERO;
212
213	case LOFS_BEGIN_TREE:
214	assert(obj->type == OBJ_TREE);
215	dtype = DT_DIR;
216	val = is_excluded_from_list(pathname, strlen(pathname),
217	filename, &dtype, &filter_data->el,
218	&the_index);
219	if (val < 0)
220	val = filter_data->array_frame[filter_data->nr].defval;
221
222	ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1,
223	filter_data->alloc);
224	filter_data->nr++;
225	filter_data->array_frame[filter_data->nr].defval = val;
226	filter_data->array_frame[filter_data->nr].child_prov_omit = 0;
227
228	/*
229	* A directory with this tree OID may appear in multiple
230	* places in the tree. (Think of a directory move or copy,
231	* with no other changes, so the OID is the same, but the
232	* full pathnames of objects within this directory are new
233	* and may match is_excluded() patterns differently.)
234	* So we cannot mark this directory as SEEN (yet), since
235	* that will prevent process_tree() from revisiting this
236	* tree object with other pathname prefixes.
237	*
238	* Only _DO_SHOW the tree object the first time we visit
239	* this tree object.
240	*
241	* We always show all tree objects. A future optimization
242	* may want to attempt to narrow this.
243	*/
244	if (obj->flags & FILTER_SHOWN_BUT_REVISIT)
245	return LOFR_ZERO;
246	obj->flags \|= FILTER_SHOWN_BUT_REVISIT;
247	return LOFR_DO_SHOW;
248
249	case LOFS_END_TREE:
250	assert(obj->type == OBJ_TREE);
251	assert(filter_data->nr > 0);
252
253	frame = &filter_data->array_frame[filter_data->nr];
254	filter_data->nr--;
255
256	/*
257	* Tell our parent directory if any of our children were
258	* provisionally omitted.
259	*/
260	filter_data->array_frame[filter_data->nr].child_prov_omit \|=
261	frame->child_prov_omit;
262
263	/*
264	* If there are NO provisionally omitted child objects (ALL child
265	* objects in this folder were INCLUDED), then we can mark the
266	* folder as SEEN (so we will not have to revisit it again).
267	*/
268	if (!frame->child_prov_omit)
269	return LOFR_MARK_SEEN;
270	return LOFR_ZERO;
271
272	case LOFS_BLOB:
273	assert(obj->type == OBJ_BLOB);
274	assert((obj->flags & SEEN) == 0);
275
276	frame = &filter_data->array_frame[filter_data->nr];
277
278	dtype = DT_REG;
279	val = is_excluded_from_list(pathname, strlen(pathname),
280	filename, &dtype, &filter_data->el,
281	&the_index);
282	if (val < 0)
283	val = frame->defval;
284	if (val > 0) {
285	if (filter_data->omits)
286	oidset_remove(filter_data->omits, &obj->oid);
287	return LOFR_MARK_SEEN \| LOFR_DO_SHOW;
288	}
289
290	/*
291	* Provisionally omit it. We've already established that
292	* this pathname is not in the sparse-checkout specification
293	* with the CURRENT pathname, so we WANT to omit this blob.
294	*
295	* However, a pathname elsewhere in the tree may also
296	* reference this same blob, so we cannot reject it yet.
297	* Leave the LOFR_ bits unset so that if the blob appears
298	* again in the traversal, we will be asked again.
299	*/
300	if (filter_data->omits)
301	oidset_insert(filter_data->omits, &obj->oid);
302
303	/*
304	* Remember that at least 1 blob in this tree was
305	* provisionally omitted. This prevents us from short
306	* cutting the tree in future iterations.
307	*/
308	frame->child_prov_omit = 1;
309	return LOFR_ZERO;
310	}
311	}
312
313
314	static void filter_sparse_free(void *filter_data)
315	{
316	struct filter_sparse_data *d = filter_data;
317	/* TODO free contents of 'd' */
318	free(d);
319	}
320
321	static void *filter_sparse_oid__init(
322	struct oidset *omitted,
323	struct list_objects_filter_options *filter_options,
324	filter_object_fn *filter_fn,
325	filter_free_fn *filter_free_fn)
326	{
327	struct filter_sparse_data d = xcalloc(1, sizeof(d));
328	d->omits = omitted;
329	if (add_excludes_from_blob_to_list(filter_options->sparse_oid_value,
330	NULL, 0, &d->el) < 0)
331	die("could not load filter specification");
332
333	ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
334	d->array_frame[d->nr].defval = 0; /* default to include */
335	d->array_frame[d->nr].child_prov_omit = 0;
336
337	*filter_fn = filter_sparse;
338	*filter_free_fn = filter_sparse_free;
339	return d;
340	}
341
342	static void *filter_sparse_path__init(
343	struct oidset *omitted,
344	struct list_objects_filter_options *filter_options,
345	filter_object_fn *filter_fn,
346	filter_free_fn *filter_free_fn)
347	{
348	struct filter_sparse_data d = xcalloc(1, sizeof(d));
349	d->omits = omitted;
350	if (add_excludes_from_file_to_list(filter_options->sparse_path_value,
351	NULL, 0, &d->el, NULL) < 0)
352	die("could not load filter specification");
353
354	ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
355	d->array_frame[d->nr].defval = 0; /* default to include */
356	d->array_frame[d->nr].child_prov_omit = 0;
357
358	*filter_fn = filter_sparse;
359	*filter_free_fn = filter_sparse_free;
360	return d;
361	}
362
363	typedef void (filter_init_fn)(
364	struct oidset *omitted,
365	struct list_objects_filter_options *filter_options,
366	filter_object_fn *filter_fn,
367	filter_free_fn *filter_free_fn);
368
369	/*
370	* Must match "enum list_objects_filter_choice".
371	*/
372	static filter_init_fn s_filters[] = {
373	NULL,
374	filter_blobs_none__init,
375	filter_blobs_limit__init,
376	filter_sparse_oid__init,
377	filter_sparse_path__init,
378	};
379
380	void *list_objects_filter__init(
381	struct oidset *omitted,
382	struct list_objects_filter_options *filter_options,
383	filter_object_fn *filter_fn,
384	filter_free_fn *filter_free_fn)
385	{
386	filter_init_fn init_fn;
387
388	assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
389
390	if (filter_options->choice >= LOFC__COUNT)
391	die("invalid list-objects filter choice: %d",
392	filter_options->choice);
393
394	init_fn = s_filters[filter_options->choice];
395	if (init_fn)
396	return init_fn(omitted, filter_options,
397	filter_fn, filter_free_fn);
398	*filter_fn = NULL;
399	*filter_free_fn = NULL;
400	return NULL;
401	}