* @since 16.0
 */
@Beta
public final class HashingOutputStream extends FilterOutputStream {
  private final Hasher hasher;

  /**
   * Creates an output stream that hashes using the given {@link HashFunction}, and forwards all
   * data written to it to the underlying {@link OutputStream}.
   *
   * <p>The {@link OutputStream} should not be written to before or after the hand-off.
   */

    WRAPPER_TO_PRIMITIVE_TYPE = Collections.unmodifiableMap(wrapToPrim);
  }

  private static void add(
      Map<Class<?>, Class<?>> forward,
      Map<Class<?>, Class<?>> backward,
      Class<?> key,
      Class<?> value) {
    forward.put(key, value);
    backward.put(value, key);
  }

  /**
   * Returns an immutable set of all nine primitive types (including {@code void}). Note that a

import java.util.Collections;
import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * GWT implementation of {@link ImmutableMap} that forwards to another map.
 *
 * @author Hayward Chan
 */
public abstract class ForwardingImmutableMap<K, V> extends ImmutableMap<K, V> {

  final transient Map<K, V> delegate;

                                        value="<la:message key="labels.wizard_button_finish"/>">
                                    <i class="fa fa-step-forward" aria-hidden="true"></i>
                                    <la:message key="labels.wizard_button_finish"/>
                                </button>
                            </div>
                        </div>

import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import org.jspecify.annotations.Nullable;

/**
 * A cache which forwards all its method calls to another cache. Subclasses should override one or
 * more methods to modify the behavior of the backing cache as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.

    }

    @Test
    void getHostAddressDelegatesToWrappedInetAddress() {
        InetAddress dummy = mock(InetAddress.class);
        when(dummy.getHostAddress()).thenReturn("192.0.2.1");
        UniAddress ua = new UniAddress(dummy);
        assertEquals("192.0.2.1", ua.getHostAddress(), "should forward hostAddress to underlying InetAddress");
    }

 *   <li>{@link UnmodifiableIterator}
 *   <li>{@link UnmodifiableListIterator}
 * </ul>
 *
 * <h2>Forwarding collections</h2>
 *
 * We provide implementations of collections that forward all method calls to a delegate collection
 * by default. Subclasses can override one or more methods to implement the decorator pattern. For
 * an example, see {@link ForwardingCollection}.
 *
 * <h2>Other</h2>
 *

  @Override
  public NavigableMap<K, V> descendingMap() {
    return new DescendingMap();
  }

  private final class DescendingMap extends Maps.DescendingMap<K, V> {
    @Override
    NavigableMap<K, V> forward() {
      return AbstractNavigableMap.this;
    }

    @Override
    Iterator<Entry<K, V>> entryIterator() {
      return descendingEntryIterator();
    }
  }

    for (int i = 0; i < result.length; i++) {
      result[i] = cipherSuites.get(i).javaName();
    }
    return result;
  }

  /**
   * An SSL socket factory that forwards all calls to a delegate. Override {@link #configureSocket}
   * to customize a created socket before it is returned.
   */
  static class DelegatingSSLSocketFactory extends SSLSocketFactory {

 * allow to create such sub-contexts.
 *
 *
 * Implementors of this interface should extend {@link jcifs.context.BaseContext} or
 * {@link jcifs.context.CIFSContextWrapper} to get forward compatibility.
 *
 * @author mbechler
 *
 */
public interface CIFSContext {

    /**
     * Get a resource
     *
     * @param url the URL of the SMB resource