* do in the other Uninterruptibles methods, it would throw immediately. Then we'd restore the
     * interrupt and return again, and the user would call us again, creating a busy wait.
     *
     * Thus, we need to clear the interrupt eagerly in case it's an interrupt from a previous call
     * to awaitUninterruptibly in the user code's Condition loop.
     */
    boolean wasAlreadyInterrupted = Thread.interrupted();

     */
    public final void addFlags(final int flag) {
        this.flags |= flag;
    }

    /**
     * Clears the specified flags from this message.
     *
     * @param flag the flags to clear
     */
    public final void clearFlags(final int flag) {
        this.flags &= ~flag;
    }

    /**
     * @return the mid
     */
    @Override
    public final long getMid() {

		// This is necessary as most compression formats have non-zero lengths
		// even when compressing an empty string.
		fh.Method = Store
		fh.Flags &^= 0x8 // we will not write a data descriptor

		// Explicitly clear sizes as they have no meaning for directories.
		fh.CompressedSize = 0
		fh.CompressedSize64 = 0
		fh.UncompressedSize = 0
		fh.UncompressedSize64 = 0

		ow = dirWriter{}
	} else {

				t.Errorf("off %d, size %d = %v, %v (%q); want %q", off, size, n, err, got, want)
			}
		}
	}

}

type zeros struct{}

func (zeros) Read(p []byte) (int, error) {
	clear(p)
	return len(p), nil

labels.index_form_search_btn=Search
labels.index_osdd_title=Search
labels.index_form_option_btn=Options
labels.index_help=Help
labels.search_options=Search Options
labels.search_options_close=Close
labels.search_options_clear=Clear
labels.search_cache_msg=This is a cache of {0}. It is a snapshot of the page as it appeared on {1}.
labels.search_unknown=Unknown
labels.footer_back_to_top=Back to Top
labels.header_brand_name=Fess

            int len;
            int amount = 0;
            while ((len = ChannelUtil.read(channel, buffer, amount)) != -1) {
                out.write(buf, 0, len);
                buffer.clear();
                amount += len;
            }
            out.flush();
            return amount;
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }

		if doneCh == nil {
			return
		}

		// Indicate we are ready to write.
		doneCh <- err

		// Wait for channel to be closed so we don't race on writes.
		<-doneCh

		// Clear so we can be called multiple times without crashing.
		doneCh = nil
	}, &closeNotifier{rc: r.Body, done: bodyDoneCh}
}

// keepHTTPResponseAlive can be used to avoid timeouts with long storage

Abra seu navegador em [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).

Você verá a resposta JSON como:

```JSON
{"item_id": 5, "q": "somequery"}
```

Você acabou de criar uma API que:

* Recebe requisições HTTP nos _paths_ `/` e `/items/{item_id}`.
* Ambos _paths_ fazem operações `GET` (também conhecido como _métodos_ HTTP).

Mas ele ainda faz parte da mesma aplicação/web API **FastAPI** (faz parte do mesmo "pacote Python").

Você pode criar as *operações de rota* para esse módulo usando o `APIRouter`.

### Importe `APIRouter` { #import-apirouter }

Você o importa e cria uma "instância" da mesma maneira que faria com a classe `FastAPI`:

      shutdown(connectionCode)
    }

    var streamsToClose: Array<Http2Stream>? = null
    withLock {
      if (streams.isNotEmpty()) {
        streamsToClose = streams.values.toTypedArray()
        streams.clear()
      }
    }

    streamsToClose?.forEach { stream ->
      ignoreIoExceptions {
        stream.close(streamCode, cause)
      }
    }