createEndpoints(t, c, serviceExportName, serviceExportNamespace, []string{"tcp-port"}, []string{serviceExportPodIP}, nil, nil)

	ec := c.exports.(*serviceExportCacheImpl)
	// Wait for the resources to be processed by the controller.
	retry.UntilOrFail(t, func() bool {
		if svc := ec.GetService(ec.serviceHostname()); svc == nil {
			return false
		}
		inst := ec.getEndpoint(c.Endpoints)
		return inst != nil

 */
public interface Dispatch<T> {
    /**
     * Dispatches the next message. Blocks until the messages has been accepted but generally does not wait for the
     * message to be processed. Delivery guarantees are implementation specific.
     *
     * @param message The message.
     */
    void dispatch(T message);

	if cpu.S390X.HasVX {
		MaxLen = 64
	}
}

// Cutover reports the number of failures of IndexByte we should tolerate
// before switching over to Index.
// n is the number of bytes processed so far.
// See the bytes.Index implementation for details.
func Cutover(n int) int {
	// 1 error per 8 characters, plus a few slop to start.
	return (n + 16) / 8

 *
 */
public interface ModelBuildingListener {

    /**
     * Notifies the listener that the model has been constructed to the extent where build extensions can be processed.
     *
     * @param event The details about the event.
     */
    void buildExtensionsAssembled(ModelBuildingEvent event);

// Package pgo contains the compiler-agnostic portions of PGO profile handling.
// Notably, parsing pprof profiles and serializing/deserializing from a custom
// intermediate representation.
package pgo

// Profile contains the processed data from the PGO profile.
type Profile struct {
	// TotalWeight is the aggregated edge weights across the profile. This
	// helps us determine the percentage threshold for hot/cold
	// partitioning.
	TotalWeight int64

	item := config.NamespacedName(ing)
	if shouldProcess {
		// record processed ingress
		c.mutex.Lock()
		c.ingresses[item] = ing
		c.mutex.Unlock()
		return true
	}

	c.mutex.Lock()
	_, preProcessed := c.ingresses[item]
	// previous processed but should not currently, delete it
	if preProcessed && !shouldProcess {
		delete(c.ingresses, item)
	} else {

  optional int64 observedGeneration = 1;

  // DisruptedPods contains information about pods whose eviction was
  // processed by the API server eviction subresource handler but has not
  // yet been observed by the PodDisruptionBudget controller.
  // A pod will be in this map from the time when the API server processed the
  // eviction request to the time when the pod is seen by PDB controller

 * under the License.
 */
package org.apache.maven.api.services;

import java.util.function.Supplier;

/**
 * Caches auxiliary data used during model building like already processed raw/effective models. The data in the cache
 * is meant for exclusive consumption by the model builder and is opaque to the cache implementation. The cache key is

     *            {@code null}.
     * @throws BeanConfigurationException If the bean configuration could not be successfully processed.
     */
    void configureBean(BeanConfigurationRequest request) throws BeanConfigurationException;

 */
public interface ExpandDetails {
    /**
     * Controls if the underlying {@link groovy.text.SimpleTemplateEngine} escapes backslashes in the file before processing. If this is set to {@code false} then escape sequences in the processed
     * files ({@code \n}, {@code \t}, {@code \\}, etc) are converted to the symbols that they represent, so, for example {@code \n} becomes newline. If set to {@code true} then escape sequences are
     * left as is.
     * <p>