}

    @Nullable
    public ModelPath getScope() {
        return reference.getScope();
    }

    public ModelNode.State getState() {
        return reference.getState();
    }

// restored.
func MakeRaw(fd int) (*State, error) {
	return makeRaw(fd)
}

// GetState returns the current state of a terminal which may be useful to
// restore the terminal after a signal.
func GetState(fd int) (*State, error) {
	return getState(fd)
}

// Restore restores the terminal connected to the given file descriptor to a
// previous state.

	return false
}

func makeRaw(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func getState(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func restore(fd int, state *State) error {

        def newState = serialized(state)
        newState.fileStates.size() == 2

        def emptyCompileState = newState.getState(fileEmpty)
        emptyCompileState.hash == TestHashCodes.hashCodeFrom(0x12345678)
        emptyCompileState.edges.empty

        def otherCompileState = newState.getState(fileTwo)
        otherCompileState.hash == TestHashCodes.hashCodeFrom(0x23456789)
        otherCompileState.edges == stateTwo.edges
    }

        this.task = task;
    }

    public void mutate(String method, Runnable action) {
        if (!task.getState().isConfigurable()) {
            throw new IllegalStateException(format(method));
        }
        action.run();
    }

    public <T> T mutate(String method, Callable<T> action) {
        if (!task.getState().isConfigurable()) {
            throw new IllegalStateException(format(method));
        }

}

func makeRaw(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func getState(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func restore(fd int, state *State) error {

        }

        @Override
        public void onNodeComplete(Node node, Node dependency) {
        }

        @Override
        public Node.DependenciesState getState(Node node) {
            return Node.DependenciesState.COMPLETE_AND_SUCCESSFUL;
        }

        @Override
        public void healthDiagnostics(StringBuilder builder) {
            builder.append("no dependencies");

        def daemonInfo = registry.all.find { it.context.pid == context.pid }
        registry.remove(daemonInfo.address)
        registry.store(new DaemonInfo(daemonInfo.address, daemonInfo.context, "password".bytes, daemonInfo.getState()))
    }

    void assertRegistryNotWorldReadable() {
        def registryFile = new DaemonDir(context.daemonRegistryDir).registry
        if (OperatingSystem.current().isLinux() || OperatingSystem.current().isMacOsX()) {

        if (!project.getState().hasCompleted()) {
            return "configuration of " + project.getDisplayName() + " has not completed yet";
        } else if (producer != null) {
            TaskInternal producerTask = (TaskInternal) producer.getTaskThatOwnsThisObject();
            if (producerTask != null && producerTask.getState().isConfigurable()) {

    @Override
    public void onNodeComplete(Node node, Node dependency) {
        delegate.onNodeComplete(node, dependency);
    }

    @Override
    public Node.DependenciesState getState(Node node) {
        Node.DependenciesState state = delegate.getState(node);
        if (state != Node.DependenciesState.COMPLETE_AND_SUCCESSFUL) {
            return state;
        }

        for (Node dependency : orderedMustSuccessors) {