/**
     * 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
     */

 * this case, you should override {@code add(Object)} as well, either providing your own
 * implementation, or delegating to the provided {@code standardAdd} 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 ForwardingMultiset}.
 *

import java.io.Serializable;
import java.util.Collections;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

/**
 * Worker-side implementation of {@link RequestProtocol} executing actions.
 */
public class WorkerAction implements Action<WorkerProcessContext>, Serializable, RequestProtocol, StreamFailureHandler, Stoppable, StreamCompletion {

            throw new IllegalArgumentException("Provided component selector may not be null");
        }

        Implementation implementation = resolveImplementation(value);

        encoder.writeByte(implementation.getId());

        if (implementation == Implementation.MODULE) {
            ModuleComponentSelector moduleComponentSelector = (ModuleComponentSelector) value;

    private final String vendor;
    private final String implementation;

    public JavaToolchainInput(JavaToolchainSpec spec) {
        this.javaLanguageVersion = spec.getLanguageVersion().getOrNull();
        this.vendor = spec.getVendor().get().toString();
        this.implementation = spec.getImplementation().get().toString();
    }

    @Optional
    @Input

 * should override {@code equals} as well, either providing your own implementation, or delegating
 * to the provided {@code standardEquals} method.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equal} to test
 * equality for both keys and values. This may not be the desired behavior for map implementations
 * that use non-standard notions of key equality, such as the entry of a {@code SortedMap} whose