freshlybakedca.ke
Git fork
1#define USE_THE_REPOSITORY_VARIABLE
2
3#include "git-compat-util.h"
4#include "dir.h"
5#include "gettext.h"
6#include "hex.h"
7#include "commit.h"
8#include "diff.h"
9#include "revision.h"
10#include "list-objects-filter.h"
11#include "list-objects-filter-options.h"
12#include "oidmap.h"
13#include "oidset.h"
14#include "object-name.h"
15#include "odb.h"
16
17/* Remember to update object flag allocation in object.h */
18/*
19 * FILTER_SHOWN_BUT_REVISIT -- we set this bit on tree objects
20 * that have been shown, but should be revisited if they appear
21 * in the traversal (until we mark it SEEN). This is a way to
22 * let us silently de-dup calls to show() in the caller. This
23 * is subtly different from the "revision.h:SHOWN" and the
24 * "object-name.c:ONELINE_SEEN" bits. And also different from
25 * the non-de-dup usage in pack-bitmap.c
26 */
27#define FILTER_SHOWN_BUT_REVISIT (1<<21)
28
29struct subfilter {
30 struct filter *filter;
31 struct oidset seen;
32 struct oidset omits;
33 struct object_id skip_tree;
34 unsigned is_skipping_tree : 1;
35};
36
37struct filter {
38 enum list_objects_filter_result (*filter_object_fn)(
39 struct repository *r,
40 enum list_objects_filter_situation filter_situation,
41 struct object *obj,
42 const char *pathname,
43 const char *filename,
44 struct oidset *omits,
45 void *filter_data);
46
47 /*
48 * Optional. If this function is supplied and the filter needs
49 * to collect omits, then this function is called once before
50 * free_fn is called.
51 *
52 * This is required because the following two conditions hold:
53 *
54 * a. A tree filter can add and remove objects as an object
55 * graph is traversed.
56 * b. A combine filter's omit set is the union of all its
57 * subfilters, which may include tree: filters.
58 *
59 * As such, the omits sets must be separate sets, and can only
60 * be unioned after the traversal is completed.
61 */
62 void (*finalize_omits_fn)(struct oidset *omits, void *filter_data);
63
64 void (*free_fn)(void *filter_data);
65
66 void *filter_data;
67
68 /* If non-NULL, the filter collects a list of the omitted OIDs here. */
69 struct oidset *omits;
70};
71
72static enum list_objects_filter_result filter_blobs_none(
73 struct repository *r UNUSED,
74 enum list_objects_filter_situation filter_situation,
75 struct object *obj,
76 const char *pathname UNUSED,
77 const char *filename UNUSED,
78 struct oidset *omits,
79 void *filter_data_ UNUSED)
80{
81 switch (filter_situation) {
82 default:
83 BUG("unknown filter_situation: %d", filter_situation);
84
85 case LOFS_TAG:
86 assert(obj->type == OBJ_TAG);
87 /* always include all tag objects */
88 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
89
90 case LOFS_COMMIT:
91 assert(obj->type == OBJ_COMMIT);
92 /* always include all commit objects */
93 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
94
95 case LOFS_BEGIN_TREE:
96 assert(obj->type == OBJ_TREE);
97 /* always include all tree objects */
98 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
99
100 case LOFS_END_TREE:
101 assert(obj->type == OBJ_TREE);
102 return LOFR_ZERO;
103
104 case LOFS_BLOB:
105 assert(obj->type == OBJ_BLOB);
106 assert((obj->flags & SEEN) == 0);
107
108 if (omits)
109 oidset_insert(omits, &obj->oid);
110 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
111 }
112}
113
114static void filter_blobs_none__init(
115 struct list_objects_filter_options *filter_options UNUSED,
116 struct filter *filter)
117{
118 filter->filter_object_fn = filter_blobs_none;
119 filter->free_fn = free;
120}
121
122/*
123 * A filter for list-objects to omit ALL trees and blobs from the traversal.
124 * Can OPTIONALLY collect a list of the omitted OIDs.
125 */
126struct filter_trees_depth_data {
127 /*
128 * Maps trees to the minimum depth at which they were seen. It is not
129 * necessary to re-traverse a tree at deeper or equal depths than it has
130 * already been traversed.
131 *
132 * We can't use LOFR_MARK_SEEN for tree objects since this will prevent
133 * it from being traversed at shallower depths.
134 */
135 struct oidmap seen_at_depth;
136
137 unsigned long exclude_depth;
138 unsigned long current_depth;
139};
140
141struct seen_map_entry {
142 struct oidmap_entry base;
143 size_t depth;
144};
145
146/* Returns 1 if the oid was in the omits set before it was invoked. */
147static int filter_trees_update_omits(
148 struct object *obj,
149 struct oidset *omits,
150 int include_it)
151{
152 if (!omits)
153 return 0;
154
155 if (include_it)
156 return oidset_remove(omits, &obj->oid);
157 else
158 return oidset_insert(omits, &obj->oid);
159}
160
161static enum list_objects_filter_result filter_trees_depth(
162 struct repository *r UNUSED,
163 enum list_objects_filter_situation filter_situation,
164 struct object *obj,
165 const char *pathname UNUSED,
166 const char *filename UNUSED,
167 struct oidset *omits,
168 void *filter_data_)
169{
170 struct filter_trees_depth_data *filter_data = filter_data_;
171 struct seen_map_entry *seen_info;
172 int include_it = filter_data->current_depth <
173 filter_data->exclude_depth;
174 int filter_res;
175 int already_seen;
176
177 /*
178 * Note that we do not use _MARK_SEEN in order to allow re-traversal in
179 * case we encounter a tree or blob again at a shallower depth.
180 */
181
182 switch (filter_situation) {
183 default:
184 BUG("unknown filter_situation: %d", filter_situation);
185
186 case LOFS_TAG:
187 assert(obj->type == OBJ_TAG);
188 /* always include all tag objects */
189 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
190
191 case LOFS_COMMIT:
192 assert(obj->type == OBJ_COMMIT);
193 /* always include all commit objects */
194 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
195
196 case LOFS_END_TREE:
197 assert(obj->type == OBJ_TREE);
198 filter_data->current_depth--;
199 return LOFR_ZERO;
200
201 case LOFS_BLOB:
202 filter_trees_update_omits(obj, omits, include_it);
203 return include_it ? LOFR_MARK_SEEN | LOFR_DO_SHOW : LOFR_ZERO;
204
205 case LOFS_BEGIN_TREE:
206 seen_info = oidmap_get(
207 &filter_data->seen_at_depth, &obj->oid);
208 if (!seen_info) {
209 CALLOC_ARRAY(seen_info, 1);
210 oidcpy(&seen_info->base.oid, &obj->oid);
211 seen_info->depth = filter_data->current_depth;
212 oidmap_put(&filter_data->seen_at_depth, seen_info);
213 already_seen = 0;
214 } else {
215 already_seen =
216 filter_data->current_depth >= seen_info->depth;
217 }
218
219 if (already_seen) {
220 filter_res = LOFR_SKIP_TREE;
221 } else {
222 int been_omitted = filter_trees_update_omits(
223 obj, omits, include_it);
224 seen_info->depth = filter_data->current_depth;
225
226 if (include_it)
227 filter_res = LOFR_DO_SHOW;
228 else if (omits && !been_omitted)
229 /*
230 * Must update omit information of children
231 * recursively; they have not been omitted yet.
232 */
233 filter_res = LOFR_ZERO;
234 else
235 filter_res = LOFR_SKIP_TREE;
236 }
237
238 filter_data->current_depth++;
239 return filter_res;
240 }
241}
242
243static void filter_trees_free(void *filter_data) {
244 struct filter_trees_depth_data *d = filter_data;
245 if (!d)
246 return;
247 oidmap_clear(&d->seen_at_depth, 1);
248 free(d);
249}
250
251static void filter_trees_depth__init(
252 struct list_objects_filter_options *filter_options,
253 struct filter *filter)
254{
255 struct filter_trees_depth_data *d = xcalloc(1, sizeof(*d));
256 oidmap_init(&d->seen_at_depth, 0);
257 d->exclude_depth = filter_options->tree_exclude_depth;
258 d->current_depth = 0;
259
260 filter->filter_data = d;
261 filter->filter_object_fn = filter_trees_depth;
262 filter->free_fn = filter_trees_free;
263}
264
265/*
266 * A filter for list-objects to omit large blobs.
267 * And to OPTIONALLY collect a list of the omitted OIDs.
268 */
269struct filter_blobs_limit_data {
270 unsigned long max_bytes;
271};
272
273static enum list_objects_filter_result filter_blobs_limit(
274 struct repository *r,
275 enum list_objects_filter_situation filter_situation,
276 struct object *obj,
277 const char *pathname UNUSED,
278 const char *filename UNUSED,
279 struct oidset *omits,
280 void *filter_data_)
281{
282 struct filter_blobs_limit_data *filter_data = filter_data_;
283 unsigned long object_length;
284 enum object_type t;
285
286 switch (filter_situation) {
287 default:
288 BUG("unknown filter_situation: %d", filter_situation);
289
290 case LOFS_TAG:
291 assert(obj->type == OBJ_TAG);
292 /* always include all tag objects */
293 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
294
295 case LOFS_COMMIT:
296 assert(obj->type == OBJ_COMMIT);
297 /* always include all commit objects */
298 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
299
300 case LOFS_BEGIN_TREE:
301 assert(obj->type == OBJ_TREE);
302 /* always include all tree objects */
303 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
304
305 case LOFS_END_TREE:
306 assert(obj->type == OBJ_TREE);
307 return LOFR_ZERO;
308
309 case LOFS_BLOB:
310 assert(obj->type == OBJ_BLOB);
311 assert((obj->flags & SEEN) == 0);
312
313 t = odb_read_object_info(r->objects, &obj->oid, &object_length);
314 if (t != OBJ_BLOB) { /* probably OBJ_NONE */
315 /*
316 * We DO NOT have the blob locally, so we cannot
317 * apply the size filter criteria. Be conservative
318 * and force show it (and let the caller deal with
319 * the ambiguity).
320 */
321 goto include_it;
322 }
323
324 if (object_length < filter_data->max_bytes)
325 goto include_it;
326
327 if (omits)
328 oidset_insert(omits, &obj->oid);
329 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
330 }
331
332include_it:
333 if (omits)
334 oidset_remove(omits, &obj->oid);
335 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
336}
337
338static void filter_blobs_limit__init(
339 struct list_objects_filter_options *filter_options,
340 struct filter *filter)
341{
342 struct filter_blobs_limit_data *d = xcalloc(1, sizeof(*d));
343 d->max_bytes = filter_options->blob_limit_value;
344
345 filter->filter_data = d;
346 filter->filter_object_fn = filter_blobs_limit;
347 filter->free_fn = free;
348}
349
350/*
351 * A filter driven by a sparse-checkout specification to only
352 * include blobs that a sparse checkout would populate.
353 *
354 * The sparse-checkout spec can be loaded from a blob with the
355 * given OID or from a local pathname. We allow an OID because
356 * the repo may be bare or we may be doing the filtering on the
357 * server.
358 */
359struct frame {
360 /*
361 * default_match is the usual default include/exclude value that
362 * should be inherited as we recurse into directories based
363 * upon pattern matching of the directory itself or of a
364 * containing directory.
365 */
366 enum pattern_match_result default_match;
367
368 /*
369 * 1 if the directory (recursively) contains any provisionally
370 * omitted objects.
371 *
372 * 0 if everything (recursively) contained in this directory
373 * has been explicitly included (SHOWN) in the result and
374 * the directory may be short-cut later in the traversal.
375 */
376 unsigned child_prov_omit : 1;
377};
378
379struct filter_sparse_data {
380 struct pattern_list pl;
381
382 size_t nr, alloc;
383 struct frame *array_frame;
384};
385
386static enum list_objects_filter_result filter_sparse(
387 struct repository *r,
388 enum list_objects_filter_situation filter_situation,
389 struct object *obj,
390 const char *pathname,
391 const char *filename,
392 struct oidset *omits,
393 void *filter_data_)
394{
395 struct filter_sparse_data *filter_data = filter_data_;
396 int dtype;
397 struct frame *frame;
398 enum pattern_match_result match;
399
400 switch (filter_situation) {
401 default:
402 BUG("unknown filter_situation: %d", filter_situation);
403
404 case LOFS_TAG:
405 assert(obj->type == OBJ_TAG);
406 /* always include all tag objects */
407 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
408
409 case LOFS_COMMIT:
410 assert(obj->type == OBJ_COMMIT);
411 /* always include all commit objects */
412 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
413
414 case LOFS_BEGIN_TREE:
415 assert(obj->type == OBJ_TREE);
416 dtype = DT_DIR;
417 match = path_matches_pattern_list(pathname, strlen(pathname),
418 filename, &dtype, &filter_data->pl,
419 r->index);
420 if (match == UNDECIDED)
421 match = filter_data->array_frame[filter_data->nr - 1].default_match;
422
423 ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1,
424 filter_data->alloc);
425 filter_data->array_frame[filter_data->nr].default_match = match;
426 filter_data->array_frame[filter_data->nr].child_prov_omit = 0;
427 filter_data->nr++;
428
429 /*
430 * A directory with this tree OID may appear in multiple
431 * places in the tree. (Think of a directory move or copy,
432 * with no other changes, so the OID is the same, but the
433 * full pathnames of objects within this directory are new
434 * and may match is_excluded() patterns differently.)
435 * So we cannot mark this directory as SEEN (yet), since
436 * that will prevent process_tree() from revisiting this
437 * tree object with other pathname prefixes.
438 *
439 * Only _DO_SHOW the tree object the first time we visit
440 * this tree object.
441 *
442 * We always show all tree objects. A future optimization
443 * may want to attempt to narrow this.
444 */
445 if (obj->flags & FILTER_SHOWN_BUT_REVISIT)
446 return LOFR_ZERO;
447 obj->flags |= FILTER_SHOWN_BUT_REVISIT;
448 return LOFR_DO_SHOW;
449
450 case LOFS_END_TREE:
451 assert(obj->type == OBJ_TREE);
452 assert(filter_data->nr > 1);
453
454 frame = &filter_data->array_frame[--filter_data->nr];
455
456 /*
457 * Tell our parent directory if any of our children were
458 * provisionally omitted.
459 */
460 filter_data->array_frame[filter_data->nr - 1].child_prov_omit |=
461 frame->child_prov_omit;
462
463 /*
464 * If there are NO provisionally omitted child objects (ALL child
465 * objects in this folder were INCLUDED), then we can mark the
466 * folder as SEEN (so we will not have to revisit it again).
467 */
468 if (!frame->child_prov_omit)
469 return LOFR_MARK_SEEN;
470 return LOFR_ZERO;
471
472 case LOFS_BLOB:
473 assert(obj->type == OBJ_BLOB);
474 assert((obj->flags & SEEN) == 0);
475
476 frame = &filter_data->array_frame[filter_data->nr - 1];
477
478 dtype = DT_REG;
479 match = path_matches_pattern_list(pathname, strlen(pathname),
480 filename, &dtype, &filter_data->pl,
481 r->index);
482 if (match == UNDECIDED)
483 match = frame->default_match;
484 if (match == MATCHED) {
485 if (omits)
486 oidset_remove(omits, &obj->oid);
487 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
488 }
489
490 /*
491 * Provisionally omit it. We've already established that
492 * this pathname is not in the sparse-checkout specification
493 * with the CURRENT pathname, so we *WANT* to omit this blob.
494 *
495 * However, a pathname elsewhere in the tree may also
496 * reference this same blob, so we cannot reject it yet.
497 * Leave the LOFR_ bits unset so that if the blob appears
498 * again in the traversal, we will be asked again.
499 */
500 if (omits)
501 oidset_insert(omits, &obj->oid);
502
503 /*
504 * Remember that at least 1 blob in this tree was
505 * provisionally omitted. This prevents us from short
506 * cutting the tree in future iterations.
507 */
508 frame->child_prov_omit = 1;
509 return LOFR_ZERO;
510 }
511}
512
513
514static void filter_sparse_free(void *filter_data)
515{
516 struct filter_sparse_data *d = filter_data;
517 clear_pattern_list(&d->pl);
518 free(d->array_frame);
519 free(d);
520}
521
522static void filter_sparse_oid__init(
523 struct list_objects_filter_options *filter_options,
524 struct filter *filter)
525{
526 struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
527 struct object_id sparse_oid;
528
529 if (repo_get_oid_with_flags(the_repository,
530 filter_options->sparse_oid_name,
531 &sparse_oid, GET_OID_BLOB))
532 die(_("unable to access sparse blob in '%s'"),
533 filter_options->sparse_oid_name);
534 if (add_patterns_from_blob_to_list(&sparse_oid, "", 0, &d->pl) < 0)
535 die(_("unable to parse sparse filter data in %s"),
536 oid_to_hex(&sparse_oid));
537
538 ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
539 d->array_frame[d->nr].default_match = 0; /* default to include */
540 d->array_frame[d->nr].child_prov_omit = 0;
541 d->nr++;
542
543 filter->filter_data = d;
544 filter->filter_object_fn = filter_sparse;
545 filter->free_fn = filter_sparse_free;
546}
547
548/*
549 * A filter for list-objects to omit large blobs.
550 * And to OPTIONALLY collect a list of the omitted OIDs.
551 */
552struct filter_object_type_data {
553 enum object_type object_type;
554};
555
556static enum list_objects_filter_result filter_object_type(
557 struct repository *r UNUSED,
558 enum list_objects_filter_situation filter_situation,
559 struct object *obj,
560 const char *pathname UNUSED,
561 const char *filename UNUSED,
562 struct oidset *omits UNUSED,
563 void *filter_data_)
564{
565 struct filter_object_type_data *filter_data = filter_data_;
566
567 switch (filter_situation) {
568 default:
569 BUG("unknown filter_situation: %d", filter_situation);
570
571 case LOFS_TAG:
572 assert(obj->type == OBJ_TAG);
573 if (filter_data->object_type == OBJ_TAG)
574 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
575 return LOFR_MARK_SEEN;
576
577 case LOFS_COMMIT:
578 assert(obj->type == OBJ_COMMIT);
579 if (filter_data->object_type == OBJ_COMMIT)
580 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
581 return LOFR_MARK_SEEN;
582
583 case LOFS_BEGIN_TREE:
584 assert(obj->type == OBJ_TREE);
585
586 /*
587 * If we only want to show commits or tags, then there is no
588 * need to walk down trees.
589 */
590 if (filter_data->object_type == OBJ_COMMIT ||
591 filter_data->object_type == OBJ_TAG)
592 return LOFR_SKIP_TREE;
593
594 if (filter_data->object_type == OBJ_TREE)
595 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
596
597 return LOFR_MARK_SEEN;
598
599 case LOFS_BLOB:
600 assert(obj->type == OBJ_BLOB);
601
602 if (filter_data->object_type == OBJ_BLOB)
603 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
604 return LOFR_MARK_SEEN;
605
606 case LOFS_END_TREE:
607 return LOFR_ZERO;
608 }
609}
610
611static void filter_object_type__init(
612 struct list_objects_filter_options *filter_options,
613 struct filter *filter)
614{
615 struct filter_object_type_data *d = xcalloc(1, sizeof(*d));
616 d->object_type = filter_options->object_type;
617
618 filter->filter_data = d;
619 filter->filter_object_fn = filter_object_type;
620 filter->free_fn = free;
621}
622
623/* A filter which only shows objects shown by all sub-filters. */
624struct combine_filter_data {
625 struct subfilter *sub;
626 size_t nr;
627};
628
629static enum list_objects_filter_result process_subfilter(
630 struct repository *r,
631 enum list_objects_filter_situation filter_situation,
632 struct object *obj,
633 const char *pathname,
634 const char *filename,
635 struct subfilter *sub)
636{
637 enum list_objects_filter_result result;
638
639 /*
640 * Check and update is_skipping_tree before oidset_contains so
641 * that is_skipping_tree gets unset even when the object is
642 * marked as seen. As of this writing, no filter uses
643 * LOFR_MARK_SEEN on trees that also uses LOFR_SKIP_TREE, so the
644 * ordering is only theoretically important. Be cautious if you
645 * change the order of the below checks and more filters have
646 * been added!
647 */
648 if (sub->is_skipping_tree) {
649 if (filter_situation == LOFS_END_TREE &&
650 oideq(&obj->oid, &sub->skip_tree))
651 sub->is_skipping_tree = 0;
652 else
653 return LOFR_ZERO;
654 }
655 if (oidset_contains(&sub->seen, &obj->oid))
656 return LOFR_ZERO;
657
658 result = list_objects_filter__filter_object(
659 r, filter_situation, obj, pathname, filename, sub->filter);
660
661 if (result & LOFR_MARK_SEEN)
662 oidset_insert(&sub->seen, &obj->oid);
663
664 if (result & LOFR_SKIP_TREE) {
665 sub->is_skipping_tree = 1;
666 sub->skip_tree = obj->oid;
667 }
668
669 return result;
670}
671
672static enum list_objects_filter_result filter_combine(
673 struct repository *r,
674 enum list_objects_filter_situation filter_situation,
675 struct object *obj,
676 const char *pathname,
677 const char *filename,
678 struct oidset *omits UNUSED,
679 void *filter_data)
680{
681 struct combine_filter_data *d = filter_data;
682 enum list_objects_filter_result combined_result =
683 LOFR_DO_SHOW | LOFR_MARK_SEEN | LOFR_SKIP_TREE;
684 size_t sub;
685
686 for (sub = 0; sub < d->nr; sub++) {
687 enum list_objects_filter_result sub_result = process_subfilter(
688 r, filter_situation, obj, pathname, filename,
689 &d->sub[sub]);
690 if (!(sub_result & LOFR_DO_SHOW))
691 combined_result &= ~LOFR_DO_SHOW;
692 if (!(sub_result & LOFR_MARK_SEEN))
693 combined_result &= ~LOFR_MARK_SEEN;
694 if (!d->sub[sub].is_skipping_tree)
695 combined_result &= ~LOFR_SKIP_TREE;
696 }
697
698 return combined_result;
699}
700
701static void filter_combine__free(void *filter_data)
702{
703 struct combine_filter_data *d = filter_data;
704 size_t sub;
705 for (sub = 0; sub < d->nr; sub++) {
706 list_objects_filter__free(d->sub[sub].filter);
707 oidset_clear(&d->sub[sub].seen);
708 if (d->sub[sub].omits.set.size)
709 BUG("expected oidset to be cleared already");
710 }
711 free(d->sub);
712 free(d);
713}
714
715static void filter_combine__finalize_omits(
716 struct oidset *omits,
717 void *filter_data)
718{
719 struct combine_filter_data *d = filter_data;
720 size_t sub;
721
722 for (sub = 0; sub < d->nr; sub++) {
723 oidset_insert_from_set(omits, &d->sub[sub].omits);
724 oidset_clear(&d->sub[sub].omits);
725 }
726}
727
728static void filter_combine__init(
729 struct list_objects_filter_options *filter_options,
730 struct filter* filter)
731{
732 struct combine_filter_data *d = xcalloc(1, sizeof(*d));
733 size_t sub;
734
735 d->nr = filter_options->sub_nr;
736 CALLOC_ARRAY(d->sub, d->nr);
737 for (sub = 0; sub < d->nr; sub++)
738 d->sub[sub].filter = list_objects_filter__init(
739 filter->omits ? &d->sub[sub].omits : NULL,
740 &filter_options->sub[sub]);
741
742 filter->filter_data = d;
743 filter->filter_object_fn = filter_combine;
744 filter->free_fn = filter_combine__free;
745 filter->finalize_omits_fn = filter_combine__finalize_omits;
746}
747
748typedef void (*filter_init_fn)(
749 struct list_objects_filter_options *filter_options,
750 struct filter *filter);
751
752/*
753 * Must match "enum list_objects_filter_choice".
754 */
755static filter_init_fn s_filters[] = {
756 NULL,
757 filter_blobs_none__init,
758 filter_blobs_limit__init,
759 filter_trees_depth__init,
760 filter_sparse_oid__init,
761 filter_object_type__init,
762 filter_combine__init,
763};
764
765struct filter *list_objects_filter__init(
766 struct oidset *omitted,
767 struct list_objects_filter_options *filter_options)
768{
769 struct filter *filter;
770 filter_init_fn init_fn;
771
772 assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
773
774 if (!filter_options)
775 return NULL;
776
777 if (filter_options->choice >= LOFC__COUNT)
778 BUG("invalid list-objects filter choice: %d",
779 filter_options->choice);
780
781 init_fn = s_filters[filter_options->choice];
782 if (!init_fn)
783 return NULL;
784
785 CALLOC_ARRAY(filter, 1);
786 filter->omits = omitted;
787 init_fn(filter_options, filter);
788 return filter;
789}
790
791enum list_objects_filter_result list_objects_filter__filter_object(
792 struct repository *r,
793 enum list_objects_filter_situation filter_situation,
794 struct object *obj,
795 const char *pathname,
796 const char *filename,
797 struct filter *filter)
798{
799 if (filter && (obj->flags & NOT_USER_GIVEN))
800 return filter->filter_object_fn(r, filter_situation, obj,
801 pathname, filename,
802 filter->omits,
803 filter->filter_data);
804 /*
805 * No filter is active or user gave object explicitly. In this case,
806 * always show the object (except when LOFS_END_TREE, since this tree
807 * had already been shown when LOFS_BEGIN_TREE).
808 */
809 if (filter_situation == LOFS_END_TREE)
810 return 0;
811 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
812}
813
814void list_objects_filter__free(struct filter *filter)
815{
816 if (!filter)
817 return;
818 if (filter->finalize_omits_fn && filter->omits)
819 filter->finalize_omits_fn(filter->omits, filter->filter_data);
820 filter->free_fn(filter->filter_data);
821 free(filter);
822}