@Override
    public String getLocation() {
        return "";
    }

    @Override
    public String getMessage() {
        String msg = null;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else if (exception != null) {
            msg = exception.getMessage();
        }

        if (msg == null) {
            msg = "";
        }

        this.fromLock = fromLock;
        this.reason = reason;
    }

    private static List<IvyArtifactName> asImmutable(List<IvyArtifactName> artifactNames) {
        return artifactNames.isEmpty() ? Collections.emptyList() : artifactNames instanceof ImmutableList ? artifactNames : ImmutableList.copyOf(artifactNames);
    }

    @Override
    public String toString() {

        CacheOperationStack stack = stackForThread.get();
        if (stack == null) {
            throw new IllegalStateException("Operation stack is empty.");
        }
        stack.popCacheAction();
        if (stack.isEmpty()) {
            stackForThread.remove();
        }
    }

    public boolean isInCacheAction() {
        CacheOperationStack stack = stackForThread.get();
        return stack != null && stack.isInCacheAction();

            operations.add(InternalBuildProgressListener.TEST_OUTPUT);
        }
        if (!fileDownloadListeners.isEmpty()) {
            operations.add(InternalBuildProgressListener.FILE_DOWNLOAD);
        }
        if (!buildPhaseListeners.isEmpty()) {
            operations.add(InternalBuildProgressListener.BUILD_PHASE);
        }
        if (!problemListeners.isEmpty()) {

        builder.append(defaultValue);
        builder.append("): ");
        return builder.toString();
    }

    @Override
    public PromptResult<Integer> convert(String text) {
        if (text.isEmpty()) {
            return PromptResult.response(defaultValue);
        }
        String trimmed = text.trim();
        try {
            int result = Integer.parseInt(trimmed);
            if (result >= minValue) {

        ongoing.remove(new TransferResourceIdentifier(event.getResource()));
        put(event, ongoing.isEmpty());
    }

    @Override
    public void transferFailed(TransferEvent event) {
        ongoing.remove(new TransferResourceIdentifier(event.getResource()));
        put(event, ongoing.isEmpty());
    }

    private static class Exchange {
        private final TransferEvent event;

                    .setMessage("Unknown packaging: " + packaging)
                    .setLocation(model.getLocation("packaging")));
        } else if (!defaultPlugins.isEmpty()) {
            List<Plugin> plugins = defaultPlugins.stream()
                    .map(org.apache.maven.model.Plugin::getDelegate)
                    .collect(Collectors.toList());

        boolean isEmpty();

        /**
         * Returns a shallow copy of this value collector, to avoid sharing mutable data.
         */
        ValueCollector isolated();
    }

    private static class EmptyCollector implements ValueCollector {
        @Override
        public boolean isEmpty() {
            return true;
        }

        @Override

        for (String config : fromConfiguration.getHierarchy()) {
            if (confs.containsKey(config)) {
                Set<String> targetPatterns = confs.get(config);
                if (!targetPatterns.isEmpty()) {
                    matched = true;
                }
                for (String targetPattern : targetPatterns) {

    public void close() {
        CompositeStoppable.stoppable(executor, cache).stop();
    }

    @Override
    public ClassPath transform(ClassPath classPath, StandardTransform transform) {
        if (classPath.isEmpty()) {
            return classPath;
        }
        return transformPipelineFor(transform).transform(classPath);

    }

    @FunctionalInterface
    private interface TransformPipeline {