/**
 * A hierarchical service registry.
 */
public interface ServiceRegistryFactory {
    /**
     * Creates the services for the given domain object. The caller is responsible for closing the registry.
     *
     * @param domainObject The domain object.
     * @return The registry containing the services for the domain object.
     */
    ServiceRegistry createFor(Object domainObject);

                println "task container node state after graph closing: ${registry.state(tasksPath)}"
            }
        '''

        then:
        succeeds "t1"

        and:
        output.contains "task container node state when task graph ready: ${ModelNode.State.SelfClosed}"
        output.contains "task container node state after graph closing: ${ModelNode.State.GraphClosed}"
    }

import (
	"os/exec"
	"syscall"

	"golang.org/x/sys/windows"
)

func init() {
	daemonize = daemonizeWindows
}

func daemonizeWindows(cmd *exec.Cmd) {
	// Set DETACHED_PROCESS creation flag so that closing
	// the console window the parent process was run in
	// does not kill the child.
	// See documentation of creation flags in the Microsoft documentation:

 *
 *  * **Open:** the web socket has been accepted by the remote peer and is fully operational.
 *    Messages in either direction are enqueued for immediate transmission.
 *
 *  * **Closing:** one of the peers on the web socket has initiated a graceful shutdown. The web
 *    socket will continue to transmit already-enqueued messages but will refuse to enqueue new
 *    ones.
 *

 * Responsible for locating, constructing, and configuring the {@link SettingsInternal} for a build.
 */
public interface SettingsProcessor {
    /**
     * Load the settings for the given build. The caller is responsible for closing the return value.
     */
    SettingsState process(
        GradleInternal gradle,
        SettingsLocation settingsLocation,
        ClassLoaderScope buildRootClassLoaderScope,
        StartParameter startParameter

    private val writeContext: DefaultWriteContext
) : Closeable {
    override fun close() {
        // we synchronize access to all resources used by callbacks
        // in case there was still an event being dispatched at closing time.
        synchronized(writeContext) {
            unsafeWrite(null)
            writeContext.close()
        }
    }

    fun write(value: T, trace: PropertyTrace? = null) {

import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;

/**
 * Reads from a {@link RandomAccessFile}. Each operation reads from and advances the current position of the file.
 *
 * <p>Closing this stream does not close the underlying file.
 */
// TODO Replace this with Channels.newInputStream(SeekableByteChannel)
public class RandomAccessFileInputStream extends InputStream {
    private final RandomAccessFile file;

		}
		if err != nil {
			// read is already closed - we need to close out
			_ = closeWriter(dst)
			return
		}
	}
}

// CloseWriter is one of possible interfaces implemented by Out to send a FIN, without closing
// the input. Some writers only do this when Close is called.
type CloseWriter interface {
	CloseWrite() error
}

func closeWriter(dst io.Writer) error {
	if cw, ok := dst.(CloseWriter); ok {

 * CharSource CharSource}, {@link ByteSink ByteSink} and {@link CharSink CharSink}. They are
 * factories for I/O streams that provide many convenience methods that handle both opening and
 * closing streams for you.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>
 * library. For more information on Sources and Sinks as well as other features of this package, see

     * @throws GradleConnectionException On some other failure using the connection.
     * @throws IllegalStateException When the connection has been closed or is closing.
     * @since 1.0-milestone-3
     */
    T get() throws GradleConnectionException, IllegalStateException;

    /**