*/

package org.gradle.internal.exceptions;

import org.gradle.api.NonNullApi;

import java.util.List;

/**
 * A provider of resolutions for an exception.
 * Exceptions can be derived from this interface to provide a list of resolutions that are then displayed in the suggestion section of the error message.
 */

@NonNullApi
public interface ResolutionProvider {
    List<String> getResolutions();

import org.gradle.internal.component.resolution.failure.exception.AbstractResolutionFailureException
import org.gradle.internal.component.resolution.failure.exception.ArtifactVariantSelectionException
import org.gradle.internal.component.resolution.failure.exception.ConfigurationSelectionException
import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException

    private
    fun resolutionPrettyString(resolution: DocumentResolution): String =
        resolution::class.simpleName + when (resolution) {
            is DocumentResolution.ElementResolution.SuccessfulElementResolution.ContainerElementResolved ->
                " -> element ${functionSignatureString(resolution.elementFactoryFunction)}"

    public List<String> getResolutions() {
        List<String> resolutions = new ArrayList<String>(causes.size()); // Typical case is 0 or 1 resolutions/cause
        for (Throwable cause : causes) {
            if (cause instanceof ResolutionProvider) {
                resolutions.addAll(((ResolutionProvider) cause).getResolutions());
            }
        }
        return resolutions;
    }

import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException;
import org.gradle.internal.component.resolution.failure.type.VariantAwareAmbiguousResolutionFailure;
import org.gradle.internal.logging.text.StyledTextOutput;
import org.gradle.internal.logging.text.TreeFormatter;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;

        return formatter.toString();
    }

    @Override
    protected List<String> buildResolutions(String... resolutions) {
        List<String> result = new ArrayList<>(super.buildResolutions(resolutions));
        result.add(suggestDependencyInsight());
        return result;
    }

import javax.annotation.concurrent.ThreadSafe;

/**
 * A specialized {@link ComponentGraphResolveState} for external components.
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface ModuleComponentGraphResolveState extends ExternalComponentGraphResolveState {
    @Override

	soffset       uint32        // used by serverOffset
	singleRequest bool          // use sequential A and AAAA queries instead of parallel queries
	useTCP        bool          // force usage of TCP for DNS resolutions
	trustAD       bool          // add AD flag to queries
	noReload      bool          // do not check for config file updates
}

// serverOffset returns an offset that can be used to determine

import java.util.List;

/**
 * A specialized {@link ComponentGraphResolveState} for local components (ie project dependencies).
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface LocalComponentGraphResolveState extends ComponentGraphResolveState {

            if (!versionConflicts.isEmpty()) {
                List<String> resolutions = resolveContext.getFailureResolutions().forVersionConflict(versionConflicts);
                nonFatalFailuresBuilder.add(new VersionConflictException(versionConflicts, resolutions));
            }
        }

        Set<Throwable> nonFatalFailures = nonFatalFailuresBuilder.build();