def node = graph.projectNode(selectedProjectIdentityPath, selectedModuleVersionId)
            deps << new EdgeBuilder(this, requested, node)
            applyTo(node, cl)
            return node
        }

        private static void applyTo(NodeBuilder node, Closure cl) {
            cl.resolveStrategy = Closure.DELEGATE_ONLY
            cl.delegate = node
            cl.call()
        }

        /**

            this.request = request;
            this.resolved = resolved;
        }

        public void apply(PluginManagerInternal target) {
            try {
                try {
                    pluginApplicationListenerBroadcaster.pluginApplied(request);
                    resolved.applyTo(target);
                } catch (UnknownPluginException e) {
                    throw couldNotApply(request, request.getId(), e);

            metadataValueContainer.finalizeIfNotAlready();
            metadataValueContainer.get().applyTo(result);
        } catch (ExecutionException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

        }

        @Override
        public void applyTo(String value, LoggingConfiguration settings, Origin origin) {
            String consoleValue = TextUtil.capitalize(TextUtil.toLowerCaseLocaleSafe(value));
            try {

		{
			ApplyTo: networking.EnvoyFilter_LISTENER,
			Match: &networking.EnvoyFilter_EnvoyConfigObjectMatch{
				Context: networking.EnvoyFilter_SIDECAR_OUTBOUND,
			},
			Patch: &networking.EnvoyFilter_Patch{
				Operation: networking.EnvoyFilter_Patch_ADD,
				Value:     buildPatchStruct(`{"name":"new-outbound-listener"}`),
			},
		},
		{
			ApplyTo: networking.EnvoyFilter_LISTENER,

                    cachedMetadata.putProcessedMetadata(metadataProcessor.getRulesHash(), state);
                    localResult.applyTo(result);
                    result.resolved(state);
                    break;
                case Failed:
                    localResult.applyTo(result, metadata -> {
                        // should not be called
                        throw new IllegalStateException();

        if (!metadataProvider.isUsable()) {
            applyTo(metadataProvider, result);
            return true;
        }
        return false;
    }

    private static DefaultMetadataProvider createMetadataProvider(ModuleComponentResolveState candidate) {
        return new DefaultMetadataProvider(candidate);
    }

    private static void applyTo(DefaultMetadataProvider provider, ComponentSelectionContext result) {

	}
}

func TestRestOptionsStorageObjectCountTracker(t *testing.T) {
	serverConfig := server.NewConfig(codecs)
	etcdOptions := &EtcdOptions{}
	if err := etcdOptions.ApplyTo(serverConfig); err != nil {
		t.Fatalf("Failed to apply etcd options error: %v", err)
	}
	restOptions, err := serverConfig.RESTOptionsGetter.GetRESTOptions(schema.GroupResource{Group: "", Resource: ""})
	if err != nil {
		t.Fatal(err)
	}

        }
        modelRegistry.bind(action.getSubject(), type, action);
    }

    @Override
    public void applyTo(NodePredicate predicate, ModelActionRole role, ModelAction action) {
        modelRegistry.configureMatching(predicate.scope(getPath()), role, action);
    }

    @Override
    public void applyTo(NodePredicate predicate, Class<? extends RuleSource> rules) {

        def task = new Object() {
            String getPath() { return path }
        }
        return new FixedBuildIdentifierProvider(id()).applyTo(new ProtocolToModelAdapter().builder(Task)).build(task)
    }

    def selector(def object) {
        return new FixedBuildIdentifierProvider(id()).applyTo(new ProtocolToModelAdapter().builder(TaskSelector)).build(object)
    }

    def id() {