} else {
		state.currentState.slots = state.currentState.slots[:numSlots]
	}
	if cap(state.currentState.registers) < len(state.registers) {
		state.currentState.registers = make([][]SlotID, len(state.registers))
	} else {
		state.currentState.registers = state.currentState.registers[:len(state.registers)]
	}

	// A relatively small slice, but used many times as the return from processValue.

import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestServiceRegistrar
import org.jetbrains.kotlin.test.services.TestServices

/**
 * Registers services specific to Standalone mode *tests*, in addition to the Standalone production services registered by

        def configurationCache = newConfigurationCacheFixture()
        def buildDirName = 'my-build-dir'
        def buildDir = file(buildDirName)
        buildFile """

            // lifecycle-base plugin registers layout.buildDirectory as a build output
            plugins { id 'lifecycle-base' }

            abstract class MyBuildService implements $BuildService.name<${BuildServiceParameters.name}.None> {

 * Allows registration of software types implemented by plugins.
 */
@ServiceScope(Scope.Build.class) // TODO: Might be too specific a scope, but needed something there
public interface SoftwareTypeRegistry {
    /**
     * Registers a plugin as providing a software type.  Cannot be called again once the list of software types has been
     * queried via {@link #getSoftwareTypeImplementations()}.
     */

// Sparsifies model to encode sparse tensors with proper format. Throws error if
// sparsification fails.
PyObject* MlirSparsifyModel(PyObject* data);

// Registers the given custom opdefs to TensorFlow global op registry.
PyObject* RegisterCustomOpdefs(PyObject* list);

// Returns the collected TFLite conversion errors.
std::vector<std::string> RetrieveCollectedErrors();

	if !kube.WaitForCacheSync("tag watcher", stopCh, p.webhooks.HasSynced) {
		return
	}
	// Notify handlers of initial state
	p.notifyHandlers()
	p.queue.Run(stopCh)
}

// AddHandler registers a new handler for updates to tag changes.
func (p *tagWatcher) AddHandler(handler TagHandler) {
	p.handlers = append(p.handlers, handler)
}

func (p *tagWatcher) HasSynced() bool {
	return p.queue.HasSynced()
}

import static org.gradle.api.internal.initialization.DefaultScriptClassPathResolver.InstrumentationPhase.NOT_INSTRUMENTED;

/**
 * Registers all Artifact transforms required for the instrumentation pipelines.
 */
public class InstrumentationTransformRegisterer {

    private static final String BUILD_SERVICE_NAME = "__InternalCacheInstrumentationDataBuildService__";

    def registersSoftwareTypes = Mock(RegistersSoftwareTypes)
    def softwareTypePluginMetadata = Mock(TypeMetadata)
    def propertyMetadata = Mock(PropertyMetadata)

    def "adds software type plugins for plugin that registers software types"() {
        when:
        pluginTarget.applyImperative(null, plugin)

        then: // setup property metadata
        2 * inspectionScheme.getMetadataStore() >> metadataStore

func (s *Server) getMetricMethodBucket(method string) string {
	if s.metricsMethodBuckets.Has(method) {
		return method
	}
	return "other"
}

// InstallDefaultHandlers registers the default set of supported HTTP request
// patterns with the restful Container.
func (s *Server) InstallDefaultHandlers() {
	s.addMetricsBucketMatcher("healthz")
	healthz.InstallHandler(s.restfulCont,

        this.moduleReplacements = moduleReplacements;
    }

    @Override
    public ModuleConflictResolver<ComponentState> getResolver() {
        return resolver;
    }

    /**
     * Registers new newModule and returns an instance of a conflict if conflict exists.
     */
    @Override
    public PotentialConflict registerCandidate(CandidateModule candidate) {