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 "));

    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();
        }

     * @throws EmptyArgumentException
     *             引数が<code>null</code>または空文字列の場合。
     */
    public static void assertArgumentNotEmpty(final String argName, final String argValue) {
        if (StringUtil.isEmpty(argValue)) {
            throw new EmptyArgumentException(argName, "ECL0010", asArray(argName));
        }
    }

    /**
     * 引数が<code>null</code>でも空文字列でもないことを表明します。
     *
     * @param argName

    ) {
        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;

                && profile.getDistributionManagement() == null
                && profile.getModules().isEmpty()
                && profile.getProperties().isEmpty()
                && profile.getRepositories().isEmpty()
                && profile.getPluginRepositories().isEmpty()
                && profile.getReporting() == null;
    }

      Entry<K, Collection<V>> entry = entryIterator.next();
      K key = entry.getKey();
      Collection<V> collection = filterCollection(entry.getValue(), new ValuePredicate(key));
      if (!collection.isEmpty()
          && predicate.apply(Maps.<K, Collection<V>>immutableEntry(key, collection))) {
        if (collection.size() == entry.getValue().size()) {
          entryIterator.remove();
        } else {

        if (variant.getDependencies().isEmpty()) {
            return emptyList();
        }
        ArrayList<ModuleMetadataSpec.Dependency> dependencies = new ArrayList<>();
        Set<ExcludeRule> additionalExcludes = variant.getGlobalExcludes();
        for (ModuleDependency moduleDependency : variant.getDependencies()) {
            if (moduleDependency.getArtifacts().isEmpty()) {
                dependencies.add(

        if (watchedHierarchies.isEmpty()) {
            LOGGER.info("Not watching anything anymore");
        }

        List<File> hierarchiesToStopWatching = oldWatchedHierarchies.stream()
            .filter(oldWatchedHierarchy -> !watchedHierarchies.contains(oldWatchedHierarchy))
            .collect(ImmutableList.toImmutableList());
        if (!hierarchiesToStopWatching.isEmpty()) {

    public Set<String> getSuperTypes(String type) {
        return instrumentedSuperTypes.get().getOrDefault(type, Collections.emptySet());
    }

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

    public Optional<HashCode> getInstrumentedTypesHash() {
        return instrumentedHashCode.get();
    }

    public Optional<HashCode> getUpgradedPropertiesHash() {