return classBasedRulesOnly;
    }

    boolean isEmpty() {
        return rules.isEmpty();
    }

    @Override
    public Iterator<MetadataRuleWrapper> iterator() {
        return rules.iterator();
    }

    Collection<SpecConfigurableRule> getOnlyClassRules() {
        if (!isClassBasedRulesOnly() || isEmpty()) {

        StringBuilder sb = new StringBuilder();
        if (!inclusions.isEmpty()) {
            sb.append("(");
            sb.append(join(inclusions, " OR "));
            sb.append(")");
            if (!exclusions.isEmpty()) {
                sb.append(" AND ");
            }
        }
        if (!exclusions.isEmpty()) {
            sb.append("NOT (");
            sb.append(join(exclusions, " OR "));

            dependents.put(className, d);
        }
        return d;
    }

    @VisibleForTesting
    Map<String, DependentsSet> getDependentsMap() {
        if (dependenciesToAll.isEmpty() && privateDependents.isEmpty() && accessibleDependents.isEmpty()) {
            return Collections.emptyMap();
        }
        ImmutableMap.Builder<String, DependentsSet> builder = ImmutableMap.builder();

    }

    public void ownReference(String path, int lineNumber) {
        ownReferences.add(new InputReference(path, lineNumber));
    }

    public boolean isEmpty() {
        return ownReferences.isEmpty() && nestedReferences.isEmpty();
    }

    public List<InputReference> getNestedReferences() {
        return nestedReferences;
    }

    public void addNestedReferences(InputReferences inputReferences) {

    return rangeContaining(value) != null;
  }

  @Override
  @CheckForNull
  public abstract Range<C> rangeContaining(C value);

  @Override
  public boolean isEmpty() {
    return asRanges().isEmpty();
  }

  @Override
  public void add(Range<C> range) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void remove(Range<C> range) {

        if (common.isEmpty()) {
            return nothing();
        }
        if (common.size() == 1) {
            return moduleId(common.iterator().next());
        }
        return moduleIdSet(common);
    }

    default ExcludeSpec fromModules(Set<ModuleIdentifier> moduleIds) {
        if (moduleIds.isEmpty()) {
            return nothing();
        }

        if (propertiesRequiringIsEmptyCheck.isEmpty()) {
            return sourceFileProperties.values().stream()
                .allMatch(CurrentFileCollectionFingerprint::isEmpty);
        } else {
            // We need to check the underlying file collections for properties in propertiesRequiringIsEmptyCheck,

    ) throws Exception {
        if (keyStoreType.isEmpty()) {
            return null;
        }

        KeyStore keyStore;
        if (keyStoreProvider.isEmpty()) {
            keyStore = KeyStore.getInstance(keyStoreType);
        } else {
            keyStore = KeyStore.getInstance(keyStoreType, keyStoreProvider);
        }

        if (!keyStorePath.isEmpty() && !NONE.equals(keyStorePath)) {

        this.files = files;
    }

    @Override
    public String toString() {
        return files.toString();
    }

    @Override
    public boolean isEmpty() {
        return files.isEmpty();
    }

    @Override
    public List<URI> getAsURIs() {
        List<URI> urls = new ArrayList<URI>(files.size());
        for (File file : files) {
            urls.add(file.toURI());

    ) {
        if (!spec.getComponentFilter().isSatisfiedBy(componentId)) {
            return ResolvedArtifactSet.EMPTY;
        } else {

            if (spec.getSelectFromAllVariants() && !artifacts.isEmpty()) {
                // Variants with overridden artifacts cannot be reselected since
                // we do not know the "true" attributes of the requested artifact.
                return ResolvedArtifactSet.EMPTY;