private final FileCollectionExecutionTimeValue source;
        private final Spec<? super File> filter;

        public FilteredExecutionTimeValue(FileCollectionExecutionTimeValue source, Spec<? super File> filter) {
            this.source = source;
            this.filter = filter;
        }

        @Override
        public FileCollectionInternal toFileCollection(FileCollectionFactory fileCollectionFactory) {

        stream(conditions.get(SearchRequestParams.AS_OCCURRENCE))
                .of(stream -> stream.filter(this::isOccurrence).findFirst().ifPresent(q -> queryBuf.insert(0, q + ":")));

        stream(conditions.get(SearchRequestParams.AS_Q)).of(stream -> stream
                .filter(q -> StringUtil.isNotBlank(q) && q.length() <= maxQueryLength).forEach(q -> queryBuf.append(' ').append(q)));

	gg.logEventGenerator.getResource = rg
	gg.gStates = make(map[trace.GoID]*gState[trace.GoID])
	gg.focus = focus
	gg.filter = filter

	// Enable a filter on the emitter.
	if filter != nil {
		ctx.SetResourceFilter(func(resource uint64) bool {
			_, ok := filter[trace.GoID(resource)]
			return ok
		})
	}
	return gg
}

func (g *goroutineGenerator) Sync() {
	g.globalRangeGenerator.Sync()
}

    interface BuildSpecificSelector {
        TaskSelection resolveTaskName(String taskName);
    }

    class Filter {
        private final BuildState build;
        private final Spec<Task> filter;

        public Filter(BuildState build, Spec<Task> filter) {
            this.build = build;
            this.filter = filter;
        }

        public BuildState getBuild() {
            return build;
        }

// The main difference is that the request includes Resources to filter.
func (g *GrpcConfigGenerator) BuildClusters(node *model.Proxy, push *model.PushContext, names []string) model.Resources {
	filter := newClusterFilter(names)
	clusters := make([]*cluster.Cluster, 0, len(names))
	for defaultClusterName, subsetFilter := range filter {
		builder, err := newClusterBuilder(node, push, defaultClusterName, subsetFilter)

        html: true,
        content: function () {
            return $('#filter-popover').html();
        }
    });

    $(document).on('click', '.form-check-input', function () {
        var currentSelectedTag = $(this).val();
        var checked = $(this).prop('checked');

    }

    private ArrayList<String> fileTreeOperators() {
        [
            'filter { it.path.endsWith "ok" }',
            'matching(patternSet)',
            'matching(patternSet).filter { it.file }',
            'matching(patternSet).asFileTree.filter { it.file }',
            'filter { it.path.endsWith "ok" }.asFileTree',
            'filter { it.file }.asFileTree.matching(patternSet)',
        ]
    }

     *
     * @see org.codelibs.fess.crawler.filter.UrlFilter#clear()
     */
    @Override
    public void clear() {
        cachedIncludeSet.clear();
        cachedExcludeSet.clear();
        if (sessionId != null) {
            getUrlFilterService().delete(sessionId);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.filter.UrlFilter#init(java.lang.String)
     */

		})
	}

	// Build a namespace watcher. This must have no filter, since this is our input to the filter itself.
	// This must be done before we build components, so they can access the filter.
	namespaces := kclient.New[*corev1.Namespace](c.Client)
	// This will start a namespace informer and wait for it to be ready. So we must start it in a go routine to avoid blocking.
	filter := filter.NewDiscoveryNamespacesFilter(namespaces, mesh, c.stop)

    filtered_ops.push_back(op);
  });
}

// A custom string for tac filter.
std::string TacFilterToString(const TacFilter& tac_filter) {
  std::string tac_filter_type_str;
  std::string tac_filter_name_pattern_str;
  if (tac_filter.has_function_filter()) {
    tac_filter_type_str = (llvm::Twine("function filter ") +
                           FunctionFilter::FunctionFilterType_Name(