Multiset<E> unfiltered, Predicate<? super E> predicate) {
    if (unfiltered instanceof FilteredMultiset) {
      // Support clear(), removeAll(), and retainAll() when filtering a filtered
      // collection.
      FilteredMultiset<E> filtered = (FilteredMultiset<E>) unfiltered;
      Predicate<E> combinedPredicate = Predicates.and(filtered.predicate, predicate);

      Multiset<E> unfiltered, Predicate<? super E> predicate) {
    if (unfiltered instanceof FilteredMultiset) {
      // Support clear(), removeAll(), and retainAll() when filtering a filtered
      // collection.
      FilteredMultiset<E> filtered = (FilteredMultiset<E>) unfiltered;
      Predicate<E> combinedPredicate = Predicates.and(filtered.predicate, predicate);

         * based on the reactor failure behavior.
         * <p>
         * This method works in conjunction with the filtering in executePlan():
         * - For FAIL_FAST: Sets ReactorBuildStatus to halted, which causes executePlan to only process after:* steps

                    },
                }
            },
            "/response_model_filtering_model-annotation_submodel-return_submodel": {
                "get": {
                    "summary": "Response Model Filtering Model Annotation Submodel Return Submodel",
                    "operationId": "response_model_filtering_model_annotation_submodel_return_submodel_response_model_filtering_model_annotation_submodel_return_submodel_get",

    /** Service for managing URL crawling queue */
    @Resource
    protected UrlQueueService<OpenSearchUrlQueue> urlQueueService;

    /** Service for URL filtering operations */
    @Resource
    protected UrlFilterService urlFilterService;

    /** Behavior class for click log operations */
    @Resource
    protected ClickLogBhv clickLogBhv;

                org = resource.getTargetPath();
                val = interpolate(org);
                if (org != val) {
                    resource.setTargetPath(val);
                }
                // Filtering
                org = resource.getFiltering();
                val = interpolate(org);
                if (org != val) {
                    resource.setFiltering(val);
                }
            }

 *
 * <p>For added safety, it is common for IPv6 network operators to filter all packets where either
 * the source or destination address appears to be a "compat" or "mapped" address. Filtering
 * suggestions usually recommend discarding any packets with source or destination addresses in the
 * invalid range {@code ::/3}, which includes both of these bizarre address formats. For more

        if (src != null) {
            if (sourceDominant || target.getFiltering() == null) {
                target.setFiltering(src);
                target.setLocation("filtering", source.getLocation("filtering"));
            }
        }
    }

    protected void mergeResource_MergeId(
            Resource target, Resource source, boolean sourceDominant, Map<Object, Object> context) {

                    resource.getDirectory(),
                    null,
                    resource);

            validateBoolean(
                    prefix,
                    "filtering",
                    problems,
                    errOn30,
                    Version.V20,
                    resource.getFiltering(),
                    resource.getDirectory(),

        : new FilteredEntrySetMultimap<K, V>(checkNotNull(unfiltered), entryPredicate);
  }

  /**
   * Support removal operations when filtering a filtered multimap. Since a filtered multimap has
   * iterators that don't support remove, passing one to the FilteredEntryMultimap constructor would