* the License.
 */
package com.google.common.collect;

import java.util.Collection;
import org.jspecify.annotations.Nullable;

/** Never actually created; instead delegates to JdkBackedImmutableMultiset. */
final class RegularImmutableMultiset<E> extends ImmutableMultiset<E> {
  static final ImmutableMultiset<Object> EMPTY =
      JdkBackedImmutableMultiset.create(ImmutableList.of());

/**
 * Wraps an arbitrary object with an {@link ObjectBasedValueSource} instance, then
 * wraps that source with a {@link PrefixedValueSourceWrapper} instance, to which
 * this class delegates all of its calls.
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")

 * an expressive source hint for the model problem. Instead, the source hint is configured by the model builder before
 * it delegates to other components that potentially encounter problems. Then, the problem reporter can focus on
 * providing a simple error message, leaving the donkey work of creating a nice model problem to this component.
 *

        section.appendChild(segmentedlist);
        Element segtitle = document.createElement("segtitle");
        segmentedlist.appendChild(segtitle);
        segtitle.appendChild(document.createTextNode("Delegates to"));
        Element seglistitem = document.createElement("seglistitem");
        segmentedlist.appendChild(seglistitem);
        Element seg = document.createElement("seg");
        seglistitem.appendChild(seg);

          + localFallback
          + "]";
    } else if (superString != null) {
      return resultString + superString;
    }
    return null;
  }

  /**
   * An {@link AbstractCatchingFuture} that delegates to an {@link AsyncFunction} and {@link
   * #setFuture(ListenableFuture)}.
   */
  private static final class AsyncCatchingFuture<V extends @Nullable Object, X extends Throwable>
      extends AbstractCatchingFuture<

  override fun getPeerPrincipal(): Principal = delegate!!.peerPrincipal

  override fun getLocalPrincipal(): Principal = delegate!!.localPrincipal

  override fun getCipherSuite(): String = delegate!!.cipherSuite

  override fun getProtocol(): String = delegate!!.protocol

  override fun getPeerHost(): String = delegate!!.peerHost

  override fun getPeerPort(): Int = delegate!!.peerPort

            byte[] arr = new byte[12];
            assertEquals(0, response.readBytesWireFormat(arr, idx));
        }
    }

    @Test
    @DisplayName("toString contains class name and delegates to superclass")
    void toStringMatches() {
        String s = response.toString();
        assertNotNull(s);
        assertTrue(s.startsWith("SmbComSetInformationResponse["));
        assertTrue(s.endsWith("]"));

import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import org.jspecify.annotations.Nullable;

/**
 * List returned by {@link ImmutableCollection#asList} that delegates {@code contains} checks to the
 * backing collection.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
@SuppressWarnings("serial")

 * an expressive source hint for the model problem. Instead, the source hint is configured by the model builder before
 * it delegates to other components that potentially encounter problems. Then, the problem reporter can focus on
 * providing a simple error message, leaving the donkey work of creating a nice model problem to this component.
 *
 */

import javax.net.ssl.SSLSocketFactory

/**
 * A [SSLSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureSocket].
 */
open class DelegatingSSLSocketFactory(
  private val delegate: SSLSocketFactory,
) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }