}

// ApplyTo fills up LegacySATokenCleaner config with options.
func (o *LegacySATokenCleanerOptions) ApplyTo(cfg *serviceaccountconfig.LegacySATokenCleanerConfiguration) error {
	if o == nil {
		return nil
	}

	cfg.CleanUpPeriod = o.CleanUpPeriod

	return nil
}

}

// ApplyTo fills up TTLAfterFinishedController config with options.
func (o *TTLAfterFinishedControllerOptions) ApplyTo(cfg *ttlafterfinishedconfig.TTLAfterFinishedControllerConfiguration) error {
	if o == nil {
		return nil
	}

	cfg.ConcurrentTTLSyncs = o.ConcurrentTTLSyncs

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: test-patch-filter-chain
  namespace: egress
spec:
  configPatches:
    - applyTo: FILTER_CHAIN
      match:
        listener:
          filterChain:
            sni: www.example.com
      patch:
        operation: MERGE
        value:
          transportSocket:
            name: envoy.transport_sockets.tls
            typedConfig:

}

// ApplyTo fills up JobController config with options.
func (o *CronJobControllerOptions) ApplyTo(cfg *cronjobconfig.CronJobControllerConfiguration) error {
	if o == nil {
		return nil
	}

	cfg.ConcurrentCronJobSyncs = o.ConcurrentCronJobSyncs

	return nil
}

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: filter-local-ratelimit-svc
  namespace: istio-system
spec:
  workloadSelector:
    labels:
      app: productpage
  configPatches:
    - applyTo: HTTP_FILTER
      match:
        context: SIDECAR_INBOUND
        listener:
          filterChain:
            filter:
              name: "envoy.filters.network.http_connection_manager"
      patch:

	etcdOptions.SkipHealthEndpoints = true // avoid double wiring of health checks
	if err := etcdOptions.ApplyTo(&genericConfig); err != nil {
		return nil, err
	}

	// override MergedResourceConfig with apiextensions defaults and registry
	if err := commandOptions.APIEnablement.ApplyTo(
		&genericConfig,
		apiextensionsapiserver.DefaultAPIResourceConfigSource(),
		apiextensionsapiserver.Scheme); err != nil {

            if (rejectedComponent != null) {
                resolveResult.missing();
            }
        }
    }

    protected void applyTo(ResourceAwareResolveResult result) {
        resolveResult.applyTo(result);
    }

    public boolean canMakeFurtherAttempts() {
        return !searchedRemotely;
    }

        def result = toResult(args, overrides)

        def parameters = new BuildLayoutParameters()
        result.applyTo(parameters)

        assert result.gradleUserHomeDir == parameters.gradleUserHomeDir

        def startParameters = new StartParameterInternal()
        result.applyTo(startParameters)

        assert startParameters.gradleUserHomeDir == parameters.gradleUserHomeDir

    @Override
    public boolean shouldUseGradleMetatada() {
        return state == State.Redirect;
    }

    public <S> void applyTo(BuildableModuleComponentMetaDataResolveResult<S> target, Function<T, S> resultMapper) {
        if (state == State.Resolved) {
            target.resolved(resultMapper.apply(metaData));
        } else if (state == State.Failed) {
            target.failed(failure);
        } else if (state == State.Redirect) {

        }

        @Override
        public void applyTo(boolean value, ParallelismConfiguration settings, Origin origin) {
            settings.setParallelProjectExecutionEnabled(value);
        }
    }