import org.gradle.model.internal.core.ModelPromise;
import org.gradle.model.internal.core.ModelRegistration;
import org.gradle.model.internal.core.ModelView;
import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.core.NodePredicate;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;
import org.gradle.model.internal.inspect.ExtractedRuleSource;

        modelRegistry.configure(ModelActionRole.Initialize, DirectNodeNoInputsModelAction.of(reference, action.getDescriptor(), new Action<MutableModelNode>() {
            @Override
            public void execute(MutableModelNode node) {
                action.execute(node, role);
            }
        }));
    }

    public static boolean isTransformedBlock(Closure<?> closure) {

 * those defined by {@link #matches(MutableModelNode)}.
 */
public abstract class ModelSpec extends ModelPredicate {
    /**
     * Returns if the node matches this predicate.
     */
    public boolean matches(MutableModelNode node) {
        return true;
    }

import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.type.ModelType;

/**
 * A marker interface that is implemented by views of managed elements.
 */
public interface ManagedInstance {
    /**
     * Returns the node that this managed instance is backed by.
     */
    MutableModelNode getBackingNode();

    /**

    }

    @Override
    protected ModelView<M> toView(MutableModelNode modelNode, ModelRuleDescriptor ruleDescriptor, boolean writable) {
        M instance = Cast.uncheckedCast(modelNode.getPrivateData());
        return InstanceModelView.of(modelNode.getPath(), getType(), instance);
    }

    @Override
    public Optional<String> getValueDescription(MutableModelNode modelNode) {

import org.gradle.model.internal.core.ModelActionRole;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.ModelView;
import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.inspect.AbstractExtractedModelRule;
import org.gradle.model.internal.inspect.ExtractedModelRule;
import org.gradle.model.internal.inspect.MethodModelRuleApplicationContext;

            } else {
                MutableModelNode backingNode = ((ManagedInstance) value).getBackingNode();
                values.put(name, backingNode);
            }
        }

        @Override
        protected ModelPath calculateTarget(MutableModelNode target) {
            if (targetProperty != null) {
                return ((MutableModelNode)values.get(targetProperty.getName())).getPath();
            }

    protected final ModelType<E> elementType;
    protected final ModelType<C> type;
    protected final MutableModelNode modelNode;
    protected final boolean overwritable;
    protected final DefaultModelViewState state;

    public ScalarCollectionModelView(ModelPath path, ModelType<C> type, ModelType<E> elementType, MutableModelNode modelNode, ModelRuleDescriptor descriptor, boolean overwritable, boolean mutable) {
        this.path = path;

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();

        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());
        }