* override {@code addAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedSet}.
 *

 * a number of capabilities. Some examples:
 *
 * <ul>
 * <li>An implementation may decorate the instances in some fashion, for example to mix in the Groovy DSL, and so may return a subclass of the requested type.
 *

 */
@Incubating
@HasInternalProtocol
public interface TypeBuilder<T> {

    /**
     * Allows the plugin to register the implementation type.
     * @param implementation the implementation class.
     */
    TypeBuilder<T> defaultImplementation(Class<?> implementation);

    /**
     * Allows type registration rules to add internal views to the registered type.
     * @param internalView the internal view class

import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * This class provides a skeletal implementation of the {@code Iterator} interface, to make this
 * interface easier to implement for certain types of data sources.
 *
 * <p>{@code Iterator} requires its implementations to support querying the end-of-data status
 * without changing the iterator's state, using the {@link #hasNext} method. But many data sources,

    VISUALCPP_2019,
    // Any available Visual Studio >= 2019
    VISUALCPP_2019_OR_NEWER,
    // Any windows GCC compatible implementation (mingw, cygwin)
    WINDOWS_GCC,
    // Any available GCC implementation (including mingw, cygwin, but not clang)
    GCC,
    // Any available GCC compatible implementation (including mingw, cygwin, and clang)
    GCC_COMPATIBLE,
    // Any available Clang
    CLANG,
    // Any Swift compiler

    /**
     * Writes a signed 64 bit long value. The implementation may encode the value as a variable number of bytes, not necessarily as 8 bytes.
     */
    void writeLong(long value) throws IOException;

    /**
     * Writes a signed 64 bit long value whose value is likely to be small and positive but may not be. The implementation may encode the value in a way that is more efficient for small positive
     * values.

    /**
     * Returns a {@link DependencyCollector} that collects the set of implementation dependencies.
     * <p>
     * <code>implementation</code> dependencies are used at compilation and runtime.
     *
     * @return a {@link DependencyCollector} that collects the set of implementation dependencies
     * @since 7.6
     */
    DependencyCollector getImplementation();

    /**

                        throw new RuntimeException(String.format("No implementation class for service '%s' specified.", serviceType.getName()));
                    }
                } catch (Throwable e) {
                    throw new ServiceLookupException(String.format("Could not determine implementation class for service '%s' specified in resource '%s'.", serviceType.getName(), resource), e);
                }

// tag::java-toolchain-resolver-implementation[]
public abstract class JavaToolchainResolverImplementation
        implements JavaToolchainResolver { // <1>

    public Optional<JavaToolchainDownload> resolve(JavaToolchainRequest request) { // <2>
        return Optional.empty(); // custom mapping logic goes here instead
    }
}

     *
     * @since 6.8
     */
    Property<JvmVendorSpec> getVendor();

    /**
     * The virtual machine implementation of the toolchain.
     * <p>
     * By default, any implementation (hotspot, j9, ...) is eligible.
     * <p>
     * Note that the implementation can only be configured if the {@link #getLanguageVersion() language version} is configured as well.
     *
     * @since 6.8
     */