return new WrappedCollection(key, collection, null);
  }

  final List<V> wrapList(
      @ParametricNullness K key, List<V> list, @Nullable WrappedCollection ancestor) {
    return (list instanceof RandomAccess)
        ? new RandomAccessWrappedList(key, list, ancestor)
        : new WrappedList(key, list, ancestor);
  }

  /**

  public static <T extends @Nullable Object> List<List<T>> partition(List<T> list, int size) {
    checkNotNull(list);
    checkArgument(size > 0);
    return (list instanceof RandomAccess)
        ? new RandomAccessPartition<>(list, size)
        : new Partition<>(list, size);
  }

  private static class Partition<T extends @Nullable Object> extends AbstractList<List<T>> {
    final List<T> list;
    final int size;

     * @param exclusive whether to acquire an unshared connection
     * @param forceSigning whether to enforce SMB signing
     * @return a connected transport
     * @throws UnknownHostException if the host cannot be resolved
     * @throws IOException if an I/O error occurs
     */
    SmbTransport getSmbTransport(CIFSContext tf, String name, int port, boolean exclusive, boolean forceSigning)

            request.addServer(server);
        }

        //  <proxies>
        //    <proxy>
        //      <active>true</active>
        //      <protocol>http</protocol>
        //      <host>proxy.somewhere.com</host>
        //      <port>8080</port>
        //      <username>proxyuser</username>
        //      <password>somepassword</password>
        //      <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>

To achieve this, the `:80`-backend must have a list of "allowed origins".

In this case, the list would have to include `http://localhost:8080` for the `:8080`-frontend to work correctly.

## Wildcards { #wildcards }

It's also possible to declare the list as `"*"` (a "wildcard") to say that all are allowed.

import java.net.InetAddress
import okhttp3.Dns

/**
 * A network that always resolves two IP addresses per host. Use this when testing route selection
 * fallbacks to guarantee that a fallback address is available.
 */
class DoubleInetAddressDns : Dns {
  override fun lookup(hostname: String): List<InetAddress> {
    val addresses = Dns.SYSTEM.lookup(hostname)
    return listOf(addresses[0], addresses[0])
  }

Following is an example lambda handler.
```py
from flask import Flask, request, abort, make_response
import requests

app = Flask(__name__)
@app.route('/', methods=['POST'])
def get_webhook():
	if request.method == 'POST':
		# obtain the request event from the 'POST' call
		event = request.json

		object_context = event["getObjectContext"]

		# Get the presigned URL to fetch the requested
		# original object from MinIO

          <type>String</type>
          <description>What the last version added to the directory is, including both releases and snapshots ("groupId/artifactId" directory only)</description>
        </field>
        <field>
          <name>release</name>
          <version>1.0.0+</version>
          <type>String</type>

  /**
   * Don't call through to the proxy selector if we don't have a host name.
   * https://github.com/square/okhttp/issues/5770
   */
  @Test fun proxySelectorNotCalledForNullHost() {
    // The string '>' is okay in a hostname in HttpUrl, which does very light hostname validation.
    // It is not okay in URI, and so it's stripped and we get a URI with a null host.
    val bogusHostname = ">"
    val address =

        writeShort(0) // additional

        val nameBuf = Buffer()
        val labels = host.split('.').dropLastWhile { it.isEmpty() }
        for (label in labels) {
          val utf8ByteCount = label.utf8Size()
          require(utf8ByteCount == label.length.toLong()) { "non-ascii hostname: $host" }
          nameBuf.writeByte(utf8ByteCount.toInt())
          nameBuf.writeUtf8(label)
        }