boolean hasLink(String name, Predicate<? super MutableModelNode> predicate);

    @Nullable
    MutableModelNode getLink(String name);

    int getLinkCount(Predicate<? super MutableModelNode> predicate);

    Set<String> getLinkNames(Predicate<? super MutableModelNode> predicate);

    Set<String> getLinkNames();

    @Override
    Iterable<? extends MutableModelNode> getLinks(ModelType<?> type);

        return withType(ModelType.of(type), predicate);
    }

    public static Predicate<MutableModelNode> withType(final ModelType<?> type, final Predicate<? super MutableModelNode> predicate) {
        return new Predicate<MutableModelNode>() {
            @Override
            public boolean apply(MutableModelNode node) {

    public static <T> Builder unmanagedInstance(final ModelReference<T> modelReference, final Factory<? extends T> factory, final Action<? super MutableModelNode> initializer) {
        return unmanagedInstanceOf(modelReference, new Transformer<T, MutableModelNode>() {
            @Override
            public T transform(MutableModelNode modelNode) {
                T t = factory.create();
                initializer.execute(modelNode);
                return t;

public class DirectNodeNoInputsModelAction<T> extends AbstractModelActionWithView<T> {

    private final BiAction<? super MutableModelNode, ? super T> action;

    private DirectNodeNoInputsModelAction(ModelReference<T> subjectReference, ModelRuleDescriptor descriptor, BiAction<? super MutableModelNode, ? super T> action) {
        super(subjectReference, descriptor, Collections.<ModelReference<?>>emptyList());
        this.action = action;

    private final Predicate<? super MutableModelNode> matcher;

    private NodePredicate(Predicate<? super MutableModelNode> matcher) {
        this.matcher = matcher;
    }

    public ModelSpec scope(ModelPath scope) {
        return scope(scope, matcher);
    }

    protected abstract ModelSpec scope(ModelPath scope, Predicate<? super MutableModelNode> matcher);

    public static NodePredicate allLinks() {

    // ModelRegistry methods

    public static MutableModelNode atState(DefaultModelRegistry modelRegistry, String path, ModelNode.State state) {
        return (MutableModelNode) modelRegistry.atState(ModelPath.path(path), state);
    }

    public static MutableModelNode atStateOrLater(ModelRegistry modelRegistry, String path, ModelNode.State state) {
        return (MutableModelNode) modelRegistry.atStateOrLater(ModelPath.path(path), state);

    protected void initializePrivateData(MutableModelNode modelNode) {
    }

    private <V> void addProjection(MutableModelNode modelNode, StructSchema<V> viewSchema, ManagedProxyFactory proxyFactory, TypeConverter typeConverter) {
        modelNode.addProjection(new ManagedModelProjection<V>(viewSchema, bindings, proxyFactory, typeConverter));
    }

    private void addPropertyLinks(MutableModelNode modelNode,

    }

    @Nullable
    @Override
    public <T> ModelView<? extends T> asImmutable(ModelType<T> type, MutableModelNode node, @Nullable ModelRuleDescriptor ruleDescriptor) {
        return null;
    }

    @Nullable
    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> type, MutableModelNode node, ModelRuleDescriptor ruleDescriptor) {
        return null;
    }

    @Override

                MutableModelNode mutableModelNode = (MutableModelNode) modelNode;

                // Add tasks created through rules to the actual task container
                mutableModelNode.applyTo(allLinks(), ModelActionRole.Initialize, DirectNodeNoInputsModelAction.of(TASK_MODEL_REFERENCE, COPY_TO_TASK_CONTAINER_DESCRIPTOR, new BiAction<MutableModelNode, Task>() {
                    @Override

        return build(NO_REFS, new TriAction<MutableModelNode, T, List<ModelView<?>>>() {
            @Override
            public void execute(MutableModelNode mutableModelNode, T t, List<ModelView<?>> inputs) {
                action.execute(t);
            }
        });
    }

    public ModelAction node(final Action<? super MutableModelNode> action) {
        return toAction(action, path, type, descriptor);
    }