Java Code Examples for com.google.common.collect.ImmutableSet.isEmpty()

The following are Jave code examples for showing how to use isEmpty() of the com.google.common.collect.ImmutableSet class. You can vote up the examples you like. Your votes will be used in our system to get more good examples.
Example 1
Project: Reer   File: VariantAspectExtractionStrategy.java   Source Code and License Vote up 6 votes
@Nullable
@Override
public ModelSchemaAspectExtractionResult extract(ModelSchemaExtractionContext<?> extractionContext, final List<ModelPropertyExtractionResult<?>> propertyResults) {
    ImmutableSet.Builder<ModelProperty<?>> dimensionsBuilder = ImmutableSet.builder();
    for (ModelPropertyExtractionResult<?> propertyResult : propertyResults) {
        ModelProperty<?> property = propertyResult.getProperty();
        for (PropertyAccessorExtractionContext accessor : propertyResult.getAccessors()) {
            if (accessor.isAnnotationPresent(Variant.class)) {
                if (accessor.getAccessorType() == PropertyAccessorType.SETTER) {
                    throw invalidProperty(extractionContext, property, "@Variant annotation is only allowed on getter methods");
                }
                Class<?> propertyType = property.getType().getRawClass();
                if (!String.class.equals(propertyType) && !Named.class.isAssignableFrom(propertyType)) {
                    throw invalidProperty(extractionContext, property, String.format("@Variant annotation only allowed for properties of type String and %s, but property has type %s", Named.class.getName(), propertyType.getName()));
                }
                dimensionsBuilder.add(property);
            }
        }
    }
    ImmutableSet<ModelProperty<?>> dimensions = dimensionsBuilder.build();
    if (dimensions.isEmpty()) {
        return null;
    }
    return new ModelSchemaAspectExtractionResult(new VariantAspect(dimensions));
}
 
Example 2
Project: BUILD_file_generator   File: ProjectClassToRuleResolver.java   Source Code and License Vote up 6 votes
/**
 * Identifies and logs all unresolved class names. Then computes the percentage of unresolved
 * classes. If more than a certain threshold are unresolved, then it will throw an
 * IllegalStateException.
 */
private void handleUnresolvedClasses(
    ImmutableSet<String> projectClasses, Set<String> resolvedClasses) {
  Set<String> unresolvedClasses = Sets.difference(projectClasses, resolvedClasses);
  if (unresolvedClasses.isEmpty() || projectClasses.isEmpty()) {
    return;
  }

  logger.severe(
      String.format(
          "Unresolved class names = {\n\t%s\n}", Joiner.on("\n\t").join(unresolvedClasses)));

  if (UNRESOLVED_THRESHOLD * projectClasses.size() < unresolvedClasses.size()) {
    throw new IllegalStateException(
        String.format(
            "BUILD File Generator failed to map over %.0f percent of class names. "
                + "Check your white list and content roots",
            UNRESOLVED_THRESHOLD * 100));
  }
}
 
Example 3
Project: tac-kbp-eal   File: AnswerKey.java   Source Code and License Vote up 6 votes
@MoveToBUECommon
private static <T> void checkSetsEqual(Set<T> left, String leftName, Set<T> right, String rightName) {
  if (!left.equals(right)) {
    final StringBuilder msg = new StringBuilder();
    msg.append(leftName).append(" should exactly equal ").append(rightName).append(" but ");
    final ImmutableSet<T> leftOnly = Sets.difference(left, right).immutableCopy();
    final ImmutableSet<T> rightOnly = Sets.difference(right, left).immutableCopy();

    if (!leftOnly.isEmpty()) {
      msg.append(leftOnly).append(" are only in ").append(leftName).append(" ");
    }
    if (!rightOnly.isEmpty()) {
      msg.append(rightOnly).append(" are only in ").append(rightName).append(" ");
    }

    throw new IllegalArgumentException(msg.toString());
  }
}
 
Example 4
Project: tac-kbp-eal   File: AssessmentSpecFormats.java   Source Code and License Vote up 6 votes
private static ImmutableSet<CharOffsetSpan> parseCharOffsetSpans(final String s) {
  if ("NIL".equals(s)) {
    return ImmutableSet.of();
  }

  final ImmutableSet.Builder<CharOffsetSpan> ret = ImmutableSet.builder();

  for (final String span : onCommas.split(s)) {
    ret.add(TACKBPEALIOUtils.parseCharOffsetSpan(span));
  }

  final ImmutableSet<CharOffsetSpan> spans = ret.build();

  if (spans.isEmpty()) {
    throw new RuntimeException(String.format("Empty spans sets must be indicated by NIL"));
  }

  return spans;
}
 
Example 5
Project: tac-kbp-eal   File: DerivedQuerySelector2016.java   Source Code and License Vote up 6 votes
@MoveToBUECommon
private static <T> ImmutableSet<T> intersectedCopy(Iterable<? extends Iterable<? extends T>> iterables) {
  if (Iterables.isEmpty(iterables)) {
    return ImmutableSet.of();
  }

  ImmutableSet<T> ret = null;

  for (final Iterable<? extends T> iterable : iterables) {
    if (ret == null) {
      ret = ImmutableSet.copyOf(iterable);
    } else {
      ret = Sets.intersection(ret, ImmutableSet.copyOf(iterable)).immutableCopy();
    }

    // as soon as we realize the intersection is empty there is no need to do more work
    if (ret.isEmpty()) {
      break;
    }
  }

  return ret;
}
 
Example 6
Project: ProjectAres   File: DataDogClient.java   Source Code and License Vote up 6 votes
String[] renderedTags() {
    final StringBuilder sb = new StringBuilder();
    boolean some = false;
    for(Provider<Tagger> provider : taggers.get()) {
        final Tagger tagger;
        try {
            tagger = Injection.unwrappingExceptions(OutOfScopeException.class, provider);
        } catch(OutOfScopeException e) {
            // If the tagger is out of scope, just omit its tags,
            // but log a warning in case this hides an unexpected exception.
            logger.warning("Ignoring out-of-scope tagger (" + e.toString() + ")");
            continue;
        }

        final ImmutableSet<Tag> tags = tagger.tags();
        if(!tags.isEmpty()) {
            if(some) sb.append(',');
            some = true;
            sb.append(tagSetCache.getUnchecked(tags));
        }
    }
    return some ? new String[] {sb.toString()} : EMPTY;
}
 
Example 7
Project: de.flapdoodle.solid   File: Blobs.java   Source Code and License Vote up 6 votes
public static ImmutableSet<?> propertyOf(Blob blob, Function<String, Collection<String>> pathPropertyMapping, PropertyCollectionResolver propertyResolver,
			String propertyName) {
		Collection<String> aliasList = pathPropertyMapping.apply(propertyName);
		for (String alias : aliasList) {
//			if (alias.equals("filename")) {
//				return ImmutableSet.of(blob.filename());
//			}
//			if (alias.equals("path")) {
//				return ImmutableSet.of(Joiner.on('/').join(blob.path()));
//			}
			ImmutableSet<?> resolved = propertyResolver.resolve(blob.meta(), Splitter.on('.').split(alias));
			if (!resolved.isEmpty()) {
				return resolved;
			}
		}
		return ImmutableSet.of();
	}
 
Example 8
Project: tac-kbp-eal   File: _ResponseLinking.java   Source Code and License Vote up 5 votes
public ResponseLinking copyWithFilteredResponses(final Predicate<Response> toKeepCondition) {
  final Set<Response> newIncompletes = Sets.filter(incompleteResponses(), toKeepCondition);
  final ImmutableSet.Builder<ResponseSet> newResponseSetsB = ImmutableSet.builder();
  final ImmutableBiMap.Builder<String, ResponseSet> responseSetsIdB = ImmutableBiMap.builder();
  // to account for ResponseSets merging due to lost annotation
  final Set<ResponseSet> alreadyAdded = Sets.newHashSet();
  for (final ResponseSet responseSet : responseSets()) {
    final ImmutableSet<Response> okResponses = FluentIterable.from(responseSet.asSet())
        .filter(toKeepCondition).toSet();
    if (!okResponses.isEmpty()) {
      final ResponseSet newResponseSet = ResponseSet.from(okResponses);
      if(alreadyAdded.contains(newResponseSet)) {
        continue;
      }
      alreadyAdded.add(newResponseSet);
      newResponseSetsB.add(newResponseSet);
      if (responseSetIds().isPresent()) {
        responseSetsIdB.put(responseSetIds().get().inverse().get(responseSet), newResponseSet);
      }
    }
  }

  final ImmutableSet<ResponseSet> newResponseSets = newResponseSetsB.build();
  final ResponseLinking.Builder ret = ResponseLinking.builder().docID(docID())
      .responseSets(newResponseSets).incompleteResponses(newIncompletes);
  if (responseSetIds().isPresent()) {
    ret.responseSetIds(responseSetsIdB.build());
  }
  return ret.build();
}
 
Example 9
Project: tac-kbp-eal   File: LinkingStoreSource.java   Source Code and License Vote up 5 votes
private String getEventFrameID(final ResponseSet responseSet,
    final ResponseLinking responseLinking) throws IOException {
  checkArgument(responseLinking.responseSetIds().isPresent(), "Linking does not assign frame "
      + "IDs. These are required for writing in 2016 format.");
  final ImmutableSet<String> ids =
      responseLinking.responseSetIds().get().asMultimap().inverse().get(responseSet);
  if (ids.size() == 1) {
    return ids.asList().get(0);
  } else if (ids.isEmpty()) {
    throw new IOException("No ID found for event frame " + responseSet);
  } else {
    throw new IOException("Multiple IDs found for event frame, should be impossible: "
        + responseSet);
  }
}
 
Example 10
Project: tac-kbp-eal   File: DocLevelArgLinking.java   Source Code and License Vote up 5 votes
public final DocLevelArgLinking filterArguments(
    Predicate<? super DocLevelEventArg> argPredicate) {
  final DocLevelArgLinking.Builder ret = new DocLevelArgLinking.Builder()
      .docID(docID());
  for (final ScoringEventFrame eventFrame : eventFrames()) {
    final ImmutableSet<DocLevelEventArg> filteredFrame =
        FluentIterable.from(eventFrame).filter(argPredicate).toSet();
    if (!filteredFrame.isEmpty()) {
      ret.addEventFrames(ScoringEventFrame.of(filteredFrame));
    }
  }
  return ret.build();
}
 
Example 11
Project: ProjectAres   File: DependencyCollector.java   Source Code and License Vote up 5 votes
private void processImplicitBindings() {
    for(;;) {
        ImmutableSet<Key<?>> keys = ImmutableSet.copyOf(Sets.difference(requiredKeys, Sets.union(explicitBindings.keySet(), implicitBindings)));
        if(keys.isEmpty()) break;
        for(Key<?> key : keys) {
            if(implicitBindings.add(key)) {
                processInjections(key.getTypeLiteral());
            }
        }
    }
}
 
Example 12
Project: devtools-driver   File: InspectorMessenger.java   Source Code and License Vote up 5 votes
@VisibleForTesting
@SuppressWarnings("GuardedBy")
Optional<ImmutableSet<AppListing>> getAllAppListings(String hostBundleId) {
  Set<AppListing> listings = appIdToListings.values();
  ImmutableSet<String> hostAppIds =
      listings
          .stream()
          .filter(appListing -> appListing.app.applicationBundleId().equals(hostBundleId))
          .map(appListing -> appListing.app.applicationId())
          .collect(ImmutableSet.toImmutableSet());
  Verify.verify(hostAppIds.size() <= 1, "multiple matching host apps: %s", hostAppIds);
  if (!hostAppIds.isEmpty()) {
    String hostAppId = Iterables.getOnlyElement(hostAppIds);
    ImmutableSet<AppListing> childListings =
        listings
            .stream()
            .filter(
                appListing ->
                    hostAppId.equals(appListing.app.optionalHostApplicationId().orNull()))
            .collect(ImmutableSet.toImmutableSet());
    if (!childListings.isEmpty()
        && childListings.stream().allMatch(appListing -> appListing.listing.isPresent())) {
      return Optional.of(childListings);
    }
  }
  return Optional.empty();
}
 
Example 13
Project: Elasticsearch   File: ClusterBlocks.java   Source Code and License Vote up 5 votes
public boolean indexBlocked(ClusterBlockLevel level, String index) {
    if (!global(level).isEmpty()) {
        return true;
    }
    ImmutableSet<ClusterBlock> indexBlocks = indices(level).get(index);
    if (indexBlocks != null && !indexBlocks.isEmpty()) {
        return true;
    }
    return false;
}
 
Example 14
Project: bazel-tools   File: MavenDependencies.java   Source Code and License Vote up 5 votes
private static Stream<MavenCoords> buildCoords(
    final String groupIdBase, final String artifactIdBase, final ImmutableSet<String> modules) {
  if (modules.isEmpty()) {
    return Stream.of(MavenCoords.create(groupIdBase, artifactIdBase));
  } else {
    return modules.stream().map(spec -> formatSpec(groupIdBase, artifactIdBase, spec));
  }
}
 
Example 15
Project: athena   File: FlowRuleOperations.java   Source Code and License Vote up 5 votes
/**
 * Closes the current stage.
 */
private void closeStage() {
    ImmutableSet<FlowRuleOperation> stage = currentStage.build();
    if (!stage.isEmpty()) {
        listBuilder.add(stage);
    }
}
 
Example 16
Project: tac-kbp-eal   File: ResponseMapping.java   Source Code and License Vote up 4 votes
public ResponseLinking apply(ResponseLinking responseLinking) {
  final Function<Response, Response> responseMapping = MapUtils.asFunction(replacedResponses,
      Functions.<Response>identity());
  final Predicate<Response> notDeleted = not(in(deletedResponses));

  final ImmutableSet.Builder<ResponseSet> newResponseSetsB = ImmutableSet.builder();
  final ImmutableMap.Builder<ResponseSet, ResponseSet> oldResponseSetToNewB = ImmutableMap.builder();
  for (final ResponseSet responseSet : responseLinking.responseSets()) {
    final ImmutableSet<Response> filteredResponses = FluentIterable.from(responseSet)
        .filter(notDeleted)
        .transform(responseMapping).toSet();
    if (!filteredResponses.isEmpty()) {
      final ResponseSet derived = ResponseSet.from(filteredResponses);
      newResponseSetsB.add(derived);
      oldResponseSetToNewB.put(responseSet, derived);
    }
  }

  final ImmutableSet<ResponseSet> newResponseSets = newResponseSetsB.build();
  final Predicate<Response> notLinked = not(in(ImmutableSet.copyOf(
      Iterables.concat(newResponseSets))));
  final ImmutableSet<Response> newIncompletes =
      FluentIterable.from(responseLinking.incompleteResponses())
          .filter(notDeleted)
          .transform(responseMapping)
          .filter(notLinked)
          .toSet();

  final Optional<ImmutableBiMap<String, ResponseSet>> newResponseSetIDMap;
  if (responseLinking.responseSetIds().isPresent()) {
    final BiMap<String, ResponseSet> responseSetIDs = responseLinking.responseSetIds().get();
    final ImmutableMap<ResponseSet, ResponseSet> oldResponseSetToNew = oldResponseSetToNewB.build();
    final Multimap<ResponseSet, ResponseSet> newResponseToOld = oldResponseSetToNew.asMultimap().inverse();
    final ImmutableBiMap.Builder<String, ResponseSet> newResponseSetIDMapB =
        ImmutableBiMap.builder();
    // since response sets may lose responses and no longer be unique, we choose the earliest alphabetical ID
    for(final ResponseSet nu: newResponseToOld.keySet()) {
      final ImmutableSet.Builder<String> candidateIDsB = ImmutableSet.builder();
      for(final ResponseSet old: newResponseToOld.get(nu)) {
        candidateIDsB.add(responseSetIDs.inverse().get(old));
      }
      final ImmutableSet<String> candidateIDs = candidateIDsB.build();
      final String newID = Ordering.natural().sortedCopy(candidateIDs).get(0);
      if(candidateIDs.size() > 1) {
        // only log if we're converting multiple sets.
        log.debug("Collapsing response sets {} to {}", candidateIDs, newID);
      }
      newResponseSetIDMapB.put(newID, nu);
    }
    newResponseSetIDMap = Optional.of(newResponseSetIDMapB.build());
  } else {
    newResponseSetIDMap = Optional.absent();
  }

  return ResponseLinking.builder().docID(responseLinking.docID())
      .responseSets(newResponseSets).incompleteResponses(newIncompletes)
      .responseSetIds(newResponseSetIDMap).build();
}
 
Example 17
Project: tac-kbp-eal   File: NaiveResponseLinkingProjector.java   Source Code and License Vote up 4 votes
public ResponseLinking projectTo(AnswerKey targetAnswerKey) {
  checkState(sourceLinking != null, "You forgot to call from()");
  checkState(targetAnswerKey.docId() == sourceLinking.docID());

  final Function<Response, Optional<TypeRoleFillerRealis>> toEquivalenceClassIfPossible =
      TypeRoleFillerRealis.extractFromSystemResponseIfPossible(
          targetAnswerKey.corefAnnotation().normalizeCASIfPossibleFunction());

  final ImmutableSet.Builder<TypeRoleFillerRealisSet> projectedSetsB =
      ImmutableSet.builder();

  for (final ResponseSet responseSet : sourceLinking.responseSets()) {
    // get the equivalence class for every response for which
    // coref information is available in the target
    final ImmutableSet<TypeRoleFillerRealis> projectedEquivalenceClasSet =
        ImmutableSet.copyOf(Optional.presentInstances(
            transform(responseSet, toEquivalenceClassIfPossible)));
    // empty sets are meaningless and invalid, so no response in the source
    // could be projected to the target, the set isn't projected either
    if (!projectedEquivalenceClasSet.isEmpty()) {
      projectedSetsB.add(TypeRoleFillerRealisSet.from(projectedEquivalenceClasSet));
    }
  }
  final ImmutableSet<TypeRoleFillerRealisSet> projectedSets = projectedSetsB.build();
  final ImmutableSet<TypeRoleFillerRealis> TRFRsInProjection =
      ImmutableSet.copyOf(concat(projectedSets));
  final ImmutableSet<TypeRoleFillerRealis> allTargetTRFRs = ImmutableSet.copyOf(
      Optional.presentInstances(FluentIterable
          .from(targetAnswerKey.annotatedResponses())
          .transform(AssessedResponseFunctions.response())
          .transform(toEquivalenceClassIfPossible)));

  final Set<TypeRoleFillerRealis> projectedIncompletesNotFoundElsewhere =
      Sets.difference(allTargetTRFRs, TRFRsInProjection);

  final EventArgumentLinking projectedEventArgumentLinking = EventArgumentLinking.builder()
      .docID(targetAnswerKey.docId()).eventFrames(projectedSets)
      .incomplete(projectedIncompletesNotFoundElsewhere).build();

  return EventArgumentLinkingAligners.getExactMatchEventArgumentLinkingAligner().alignToResponseLinking(
      projectedEventArgumentLinking, targetAnswerKey);
}
 
Example 18
Project: NullAway   File: NullAway.java   Source Code and License Vote up 4 votes
/**
 * handle either a method invocation or a 'new' invocation
 *
 * @param state visitor state
 * @param methodSymbol symbol for invoked method
 * @param actualParams parameters passed at call
 * @return description of error or NO_MATCH if no error
 */
private Description handleInvocation(
    VisitorState state,
    Symbol.MethodSymbol methodSymbol,
    List<? extends ExpressionTree> actualParams) {
  ImmutableSet<Integer> nonNullPositions = null;
  if (NullabilityUtil.fromUnannotatedPackage(methodSymbol, config)) {
    nonNullPositions =
        handler.onUnannotatedInvocationGetNonNullPositions(
            this, state, methodSymbol, actualParams, ImmutableSet.of());
  }
  if (nonNullPositions == null) {
    ImmutableSet.Builder<Integer> builder = ImmutableSet.builder();
    // compute which arguments are @NonNull
    List<VarSymbol> formalParams = methodSymbol.getParameters();
    for (int i = 0; i < formalParams.size(); i++) {
      if (i == formalParams.size() - 1 && methodSymbol.isVarArgs()) {
        // eventually, handle this case properly.  I *think* a null
        // array could be passed in incorrectly.  For now, punt
        continue;
      }
      VarSymbol param = formalParams.get(i);
      if (param.type.isPrimitive()) {
        Description unboxingCheck = doUnboxingCheck(state, actualParams.get(i));
        if (unboxingCheck != Description.NO_MATCH) {
          return unboxingCheck;
        } else {
          continue;
        }
      }
      boolean nullable = Nullness.hasNullableAnnotation(param);
      if (!nullable) {
        builder.add(i);
      }
    }
    nonNullPositions = builder.build();
  }
  if (nonNullPositions.isEmpty()) {
    return Description.NO_MATCH;
  }
  // now actually check the arguments
  for (int argPos : nonNullPositions) {
    // make sure we are passing a non-null value
    ExpressionTree actual = actualParams.get(argPos);
    if (mayBeNullExpr(state, actual)) {
      String message =
          "passing @Nullable parameter '" + actual.toString() + "' where @NonNull is required";
      return createErrorDescriptionForNullAssignment(
          MessageTypes.PASS_NULLABLE, actual, message, actual, state.getPath());
    }
  }
  // NOTE: the case of an invocation on a possibly-null reference
  // is handled by matchMemberSelect()
  return Description.NO_MATCH;
}
 
Example 19
Project: url-classifier   File: QueryClassifierBuilder.java   Source Code and License Vote up 4 votes
/**
 * Builds a classifier based on previous allow/match decisions.
 * This may be reused after a call to build and subsequent calls to
 * allow/match methods will not affect previously built classifiers.
 */
public QueryClassifier build() {
  ImmutableSet<String> mayKeySet = mayKeys.build();
  Predicate<? super String> mayKeyClassifier;
  if (mayClassifier != null) {
    mayKeyClassifier = mayClassifier;
  } else if (mayKeySet.isEmpty()) {
      // If nothing specified, assume permissive.
    mayKeyClassifier = Predicates.alwaysTrue();
  } else {
    // If a set specified, defer to the set.
    mayKeyClassifier = Predicates.<String>alwaysFalse();
  }

  ImmutableSet<String> onceKeySet = onceKeys.build();
  Predicate<? super String> onceKeyClassifier;
  if (onceClassifier != null) {
    onceKeyClassifier = onceClassifier;
  } else {
    onceKeyClassifier = Predicates.<String>alwaysFalse();
  }

  ImmutableSet<String> mustKeySet = mustKeys.build();
  ImmutableMap<String, Predicate<? super Optional<String>>> valueClassifierMap =
      ImmutableMap.copyOf(valueClassifiers);

  // If something may appear once or must appear, then it may appear.
  if (!Predicates.alwaysTrue().equals(mayKeyClassifier)) {
    if (!Predicates.alwaysFalse().equals(onceKeyClassifier)) {
      mayKeyClassifier = Predicates.or(mayKeyClassifier, onceKeyClassifier);
    }
    mayKeySet = ImmutableSet.<String>builder()
        .addAll(mayKeySet)
        .addAll(onceKeySet)
        .addAll(mustKeySet)
        .build();
  }

  return new QueryClassifierImpl(
      mayKeySet,
      mayKeyClassifier,
      onceKeySet,
      onceKeyClassifier,
      mustKeySet,
      valueClassifierMap);
}
 
Example 20
Project: url-classifier   File: UrlClassifierBuilder.java   Source Code and License Vote up 4 votes
/**
 * Builds a classifier based on previous allow/match decisions.
 * This may be reused after a call to build and subsequent calls to
 * allow/match methods will not affect previously built classifiers.
 * @return this
 */
public UrlClassifier build() {
  ImmutableSet<UrlValue.CornerCase> toleratedCornerCaseSet =
      Sets.immutableEnumSet(this.toleratedCornerCases);
  ImmutableSet<Scheme> allowedSchemeSet = allowedSchemes.build();
  MediaTypeClassifier mtc = mediaTypeClassifier != null
      ? mediaTypeClassifier
      : MediaTypeClassifiers.or();
  AuthorityClassifier ac = authorityClassifier != null
      ? authorityClassifier
      : AuthorityClassifiers.any();
  ImmutableSet<String> positivePathGlobSet = positivePathGlobs.build();
  ImmutableSet<String> negativePathGlobSet = negativePathGlobs.build();
  Pattern positivePathPattern = positivePathGlobSet.isEmpty()
      ? null
      : PathGlobs.toPattern(positivePathGlobSet);
  Pattern negativePathPattern = negativePathGlobSet.isEmpty()
      ? null
      : PathGlobs.toPattern(negativePathGlobSet);
  QueryClassifier qc = queryClassifier != null
      ? queryClassifier
      : QueryClassifiers.any();
  FragmentClassifier fc = fragmentClassifier != null
      ? fragmentClassifier
      : FragmentClassifiers.any();
  ContentClassifier cc = contentClassifier != null
      ? contentClassifier
      : ContentClassifiers.any();

  return new UrlClassifierImpl(
      toleratedCornerCaseSet,
      allowedSchemeSet,
      mtc,
      ac,
      positivePathPattern,
      negativePathPattern,
      qc,
      fc,
      cc
      );
}