// LD - 5/6/14
        MutableModelNode backingNode = ((ManagedInstance) binaries).getBackingNode();
        ModelPath binaryPath = backingNode.getPath().child(name);
        backingNode.applyToLink(ModelActionRole.Defaults, DirectNodeNoInputsModelAction.of(
            ModelReference.of(binaryPath, NativeBinarySpec.class),
            new SimpleModelRuleDescriptor("initialize binary " + binaryPath),

        node.applyToSelf(role, action.transform(ModelActionBuilder.of()));
    }

    public static void applyToLink(MutableModelNode node, ModelActionRole role, Transformer<ModelAction, ModelActionBuilder<?>> action) {
        node.applyToLink(role, action.transform(ModelActionBuilder.of()));
    }

    /**
     * Applies an action to a linked node.
     *
     * The path returned by {@link ModelAction#getSubject()} is used to select the link to apply the action to.
     */
    void applyToLink(ModelActionRole type, ModelAction action);

    /**
     * Applies the rules defined in the given rule source to this node.
     */
    void applyToSelf(Class<? extends RuleSource> rules);

    /**

        @Override
        void addLink(ModelRegistration registration) {

        }

        @Override
        void removeLink(String name) {

        }

        @Override
        def void applyToLink(ModelActionRole type, ModelAction action) {

        }

        @Override
        void applyTo(NodePredicate predicate, ModelActionRole role, ModelAction action) {

        }

        @Override

    public Set<String> getLinkNames(ModelType<?> type) {
        return getLinkNames(withType(type));
    }

    @Override
    public void defineRulesForLink(ModelActionRole role, ModelAction action) {
        applyToLink(role, action);
    }

    @Override
    public void defineRulesFor(NodePredicate predicate, ModelActionRole role, ModelAction action) {
        applyTo(predicate, role, action);
    }

    @Override

        ModelRuleDescriptor descriptor = sourceDescriptor.append("named(%s)", name);
        ModelReference<T> subject = ModelReference.of(modelNode.getPath().child(name), elementType);
        modelNode.applyToLink(ModelActionRole.Mutate, new FilteringActionWrapper<T>(elementFilter, subject, NoInputsModelAction.of(subject, descriptor, configAction)));
    }

    @Override

    }

    @Override
    public void removeLink(String name) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void applyToLink(ModelActionRole type, ModelAction action) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void applyTo(NodePredicate predicate, ModelActionRole role, ModelAction action) {

        ModelNodeInternal linked = getLink(name);
        return linked != null && predicate.apply(linked);
    }

    @Override
    public void applyToLink(ModelActionRole type, ModelAction action) {
        if (!getPath().isDirectChild(action.getSubject().getPath())) {

            node.addLinkInstance("parent.foo", "ignore me")
            node.addLinkInstance("parent.bar", new Bean(value: "bar"))
            node.applyToLink(ModelActionRole.Mutate) { it.path("parent.bar").node { MutableModelNode bar ->
                bar.addLinkInstance("parent.bar.child1", new Bean(value: "baz"))
                bar.addLinkInstance("parent.bar.child2", "ignore me too")