*/

package org.gradle.model.internal.registry;

import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.SetMultimap;
import org.gradle.model.internal.core.ModelNode;
import org.gradle.model.internal.core.ModelPath;

import javax.annotation.Nullable;
import java.util.ArrayDeque;
import java.util.Collections;
import java.util.Deque;
import java.util.Iterator;

        super(subject, descriptor, inputs);
    }

    @Override
    final public void execute(MutableModelNode node, List<ModelView<?>> inputs) {
        if (!node.isAtLeast(ModelNode.State.Created)) {
            throw new IllegalStateException("Cannot get view for node " + node.getPath() + " in state " + node.getState());
        }
        ModelType<T> type = getSubject().getType();

    public ModelRuleDescriptor getDescriptor() {
        return descriptor;
    }

    @Override
    public void execute(ModelRuleInvoker<?> invoker, MutableModelNode modelNode, List<ModelView<?>> inputs) {
        ModelView<? extends T> subjectView = modelNode.asMutable(getSubject().getType(), descriptor);
        try {
            execute(invoker, subjectView.getInstance(), inputs);
        } finally {
            subjectView.close();

 * limitations under the License.
 */

package org.gradle.model.internal.registry;

import javax.annotation.concurrent.ThreadSafe;
import org.gradle.api.Transformer;
import org.gradle.model.internal.core.ModelNode;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.report.unbound.UnboundRule;

        expect:
        registry.node("s").state == ModelNode.State.Registered

        when:
        registry.atState("beans", ModelNode.State.SelfClosed)

        then:
        registry.node("s").state == ModelNode.State.Registered
        registry.get("beans.b1", Bean).value != "changed"
        registry.node("s").state == ModelNode.State.Registered

        when:

import org.gradle.api.tasks.options.Option;
import org.gradle.internal.logging.text.StyledTextOutput;
import org.gradle.internal.logging.text.StyledTextOutputFactory;
import org.gradle.model.internal.core.ModelNode;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.registry.ModelRegistry;
import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;

/**

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

import java.util.List;

public interface ModelAction {

    ModelReference<?> getSubject();

    void execute(MutableModelNode modelNode, List<ModelView<?>> inputs);

    List<? extends ModelReference<?>> getInputs();

    ModelRuleDescriptor getDescriptor();

        @Override
        public List<? extends ModelReference<?>> getInputs() {
            return inputs;
        }

        @Override
        public void execute(ModelRuleInvoker<?> ruleInvoker, MutableModelNode modelNode, List<ModelView<?>> inputs) {
            Object instance;
            if (inputs.size() == 0) {
                instance = ruleInvoker.invoke();
            } else {

import java.util.List;

public interface MethodRuleAction {
    ModelReference<?> getSubject();

    List<? extends ModelReference<?>> getInputs();

    void execute(ModelRuleInvoker<?> invoker, MutableModelNode modelNode, List<ModelView<?>> inputs);

    <T> void bind(ModelReference<T> subject, ModelActionRole role, ModelAction mutator);

    void transition(ModelNodeInternal node, ModelNode.State desired, boolean laterOk);