]>
Commit | Line | Data |
---|---|---|
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 "oidmap.h" | |
14 | #include "oidset.h" | |
15 | #include "object-store.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 | * "sha1-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 | ||
29 | struct 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 | ||
37 | struct 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 | ||
72 | static enum list_objects_filter_result filter_blobs_none( | |
73 | struct repository *r, | |
74 | enum list_objects_filter_situation filter_situation, | |
75 | struct object *obj, | |
76 | const char *pathname, | |
77 | const char *filename, | |
78 | struct oidset *omits, | |
79 | void *filter_data_) | |
80 | { | |
81 | switch (filter_situation) { | |
82 | default: | |
83 | BUG("unknown filter_situation: %d", filter_situation); | |
84 | ||
85 | case LOFS_BEGIN_TREE: | |
86 | assert(obj->type == OBJ_TREE); | |
87 | /* always include all tree objects */ | |
88 | return LOFR_MARK_SEEN | LOFR_DO_SHOW; | |
89 | ||
90 | case LOFS_END_TREE: | |
91 | assert(obj->type == OBJ_TREE); | |
92 | return LOFR_ZERO; | |
93 | ||
94 | case LOFS_BLOB: | |
95 | assert(obj->type == OBJ_BLOB); | |
96 | assert((obj->flags & SEEN) == 0); | |
97 | ||
98 | if (omits) | |
99 | oidset_insert(omits, &obj->oid); | |
100 | return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */ | |
101 | } | |
102 | } | |
103 | ||
104 | static void filter_blobs_none__init( | |
105 | struct list_objects_filter_options *filter_options, | |
106 | struct filter *filter) | |
107 | { | |
108 | filter->filter_object_fn = filter_blobs_none; | |
109 | filter->free_fn = free; | |
110 | } | |
111 | ||
112 | /* | |
113 | * A filter for list-objects to omit ALL trees and blobs from the traversal. | |
114 | * Can OPTIONALLY collect a list of the omitted OIDs. | |
115 | */ | |
116 | struct filter_trees_depth_data { | |
117 | /* | |
118 | * Maps trees to the minimum depth at which they were seen. It is not | |
119 | * necessary to re-traverse a tree at deeper or equal depths than it has | |
120 | * already been traversed. | |
121 | * | |
122 | * We can't use LOFR_MARK_SEEN for tree objects since this will prevent | |
123 | * it from being traversed at shallower depths. | |
124 | */ | |
125 | struct oidmap seen_at_depth; | |
126 | ||
127 | unsigned long exclude_depth; | |
128 | unsigned long current_depth; | |
129 | }; | |
130 | ||
131 | struct seen_map_entry { | |
132 | struct oidmap_entry base; | |
133 | size_t depth; | |
134 | }; | |
135 | ||
136 | /* Returns 1 if the oid was in the omits set before it was invoked. */ | |
137 | static int filter_trees_update_omits( | |
138 | struct object *obj, | |
139 | struct oidset *omits, | |
140 | int include_it) | |
141 | { | |
142 | if (!omits) | |
143 | return 0; | |
144 | ||
145 | if (include_it) | |
146 | return oidset_remove(omits, &obj->oid); | |
147 | else | |
148 | return oidset_insert(omits, &obj->oid); | |
149 | } | |
150 | ||
151 | static enum list_objects_filter_result filter_trees_depth( | |
152 | struct repository *r, | |
153 | enum list_objects_filter_situation filter_situation, | |
154 | struct object *obj, | |
155 | const char *pathname, | |
156 | const char *filename, | |
157 | struct oidset *omits, | |
158 | void *filter_data_) | |
159 | { | |
160 | struct filter_trees_depth_data *filter_data = filter_data_; | |
161 | struct seen_map_entry *seen_info; | |
162 | int include_it = filter_data->current_depth < | |
163 | filter_data->exclude_depth; | |
164 | int filter_res; | |
165 | int already_seen; | |
166 | ||
167 | /* | |
168 | * Note that we do not use _MARK_SEEN in order to allow re-traversal in | |
169 | * case we encounter a tree or blob again at a shallower depth. | |
170 | */ | |
171 | ||
172 | switch (filter_situation) { | |
173 | default: | |
174 | BUG("unknown filter_situation: %d", filter_situation); | |
175 | ||
176 | case LOFS_END_TREE: | |
177 | assert(obj->type == OBJ_TREE); | |
178 | filter_data->current_depth--; | |
179 | return LOFR_ZERO; | |
180 | ||
181 | case LOFS_BLOB: | |
182 | filter_trees_update_omits(obj, omits, include_it); | |
183 | return include_it ? LOFR_MARK_SEEN | LOFR_DO_SHOW : LOFR_ZERO; | |
184 | ||
185 | case LOFS_BEGIN_TREE: | |
186 | seen_info = oidmap_get( | |
187 | &filter_data->seen_at_depth, &obj->oid); | |
188 | if (!seen_info) { | |
189 | seen_info = xcalloc(1, sizeof(*seen_info)); | |
190 | oidcpy(&seen_info->base.oid, &obj->oid); | |
191 | seen_info->depth = filter_data->current_depth; | |
192 | oidmap_put(&filter_data->seen_at_depth, seen_info); | |
193 | already_seen = 0; | |
194 | } else { | |
195 | already_seen = | |
196 | filter_data->current_depth >= seen_info->depth; | |
197 | } | |
198 | ||
199 | if (already_seen) { | |
200 | filter_res = LOFR_SKIP_TREE; | |
201 | } else { | |
202 | int been_omitted = filter_trees_update_omits( | |
203 | obj, omits, include_it); | |
204 | seen_info->depth = filter_data->current_depth; | |
205 | ||
206 | if (include_it) | |
207 | filter_res = LOFR_DO_SHOW; | |
208 | else if (omits && !been_omitted) | |
209 | /* | |
210 | * Must update omit information of children | |
211 | * recursively; they have not been omitted yet. | |
212 | */ | |
213 | filter_res = LOFR_ZERO; | |
214 | else | |
215 | filter_res = LOFR_SKIP_TREE; | |
216 | } | |
217 | ||
218 | filter_data->current_depth++; | |
219 | return filter_res; | |
220 | } | |
221 | } | |
222 | ||
223 | static void filter_trees_free(void *filter_data) { | |
224 | struct filter_trees_depth_data *d = filter_data; | |
225 | if (!d) | |
226 | return; | |
227 | oidmap_free(&d->seen_at_depth, 1); | |
228 | free(d); | |
229 | } | |
230 | ||
231 | static void filter_trees_depth__init( | |
232 | struct list_objects_filter_options *filter_options, | |
233 | struct filter *filter) | |
234 | { | |
235 | struct filter_trees_depth_data *d = xcalloc(1, sizeof(*d)); | |
236 | oidmap_init(&d->seen_at_depth, 0); | |
237 | d->exclude_depth = filter_options->tree_exclude_depth; | |
238 | d->current_depth = 0; | |
239 | ||
240 | filter->filter_data = d; | |
241 | filter->filter_object_fn = filter_trees_depth; | |
242 | filter->free_fn = filter_trees_free; | |
243 | } | |
244 | ||
245 | /* | |
246 | * A filter for list-objects to omit large blobs. | |
247 | * And to OPTIONALLY collect a list of the omitted OIDs. | |
248 | */ | |
249 | struct filter_blobs_limit_data { | |
250 | unsigned long max_bytes; | |
251 | }; | |
252 | ||
253 | static enum list_objects_filter_result filter_blobs_limit( | |
254 | struct repository *r, | |
255 | enum list_objects_filter_situation filter_situation, | |
256 | struct object *obj, | |
257 | const char *pathname, | |
258 | const char *filename, | |
259 | struct oidset *omits, | |
260 | void *filter_data_) | |
261 | { | |
262 | struct filter_blobs_limit_data *filter_data = filter_data_; | |
263 | unsigned long object_length; | |
264 | enum object_type t; | |
265 | ||
266 | switch (filter_situation) { | |
267 | default: | |
268 | BUG("unknown filter_situation: %d", filter_situation); | |
269 | ||
270 | case LOFS_BEGIN_TREE: | |
271 | assert(obj->type == OBJ_TREE); | |
272 | /* always include all tree objects */ | |
273 | return LOFR_MARK_SEEN | LOFR_DO_SHOW; | |
274 | ||
275 | case LOFS_END_TREE: | |
276 | assert(obj->type == OBJ_TREE); | |
277 | return LOFR_ZERO; | |
278 | ||
279 | case LOFS_BLOB: | |
280 | assert(obj->type == OBJ_BLOB); | |
281 | assert((obj->flags & SEEN) == 0); | |
282 | ||
283 | t = oid_object_info(r, &obj->oid, &object_length); | |
284 | if (t != OBJ_BLOB) { /* probably OBJ_NONE */ | |
285 | /* | |
286 | * We DO NOT have the blob locally, so we cannot | |
287 | * apply the size filter criteria. Be conservative | |
288 | * and force show it (and let the caller deal with | |
289 | * the ambiguity). | |
290 | */ | |
291 | goto include_it; | |
292 | } | |
293 | ||
294 | if (object_length < filter_data->max_bytes) | |
295 | goto include_it; | |
296 | ||
297 | if (omits) | |
298 | oidset_insert(omits, &obj->oid); | |
299 | return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */ | |
300 | } | |
301 | ||
302 | include_it: | |
303 | if (omits) | |
304 | oidset_remove(omits, &obj->oid); | |
305 | return LOFR_MARK_SEEN | LOFR_DO_SHOW; | |
306 | } | |
307 | ||
308 | static void filter_blobs_limit__init( | |
309 | struct list_objects_filter_options *filter_options, | |
310 | struct filter *filter) | |
311 | { | |
312 | struct filter_blobs_limit_data *d = xcalloc(1, sizeof(*d)); | |
313 | d->max_bytes = filter_options->blob_limit_value; | |
314 | ||
315 | filter->filter_data = d; | |
316 | filter->filter_object_fn = filter_blobs_limit; | |
317 | filter->free_fn = free; | |
318 | } | |
319 | ||
320 | /* | |
321 | * A filter driven by a sparse-checkout specification to only | |
322 | * include blobs that a sparse checkout would populate. | |
323 | * | |
324 | * The sparse-checkout spec can be loaded from a blob with the | |
325 | * given OID or from a local pathname. We allow an OID because | |
326 | * the repo may be bare or we may be doing the filtering on the | |
327 | * server. | |
328 | */ | |
329 | struct frame { | |
330 | /* | |
331 | * default_match is the usual default include/exclude value that | |
332 | * should be inherited as we recurse into directories based | |
333 | * upon pattern matching of the directory itself or of a | |
334 | * containing directory. | |
335 | */ | |
336 | enum pattern_match_result default_match; | |
337 | ||
338 | /* | |
339 | * 1 if the directory (recursively) contains any provisionally | |
340 | * omitted objects. | |
341 | * | |
342 | * 0 if everything (recursively) contained in this directory | |
343 | * has been explicitly included (SHOWN) in the result and | |
344 | * the directory may be short-cut later in the traversal. | |
345 | */ | |
346 | unsigned child_prov_omit : 1; | |
347 | }; | |
348 | ||
349 | struct filter_sparse_data { | |
350 | struct pattern_list pl; | |
351 | ||
352 | size_t nr, alloc; | |
353 | struct frame *array_frame; | |
354 | }; | |
355 | ||
356 | static enum list_objects_filter_result filter_sparse( | |
357 | struct repository *r, | |
358 | enum list_objects_filter_situation filter_situation, | |
359 | struct object *obj, | |
360 | const char *pathname, | |
361 | const char *filename, | |
362 | struct oidset *omits, | |
363 | void *filter_data_) | |
364 | { | |
365 | struct filter_sparse_data *filter_data = filter_data_; | |
366 | int dtype; | |
367 | struct frame *frame; | |
368 | enum pattern_match_result match; | |
369 | ||
370 | switch (filter_situation) { | |
371 | default: | |
372 | BUG("unknown filter_situation: %d", filter_situation); | |
373 | ||
374 | case LOFS_BEGIN_TREE: | |
375 | assert(obj->type == OBJ_TREE); | |
376 | dtype = DT_DIR; | |
377 | match = path_matches_pattern_list(pathname, strlen(pathname), | |
378 | filename, &dtype, &filter_data->pl, | |
379 | r->index); | |
380 | if (match == UNDECIDED) | |
381 | match = filter_data->array_frame[filter_data->nr - 1].default_match; | |
382 | ||
383 | ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1, | |
384 | filter_data->alloc); | |
385 | filter_data->array_frame[filter_data->nr].default_match = match; | |
386 | filter_data->array_frame[filter_data->nr].child_prov_omit = 0; | |
387 | filter_data->nr++; | |
388 | ||
389 | /* | |
390 | * A directory with this tree OID may appear in multiple | |
391 | * places in the tree. (Think of a directory move or copy, | |
392 | * with no other changes, so the OID is the same, but the | |
393 | * full pathnames of objects within this directory are new | |
394 | * and may match is_excluded() patterns differently.) | |
395 | * So we cannot mark this directory as SEEN (yet), since | |
396 | * that will prevent process_tree() from revisiting this | |
397 | * tree object with other pathname prefixes. | |
398 | * | |
399 | * Only _DO_SHOW the tree object the first time we visit | |
400 | * this tree object. | |
401 | * | |
402 | * We always show all tree objects. A future optimization | |
403 | * may want to attempt to narrow this. | |
404 | */ | |
405 | if (obj->flags & FILTER_SHOWN_BUT_REVISIT) | |
406 | return LOFR_ZERO; | |
407 | obj->flags |= FILTER_SHOWN_BUT_REVISIT; | |
408 | return LOFR_DO_SHOW; | |
409 | ||
410 | case LOFS_END_TREE: | |
411 | assert(obj->type == OBJ_TREE); | |
412 | assert(filter_data->nr > 1); | |
413 | ||
414 | frame = &filter_data->array_frame[--filter_data->nr]; | |
415 | ||
416 | /* | |
417 | * Tell our parent directory if any of our children were | |
418 | * provisionally omitted. | |
419 | */ | |
420 | filter_data->array_frame[filter_data->nr - 1].child_prov_omit |= | |
421 | frame->child_prov_omit; | |
422 | ||
423 | /* | |
424 | * If there are NO provisionally omitted child objects (ALL child | |
425 | * objects in this folder were INCLUDED), then we can mark the | |
426 | * folder as SEEN (so we will not have to revisit it again). | |
427 | */ | |
428 | if (!frame->child_prov_omit) | |
429 | return LOFR_MARK_SEEN; | |
430 | return LOFR_ZERO; | |
431 | ||
432 | case LOFS_BLOB: | |
433 | assert(obj->type == OBJ_BLOB); | |
434 | assert((obj->flags & SEEN) == 0); | |
435 | ||
436 | frame = &filter_data->array_frame[filter_data->nr - 1]; | |
437 | ||
438 | dtype = DT_REG; | |
439 | match = path_matches_pattern_list(pathname, strlen(pathname), | |
440 | filename, &dtype, &filter_data->pl, | |
441 | r->index); | |
442 | if (match == UNDECIDED) | |
443 | match = frame->default_match; | |
444 | if (match == MATCHED) { | |
445 | if (omits) | |
446 | oidset_remove(omits, &obj->oid); | |
447 | return LOFR_MARK_SEEN | LOFR_DO_SHOW; | |
448 | } | |
449 | ||
450 | /* | |
451 | * Provisionally omit it. We've already established that | |
452 | * this pathname is not in the sparse-checkout specification | |
453 | * with the CURRENT pathname, so we *WANT* to omit this blob. | |
454 | * | |
455 | * However, a pathname elsewhere in the tree may also | |
456 | * reference this same blob, so we cannot reject it yet. | |
457 | * Leave the LOFR_ bits unset so that if the blob appears | |
458 | * again in the traversal, we will be asked again. | |
459 | */ | |
460 | if (omits) | |
461 | oidset_insert(omits, &obj->oid); | |
462 | ||
463 | /* | |
464 | * Remember that at least 1 blob in this tree was | |
465 | * provisionally omitted. This prevents us from short | |
466 | * cutting the tree in future iterations. | |
467 | */ | |
468 | frame->child_prov_omit = 1; | |
469 | return LOFR_ZERO; | |
470 | } | |
471 | } | |
472 | ||
473 | ||
474 | static void filter_sparse_free(void *filter_data) | |
475 | { | |
476 | struct filter_sparse_data *d = filter_data; | |
477 | free(d->array_frame); | |
478 | free(d); | |
479 | } | |
480 | ||
481 | static void filter_sparse_oid__init( | |
482 | struct list_objects_filter_options *filter_options, | |
483 | struct filter *filter) | |
484 | { | |
485 | struct filter_sparse_data *d = xcalloc(1, sizeof(*d)); | |
486 | if (add_patterns_from_blob_to_list(filter_options->sparse_oid_value, | |
487 | NULL, 0, &d->pl) < 0) | |
488 | die("could not load filter specification"); | |
489 | ||
490 | ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc); | |
491 | d->array_frame[d->nr].default_match = 0; /* default to include */ | |
492 | d->array_frame[d->nr].child_prov_omit = 0; | |
493 | d->nr++; | |
494 | ||
495 | filter->filter_data = d; | |
496 | filter->filter_object_fn = filter_sparse; | |
497 | filter->free_fn = filter_sparse_free; | |
498 | } | |
499 | ||
500 | /* A filter which only shows objects shown by all sub-filters. */ | |
501 | struct combine_filter_data { | |
502 | struct subfilter *sub; | |
503 | size_t nr; | |
504 | }; | |
505 | ||
506 | static enum list_objects_filter_result process_subfilter( | |
507 | struct repository *r, | |
508 | enum list_objects_filter_situation filter_situation, | |
509 | struct object *obj, | |
510 | const char *pathname, | |
511 | const char *filename, | |
512 | struct subfilter *sub) | |
513 | { | |
514 | enum list_objects_filter_result result; | |
515 | ||
516 | /* | |
517 | * Check and update is_skipping_tree before oidset_contains so | |
518 | * that is_skipping_tree gets unset even when the object is | |
519 | * marked as seen. As of this writing, no filter uses | |
520 | * LOFR_MARK_SEEN on trees that also uses LOFR_SKIP_TREE, so the | |
521 | * ordering is only theoretically important. Be cautious if you | |
522 | * change the order of the below checks and more filters have | |
523 | * been added! | |
524 | */ | |
525 | if (sub->is_skipping_tree) { | |
526 | if (filter_situation == LOFS_END_TREE && | |
527 | oideq(&obj->oid, &sub->skip_tree)) | |
528 | sub->is_skipping_tree = 0; | |
529 | else | |
530 | return LOFR_ZERO; | |
531 | } | |
532 | if (oidset_contains(&sub->seen, &obj->oid)) | |
533 | return LOFR_ZERO; | |
534 | ||
535 | result = list_objects_filter__filter_object( | |
536 | r, filter_situation, obj, pathname, filename, sub->filter); | |
537 | ||
538 | if (result & LOFR_MARK_SEEN) | |
539 | oidset_insert(&sub->seen, &obj->oid); | |
540 | ||
541 | if (result & LOFR_SKIP_TREE) { | |
542 | sub->is_skipping_tree = 1; | |
543 | sub->skip_tree = obj->oid; | |
544 | } | |
545 | ||
546 | return result; | |
547 | } | |
548 | ||
549 | static enum list_objects_filter_result filter_combine( | |
550 | struct repository *r, | |
551 | enum list_objects_filter_situation filter_situation, | |
552 | struct object *obj, | |
553 | const char *pathname, | |
554 | const char *filename, | |
555 | struct oidset *omits, | |
556 | void *filter_data) | |
557 | { | |
558 | struct combine_filter_data *d = filter_data; | |
559 | enum list_objects_filter_result combined_result = | |
560 | LOFR_DO_SHOW | LOFR_MARK_SEEN | LOFR_SKIP_TREE; | |
561 | size_t sub; | |
562 | ||
563 | for (sub = 0; sub < d->nr; sub++) { | |
564 | enum list_objects_filter_result sub_result = process_subfilter( | |
565 | r, filter_situation, obj, pathname, filename, | |
566 | &d->sub[sub]); | |
567 | if (!(sub_result & LOFR_DO_SHOW)) | |
568 | combined_result &= ~LOFR_DO_SHOW; | |
569 | if (!(sub_result & LOFR_MARK_SEEN)) | |
570 | combined_result &= ~LOFR_MARK_SEEN; | |
571 | if (!d->sub[sub].is_skipping_tree) | |
572 | combined_result &= ~LOFR_SKIP_TREE; | |
573 | } | |
574 | ||
575 | return combined_result; | |
576 | } | |
577 | ||
578 | static void filter_combine__free(void *filter_data) | |
579 | { | |
580 | struct combine_filter_data *d = filter_data; | |
581 | size_t sub; | |
582 | for (sub = 0; sub < d->nr; sub++) { | |
583 | list_objects_filter__free(d->sub[sub].filter); | |
584 | oidset_clear(&d->sub[sub].seen); | |
585 | if (d->sub[sub].omits.set.size) | |
586 | BUG("expected oidset to be cleared already"); | |
587 | } | |
588 | free(d->sub); | |
589 | } | |
590 | ||
591 | static void add_all(struct oidset *dest, struct oidset *src) { | |
592 | struct oidset_iter iter; | |
593 | struct object_id *src_oid; | |
594 | ||
595 | oidset_iter_init(src, &iter); | |
596 | while ((src_oid = oidset_iter_next(&iter)) != NULL) | |
597 | oidset_insert(dest, src_oid); | |
598 | } | |
599 | ||
600 | static void filter_combine__finalize_omits( | |
601 | struct oidset *omits, | |
602 | void *filter_data) | |
603 | { | |
604 | struct combine_filter_data *d = filter_data; | |
605 | size_t sub; | |
606 | ||
607 | for (sub = 0; sub < d->nr; sub++) { | |
608 | add_all(omits, &d->sub[sub].omits); | |
609 | oidset_clear(&d->sub[sub].omits); | |
610 | } | |
611 | } | |
612 | ||
613 | static void filter_combine__init( | |
614 | struct list_objects_filter_options *filter_options, | |
615 | struct filter* filter) | |
616 | { | |
617 | struct combine_filter_data *d = xcalloc(1, sizeof(*d)); | |
618 | size_t sub; | |
619 | ||
620 | d->nr = filter_options->sub_nr; | |
621 | d->sub = xcalloc(d->nr, sizeof(*d->sub)); | |
622 | for (sub = 0; sub < d->nr; sub++) | |
623 | d->sub[sub].filter = list_objects_filter__init( | |
624 | filter->omits ? &d->sub[sub].omits : NULL, | |
625 | &filter_options->sub[sub]); | |
626 | ||
627 | filter->filter_data = d; | |
628 | filter->filter_object_fn = filter_combine; | |
629 | filter->free_fn = filter_combine__free; | |
630 | filter->finalize_omits_fn = filter_combine__finalize_omits; | |
631 | } | |
632 | ||
633 | typedef void (*filter_init_fn)( | |
634 | struct list_objects_filter_options *filter_options, | |
635 | struct filter *filter); | |
636 | ||
637 | /* | |
638 | * Must match "enum list_objects_filter_choice". | |
639 | */ | |
640 | static filter_init_fn s_filters[] = { | |
641 | NULL, | |
642 | filter_blobs_none__init, | |
643 | filter_blobs_limit__init, | |
644 | filter_trees_depth__init, | |
645 | filter_sparse_oid__init, | |
646 | filter_combine__init, | |
647 | }; | |
648 | ||
649 | struct filter *list_objects_filter__init( | |
650 | struct oidset *omitted, | |
651 | struct list_objects_filter_options *filter_options) | |
652 | { | |
653 | struct filter *filter; | |
654 | filter_init_fn init_fn; | |
655 | ||
656 | assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT); | |
657 | ||
658 | if (filter_options->choice >= LOFC__COUNT) | |
659 | BUG("invalid list-objects filter choice: %d", | |
660 | filter_options->choice); | |
661 | ||
662 | init_fn = s_filters[filter_options->choice]; | |
663 | if (!init_fn) | |
664 | return NULL; | |
665 | ||
666 | filter = xcalloc(1, sizeof(*filter)); | |
667 | filter->omits = omitted; | |
668 | init_fn(filter_options, filter); | |
669 | return filter; | |
670 | } | |
671 | ||
672 | enum list_objects_filter_result list_objects_filter__filter_object( | |
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 filter *filter) | |
679 | { | |
680 | if (filter && (obj->flags & NOT_USER_GIVEN)) | |
681 | return filter->filter_object_fn(r, filter_situation, obj, | |
682 | pathname, filename, | |
683 | filter->omits, | |
684 | filter->filter_data); | |
685 | /* | |
686 | * No filter is active or user gave object explicitly. In this case, | |
687 | * always show the object (except when LOFS_END_TREE, since this tree | |
688 | * had already been shown when LOFS_BEGIN_TREE). | |
689 | */ | |
690 | if (filter_situation == LOFS_END_TREE) | |
691 | return 0; | |
692 | return LOFR_MARK_SEEN | LOFR_DO_SHOW; | |
693 | } | |
694 | ||
695 | void list_objects_filter__free(struct filter *filter) | |
696 | { | |
697 | if (!filter) | |
698 | return; | |
699 | if (filter->finalize_omits_fn && filter->omits) | |
700 | filter->finalize_omits_fn(filter->omits, filter->filter_data); | |
701 | filter->free_fn(filter->filter_data); | |
702 | free(filter); | |
703 | } |