*
   * @param reader input source
   * @param charset character set used for encoding chars to bytes
   * @param bufferSize size of internal input and output buffers
   * @throws IllegalArgumentException if bufferSize is non-positive
   */
  ReaderInputStream(Reader reader, Charset charset, int bufferSize) {
    this(
        reader,
        charset
            .newEncoder()

Un "middleware" es una función que trabaja con cada **request** antes de que sea procesada por cualquier *path operation* específica. Y también con cada **response** antes de devolverla.

* Toma cada **request** que llega a tu aplicación.
* Puede entonces hacer algo a esa **request** o ejecutar cualquier código necesario.
* Luego pasa la **request** para que sea procesada por el resto de la aplicación (por alguna *path operation*).

        request.addr = addr != null ? addr : getWINSAddress();
        request.isBroadcast = request.addr == null || isBroadcastAddress(request.addr);

        if (request.isBroadcast) {
            if (request.addr == null) {
                request.addr = this.baddr;
            }
            n = config.getNetbiosRetryCount();
        } else {
            n = 1;
        }

        do {

    }

    /**
     * Wraps the reader with a {@link BufferedReader} if necessary.
     *
     * @param reader the reader
     * @return the wrapped reader
     */
    protected static Reader wrap(final Reader reader) {
        if (reader instanceof BufferedReader) {
            return reader;
        }
        if (reader instanceof StringReader) {
            return reader;
        }

   */
  open fun requestHeadersEnd(
    call: Call,
    request: Request,
  ) {
  }

  /**
   * Invoked just prior to sending a request body.  Will only be invoked for request allowing and
   * having a request body to send.
   *
   * The connection is implicit, and will generally relate to the last [connectionAcquired] event.
   *

     * The custom servlet path for this web API request.
     */
    protected String servletPath;

    /**
     * Constructs a WebApiRequest with the specified request and servlet path.
     *
     * @param request The original HTTP servlet request
     * @param servletPath The custom servlet path for this web API request
     */
    public WebApiRequest(final HttpServletRequest request, final String servletPath) {
        super(request);

pkg mime, type WordDecoder struct
pkg mime, type WordDecoder struct, CharsetReader func(string, io.Reader) (io.Reader, error)
pkg mime, type WordEncoder uint8
pkg mime/quotedprintable, func NewReader(io.Reader) *Reader
pkg mime/quotedprintable, func NewWriter(io.Writer) *Writer
pkg mime/quotedprintable, method (*Reader) Read([]uint8) (int, error)
pkg mime/quotedprintable, method (*Writer) Close() error

			t.Fatal(err)
		}
		_, err = globalIAMSys.PolicyDBSet(ctx, accessKey, testKMSPolicyName, regUser, false)
		if err != nil {
			t.Fatal(err)
		}
	} else {
		err = globalIAMSys.DeletePolicy(ctx, testKMSPolicyName, false)
		if err != nil {
			t.Fatal(err)
		}
		_, err = globalIAMSys.PolicyDBSet(ctx, accessKey, "", regUser, false)
		if err != nil {
			t.Fatal(err)
		}
	}

	if f.Logger != nil && err != context.Canceled {
		f.Logger(err)
	}
	w.WriteHeader(http.StatusBadGateway)
}

func (f *Forwarder) getURLFromRequest(req *http.Request) *url.URL {
	// If the Request was created by Go via a real HTTP request,  RequestURI will
	// contain the original query string. If the Request was created in code, RequestURI

        for (PomArtifactTransformer transformer : transformers.values()) {
            request = transformer.remapInstallArtifacts(session, request);
        }
        return request;
    }

    @Override
    public DeployRequest remapDeployArtifacts(RepositorySystemSession session, DeployRequest request) {