SYMBOL INDEX (4388 symbols across 315 files)

FILE: codegen/src/main.rs
  function main (line 12) | fn main() {
  function codegen (line 87) | fn codegen(
  function write_fds (line 134) | fn write_fds(fds: &FileDescriptorSet, path: &Path) {
  function comment_out (line 179) | fn comment_out(s: &str) -> String {

FILE: examples/build.rs
  function main (line 3) | fn main() {
  function build_json_codec_service (line 51) | fn build_json_codec_service() {

FILE: examples/src/authentication/client.rs
  function main (line 9) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/authentication/server.rs
  type EchoResult (line 8) | type EchoResult<T> = Result<Response<T>, Status>;
  type EchoServer (line 11) | pub struct EchoServer {}
    method unary_echo (line 15) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResul...
  function main (line 22) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function check_auth (line 33) | fn check_auth(req: Request<()>) -> Result<Request<()>, Status> {

FILE: examples/src/autoreload/server.rs
  type MyGreeter (line 11) | pub struct MyGreeter {}
  method say_hello (line 15) | async fn say_hello(
  function main (line 29) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/blocking/client.rs
  type StdError (line 9) | type StdError = Box<dyn std::error::Error + Send + Sync + 'static>;
  type Result (line 10) | type Result<T, E = StdError> = ::std::result::Result<T, E>;
  type BlockingClient (line 16) | struct BlockingClient {
    method connect (line 22) | pub fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
    method say_hello (line 33) | pub fn say_hello(
  function main (line 41) | fn main() -> Result<()> {

FILE: examples/src/blocking/server.rs
  type MyGreeter (line 13) | pub struct MyGreeter {}
  method say_hello (line 17) | async fn say_hello(
  function main (line 31) | fn main() {

FILE: examples/src/cancellation/client.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/cancellation/server.rs
  type MyGreeter (line 18) | pub struct MyGreeter {}
  method say_hello (line 22) | async fn say_hello(
  function with_cancellation_handler (line 49) | async fn with_cancellation_handler<FRequest, FCancellation>(
  function main (line 73) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/codec_buffers/client.rs
  function main (line 18) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/codec_buffers/common.rs
  type SmallBufferCodec (line 19) | pub struct SmallBufferCodec<T, U>(PhantomData<(T, U)>);
  type Encode (line 26) | type Encode = T;
  type Decode (line 27) | type Decode = U;
  type Encoder (line 29) | type Encoder = <ProstCodec<T, U> as Codec>::Encoder;
  type Decoder (line 30) | type Decoder = <ProstCodec<T, U> as Codec>::Decoder;
  method encoder (line 32) | fn encoder(&mut self) -> Self::Encoder {
  method decoder (line 39) | fn decoder(&mut self) -> Self::Decoder {

FILE: examples/src/codec_buffers/server.rs
  type MyGreeter (line 21) | pub struct MyGreeter {}
  method say_hello (line 25) | async fn say_hello(
  function main (line 39) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/compression/client.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/compression/server.rs
  type MyGreeter (line 12) | pub struct MyGreeter {}
  method say_hello (line 16) | async fn say_hello(
  function main (line 30) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/dynamic/server.rs
  type EchoResult (line 18) | type EchoResult<T> = Result<Response<T>, Status>;
  type MyEcho (line 21) | pub struct MyEcho {}
  method unary_echo (line 25) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResult<...
  function init_echo (line 34) | fn init_echo(args: &[String], builder: &mut RoutesBuilder) {
  type MyGreeter (line 44) | pub struct MyGreeter {}
  method say_hello (line 48) | async fn say_hello(
  function init_greeter (line 61) | fn init_greeter(args: &[String], builder: &mut RoutesBuilder) {
  function main (line 72) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/dynamic_load_balance/client.rs
  function main (line 16) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/dynamic_load_balance/server.rs
  type EchoResult (line 11) | type EchoResult<T> = Result<Response<T>, Status>;
  type EchoServer (line 14) | pub struct EchoServer {
    method unary_echo (line 20) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResul...
  function main (line 28) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/gcp/client.rs
  constant ENDPOINT (line 12) | const ENDPOINT: &str = "https://pubsub.googleapis.com";
  function main (line 15) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/grpc-web/client.rs
  function main (line 10) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/grpc-web/server.rs
  type MyGreeter (line 11) | pub struct MyGreeter {}
  method say_hello (line 15) | async fn say_hello(
  function main (line 29) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/h2c/client.rs
  function main (line 12) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  type H2cChannel (line 45) | pub struct H2cChannel {
    type Response (line 50) | type Response = http::Response<Incoming>;
    type Error (line 51) | type Error = hyper::Error;
    type Future (line 52) | type Future =
    method poll_ready (line 55) | fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self:...
    method call (line 59) | fn call(&mut self, request: http::Request<Body>) -> Self::Future {

FILE: examples/src/h2c/server.rs
  type MyGreeter (line 17) | pub struct MyGreeter {}
  method say_hello (line 21) | async fn say_hello(
  function main (line 35) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  type H2c (line 76) | pub struct H2c<S> {
  type BoxError (line 80) | type BoxError = Box<dyn std::error::Error + Send + Sync>;
  type Response (line 88) | type Response = hyper::Response<Body>;
  type Error (line 89) | type Error = hyper::Error;
  type Future (line 90) | type Future =
  function poll_ready (line 93) | fn poll_ready(
  function call (line 100) | fn call(&mut self, req: hyper::Request<Incoming>) -> Self::Future {

FILE: examples/src/health/server.rs
  type MyGreeter (line 13) | pub struct MyGreeter {}
  method say_hello (line 17) | async fn say_hello(
  function twiddle_service_status (line 32) | async fn twiddle_service_status(reporter: HealthReporter) {
  function main (line 47) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/helloworld/client.rs
  function main (line 9) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/helloworld/server.rs
  type MyGreeter (line 11) | pub struct MyGreeter {}
  method say_hello (line 15) | async fn say_hello(
  function main (line 29) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/interceptor/client.rs
  function main (line 15) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function intercept (line 36) | fn intercept(req: Request<()>) -> Result<Request<()>, Status> {
  type MyInterceptor (line 43) | struct MyInterceptor;
  method call (line 46) | fn call(&mut self, request: tonic::Request<()>) -> Result<tonic::Request...
  function using_named_interceptor (line 52) | async fn using_named_interceptor() -> Result<(), Box<dyn std::error::Err...
  function using_function_pointer_interceptro (line 66) | async fn using_function_pointer_interceptro() -> Result<(), Box<dyn std:...

FILE: examples/src/interceptor/server.rs
  type MyGreeter (line 11) | pub struct MyGreeter {}
  method say_hello (line 15) | async fn say_hello(
  function main (line 30) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function intercept (line 49) | fn intercept(mut req: Request<()>) -> Result<Request<()>, Status> {
  type MyExtension (line 61) | struct MyExtension {

FILE: examples/src/json-codec/client.rs
  function main (line 16) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/json-codec/common.rs
  type HelloRequest (line 14) | pub struct HelloRequest {
  type HelloResponse (line 19) | pub struct HelloResponse {
  type JsonEncoder (line 24) | pub struct JsonEncoder<T>(PhantomData<T>);
  type Item (line 27) | type Item = T;
  type Error (line 28) | type Error = Status;
  method encode (line 30) | fn encode(&mut self, item: Self::Item, buf: &mut EncodeBuf<'_>) -> Resul...
  type JsonDecoder (line 36) | pub struct JsonDecoder<U>(PhantomData<U>);
  type Item (line 39) | type Item = U;
  type Error (line 40) | type Error = Status;
  method decode (line 42) | fn decode(&mut self, buf: &mut DecodeBuf<'_>) -> Result<Option<Self::Ite...
  type JsonCodec (line 55) | pub struct JsonCodec<T, U>(PhantomData<(T, U)>);
  method default (line 58) | fn default() -> Self {
  type Encode (line 68) | type Encode = T;
  type Decode (line 69) | type Decode = U;
  type Encoder (line 70) | type Encoder = JsonEncoder<T>;
  type Decoder (line 71) | type Decoder = JsonDecoder<U>;
  method encoder (line 73) | fn encoder(&mut self) -> Self::Encoder {
  method decoder (line 77) | fn decoder(&mut self) -> Self::Decoder {

FILE: examples/src/json-codec/server.rs
  type MyGreeter (line 18) | pub struct MyGreeter {}
  method say_hello (line 22) | async fn say_hello(
  function main (line 36) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/load_balance/client.rs
  function main (line 9) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/load_balance/server.rs
  type EchoResult (line 11) | type EchoResult<T> = Result<Response<T>, Status>;
  type EchoServer (line 14) | pub struct EchoServer {
    method unary_echo (line 20) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResul...
  function main (line 28) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/mock/mock.rs
  function main (line 19) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  type MyGreeter (line 62) | pub struct MyGreeter {}
  method say_hello (line 66) | async fn say_hello(

FILE: examples/src/multiplex/client.rs
  function main (line 14) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/multiplex/server.rs
  function main (line 22) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  type MyGreeter (line 38) | pub struct MyGreeter {}
  method say_hello (line 42) | async fn say_hello(
  type MyEcho (line 54) | pub struct MyEcho {}
  method unary_echo (line 58) | async fn unary_echo(

FILE: examples/src/reflection/server.rs
  constant FILE_DESCRIPTOR_SET (line 7) | pub(crate) const FILE_DESCRIPTOR_SET: &[u8] =
  type MyGreeter (line 12) | pub struct MyGreeter {}
    method say_hello (line 16) | async fn say_hello(
  function main (line 30) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/richer-error/client.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/richer-error/client_vec.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/richer-error/server.rs
  type MyGreeter (line 12) | pub struct MyGreeter {}
  method say_hello (line 16) | async fn say_hello(
  function main (line 59) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/richer-error/server_vec.rs
  type MyGreeter (line 12) | pub struct MyGreeter {}
  method say_hello (line 16) | async fn say_hello(
  function main (line 59) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/routeguide/client.rs
  function print_features (line 17) | async fn print_features(client: &mut RouteGuideClient<Channel>) -> Resul...
  function run_record_route (line 41) | async fn run_record_route(client: &mut RouteGuideClient<Channel>) -> Res...
  function run_route_chat (line 61) | async fn run_route_chat(client: &mut RouteGuideClient<Channel>) -> Resul...
  function main (line 93) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function random_point (line 117) | fn random_point(rng: &mut ThreadRng) -> Point {

FILE: examples/src/routeguide/data.rs
  type Feature (line 5) | struct Feature {
  type Location (line 11) | struct Location {
  function load (line 17) | pub fn load() -> Vec<crate::routeguide::Feature> {

FILE: examples/src/routeguide/server.rs
  type RouteGuideService (line 21) | pub struct RouteGuideService {
  method get_feature (line 27) | async fn get_feature(&self, request: Request<Point>) -> Result<Response<...
  type ListFeaturesStream (line 39) | type ListFeaturesStream = ReceiverStream<Result<Feature, Status>>;
  method list_features (line 41) | async fn list_features(
  method record_route (line 64) | async fn record_route(
  type RouteChatStream (line 104) | type RouteChatStream = Pin<Box<dyn Stream<Item = Result<RouteNote, Statu...
  method route_chat (line 106) | async fn route_chat(
  function main (line 135) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function in_range (line 151) | fn in_range(point: &Point, rect: &Rectangle) -> bool {
  function calc_distance (line 170) | fn calc_distance(p1: &Point, p2: &Point) -> i32 {

FILE: examples/src/streaming/client.rs
  function echo_requests_iter (line 11) | fn echo_requests_iter() -> impl Stream<Item = EchoRequest> {
  function streaming_echo (line 17) | async fn streaming_echo(client: &mut EchoClient<Channel>, num: usize) {
  function bidirectional_streaming_echo (line 34) | async fn bidirectional_streaming_echo(client: &mut EchoClient<Channel>, ...
  function bidirectional_streaming_echo_throttle (line 50) | async fn bidirectional_streaming_echo_throttle(client: &mut EchoClient<C...
  function main (line 67) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/streaming/server.rs
  type EchoResult (line 12) | type EchoResult<T> = Result<Response<T>, Status>;
  type ResponseStream (line 13) | type ResponseStream = Pin<Box<dyn Stream<Item = Result<EchoResponse, Sta...
  function match_for_io_error (line 15) | fn match_for_io_error(err_status: &Status) -> Option<&std::io::Error> {
  type EchoServer (line 36) | pub struct EchoServer {}
    method unary_echo (line 40) | async fn unary_echo(&self, _: Request<EchoRequest>) -> EchoResult<Echo...
    type ServerStreamingEchoStream (line 44) | type ServerStreamingEchoStream = ResponseStream;
    method server_streaming_echo (line 46) | async fn server_streaming_echo(
    method client_streaming_echo (line 83) | async fn client_streaming_echo(
    type BidirectionalStreamingEchoStream (line 90) | type BidirectionalStreamingEchoStream = ResponseStream;
    method bidirectional_streaming_echo (line 92) | async fn bidirectional_streaming_echo(
  function main (line 142) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tls/client.rs
  function main (line 9) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tls/server.rs
  type EchoResult (line 14) | type EchoResult<T> = Result<Response<T>, Status>;
  type EchoServer (line 17) | pub struct EchoServer {}
    method unary_echo (line 21) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResul...
  function main (line 38) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tls_client_auth/client.rs
  function main (line 9) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tls_client_auth/server.rs
  type EchoResult (line 9) | type EchoResult<T> = Result<Response<T>, Status>;
  type EchoServer (line 12) | pub struct EchoServer {}
    method unary_echo (line 16) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResul...
  function main (line 29) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tls_rustls/client.rs
  function main (line 17) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tls_rustls/server.rs
  function main (line 25) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  type ConnInfo (line 96) | struct ConnInfo {
  type EchoResult (line 101) | type EchoResult<T> = Result<Response<T>, Status>;
  type EchoServer (line 104) | pub struct EchoServer {}
    method unary_echo (line 108) | async fn unary_echo(&self, request: Request<EchoRequest>) -> EchoResul...

FILE: examples/src/tower/client.rs
  function main (line 13) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function intercept (line 36) | fn intercept(req: Request<()>) -> Result<Request<()>, Status> {
  type AuthSvc (line 50) | pub struct AuthSvc {
    method new (line 55) | pub fn new(inner: Channel) -> Self {
    type Response (line 61) | type Response = Response<Body>;
    type Error (line 62) | type Error = Box<dyn std::error::Error + Send + Sync>;
    type Future (line 64) | type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self:...
    method poll_ready (line 66) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 70) | fn call(&mut self, req: Request<Body>) -> Self::Future {

FILE: examples/src/tower/server.rs
  type MyGreeter (line 16) | pub struct MyGreeter {}
  method say_hello (line 20) | async fn say_hello(
  function main (line 34) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function intercept (line 61) | fn intercept(req: Request<()>) -> Result<Request<()>, Status> {
  type MyMiddlewareLayer (line 66) | struct MyMiddlewareLayer {}
    type Service (line 69) | type Service = MyMiddleware<S>;
    method layer (line 71) | fn layer(&self, service: S) -> Self::Service {
  type MyMiddleware (line 77) | struct MyMiddleware<S> {
  type BoxFuture (line 81) | type BoxFuture<'a, T> = Pin<Box<dyn std::future::Future<Output = T> + Se...
  type Response (line 89) | type Response = S::Response;
  type Error (line 90) | type Error = S::Error;
  type Future (line 91) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
  function poll_ready (line 93) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 97) | fn call(&mut self, req: http::Request<ReqBody>) -> Self::Future {

FILE: examples/src/tracing/client.rs
  function main (line 8) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function say_hi (line 19) | async fn say_hi(name: String) -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/tracing/server.rs
  type MyGreeter (line 13) | pub struct MyGreeter {}
  method say_hello (line 18) | async fn say_hello(
  function main (line 35) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/src/uds/client_standard.rs
  function main (line 11) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function main (line 32) | fn main() {

FILE: examples/src/uds/client_with_connector.rs
  function main (line 16) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function main (line 44) | fn main() {

FILE: examples/src/uds/server.rs
  type MyGreeter (line 22) | pub struct MyGreeter {}
  method say_hello (line 26) | async fn say_hello(
  function main (line 45) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function main (line 64) | fn main() {

FILE: grpc/examples/inmemory.rs
  type Handler (line 44) | struct Handler {
  type MyReqMessage (line 49) | struct MyReqMessage(String);
  method encode (line 52) | fn encode(&self) -> Result<Box<dyn Buf + Send + Sync>, String> {
  method decode (line 57) | fn decode(&mut self, data: &mut dyn Buf) -> Result<(), String> {
  type MyResMessage (line 65) | struct MyResMessage(String);
  method encode (line 67) | fn encode(&self) -> Result<Box<dyn Buf + Send + Sync>, String> {
  method decode (line 72) | fn decode(&mut self, data: &mut dyn Buf) -> Result<(), String> {
  method handle (line 80) | async fn handle(
  function main (line 123) | async fn main() {
  function run_rpc (line 171) | async fn run_rpc(chan: &Channel) -> String {

FILE: grpc/src/attributes/linked_list.rs
  type Node (line 32) | struct Node<K, V> {
  type LinkedList (line 52) | pub(crate) struct LinkedList<K, V> {
  method clone (line 57) | fn clone(&self) -> Self {
  method default (line 65) | fn default() -> Self {
  function new (line 72) | pub(crate) fn new() -> Self {
  function add (line 80) | pub(crate) fn add(&self, key: K, value: V) -> Self {
  function get (line 106) | pub(crate) fn get(&self, key: &K) -> Option<&V> {
  function iter (line 124) | pub(crate) fn iter(&self) -> Iter<'_, K, V> {
  type Iter (line 133) | pub struct Iter<'a, K, V> {
  type Item (line 139) | type Item = (&'a K, &'a V);
  method next (line 141) | fn next(&mut self) -> Option<Self::Item> {
  function test_add_and_iter (line 157) | fn test_add_and_iter() {
  function test_persistence (line 164) | fn test_persistence() {
  function test_shadowing (line 178) | fn test_shadowing() {
  function test_send_sync (line 186) | fn test_send_sync() {

FILE: grpc/src/attributes/mod.rs
  type AttributeTrait (line 37) | trait AttributeTrait: Any + Send + Sync + Debug {
    method any_ref (line 38) | fn any_ref(&self) -> &dyn Any;
    method dyn_eq (line 39) | fn dyn_eq(&self, other: &dyn AttributeTrait) -> bool;
    method dyn_cmp (line 40) | fn dyn_cmp(&self, other: &dyn AttributeTrait) -> Ordering;
    method any_ref (line 44) | fn any_ref(&self) -> &dyn Any {
    method dyn_eq (line 48) | fn dyn_eq(&self, other: &dyn AttributeTrait) -> bool {
    method dyn_cmp (line 56) | fn dyn_cmp(&self, other: &dyn AttributeTrait) -> Ordering {
  type AttributeValue (line 68) | struct AttributeValue {
  method eq (line 73) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 81) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 87) | fn cmp(&self, other: &Self) -> Ordering {
  type Attributes (line 107) | pub struct Attributes {
    method new (line 112) | pub fn new() -> Self {
    method add (line 119) | pub fn add<T: Send + Sync + Eq + Ord + Debug + 'static>(&self, value: ...
    method get (line 132) | pub fn get<T: 'static>(&self) -> Option<&T> {
  method eq (line 141) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 156) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 162) | fn cmp(&self, other: &Self) -> Ordering {
  function test_eq (line 176) | fn test_eq() {
  function test_attributes (line 189) | fn test_attributes() {
  function test_persistence (line 200) | fn test_persistence() {
  function test_overwrite (line 212) | fn test_overwrite() {
  type Priority (line 221) | struct Priority {
  type Config (line 227) | struct Config {
  function test_custom_structs (line 233) | fn test_custom_structs() {

FILE: grpc/src/byte_str.rs
  type ByteStr (line 32) | pub struct ByteStr {
    method from (line 51) | fn from(src: String) -> ByteStr {
  type Target (line 38) | type Target = str;
  method deref (line 41) | fn deref(&self) -> &str {

FILE: grpc/src/client/channel.rs
  type ChannelOptions (line 86) | pub struct ChannelOptions {
    method transport_options (line 137) | pub fn transport_options(self, transport_options: TODO) -> Self {
    method override_authority (line 140) | pub fn override_authority(self, authority: String) -> Self {
  method default (line 120) | fn default() -> Self {
  type Channel (line 152) | pub struct Channel {
    method new (line 162) | pub fn new<C>(target: &str, credentials: C, options: ChannelOptions) -...
    method state (line 183) | pub fn state(&mut self, connect: bool) -> ConnectivityState {
    method wait_for_state_change (line 189) | pub async fn wait_for_state_change(
  type SendStream (line 199) | type SendStream = Box<dyn DynSendStream>;
  type RecvStream (line 200) | type RecvStream = Box<dyn DynRecvStream>;
  method invoke (line 202) | async fn invoke(
  type PersistentChannel (line 216) | struct PersistentChannel {
    method new (line 226) | fn new(
    method state (line 242) | fn state(&self, connect: bool) -> ConnectivityState {
    method get_active_channel (line 263) | fn get_active_channel(&self) -> Arc<ActiveChannel> {
  type ActiveChannel (line 278) | struct ActiveChannel {
    method new (line 286) | fn new(target: Url, options: &ChannelOptions, runtime: GrpcRuntime) ->...
  type SendStream (line 339) | type SendStream = Box<dyn DynSendStream>;
  type RecvStream (line 340) | type RecvStream = Box<dyn DynRecvStream>;
  method invoke (line 342) | async fn invoke(
  method drop (line 384) | fn drop(&mut self) {
  type ResolverWorkScheduler (line 389) | struct ResolverWorkScheduler {
    method schedule_work (line 396) | fn schedule_work(&self) {
  type WorkQueueTx (line 393) | pub(super) type WorkQueueTx = mpsc::UnboundedSender<WorkQueueItem>;
  type InternalChannelController (line 401) | pub(crate) struct InternalChannelController {
    method new (line 414) | fn new(
    method new_esc_for_isc (line 444) | fn new_esc_for_isc(&self, isc: Arc<InternalSubchannel>) -> Arc<dyn Sub...
    method update (line 454) | fn update(&mut self, update: ResolverUpdate) -> Result<(), String> {
    method parse_service_config (line 460) | fn parse_service_config(&self, config: &str) -> Result<ServiceConfig, ...
    method new_subchannel (line 466) | fn new_subchannel(&mut self, address: &Address) -> Arc<dyn Subchannel> {
    method update_picker (line 496) | fn update_picker(&mut self, update: LbState) {
    method request_resolution (line 505) | fn request_resolution(&mut self) {
  type LbController (line 512) | pub(super) struct LbController {
    method new (line 547) | fn new(work_scheduler: Arc<LbWorkScheduler>, runtime: GrpcRuntime) -> ...
    method handle_resolver_update (line 556) | fn handle_resolver_update(
    method subchannel_update (line 601) | pub(super) fn subchannel_update(
  type LbWorkScheduler (line 520) | struct LbWorkScheduler {
  method schedule_work (line 526) | fn schedule_work(&self) {
  type WorkQueueItem (line 615) | pub(super) enum WorkQueueItem {
  type TODO (line 622) | pub struct TODO;
  type Watcher (line 627) | pub(crate) struct Watcher<T> {
  function new (line 633) | fn new() -> Self {
  function iter (line 638) | pub(crate) fn iter(&self) -> WatcherIter<T> {
  function cur (line 644) | pub(crate) fn cur(&self) -> Option<T> {
  function update (line 651) | fn update(&self, item: T) {
  type WatcherIter (line 656) | pub(crate) struct WatcherIter<T> {
  function next (line 665) | pub(crate) async fn next(&mut self) -> Option<T> {

FILE: grpc/src/client/interceptor.rs
  type Intercept (line 37) | pub trait Intercept<I>: Sync {
    method intercept (line 44) | async fn intercept(
  type InterceptOnce (line 54) | pub trait InterceptOnce<I>: Sync {
    method intercept_once (line 61) | async fn intercept_once(
  type IntoOnce (line 73) | pub struct IntoOnce<T>(pub T);
  type SendStream (line 82) | type SendStream = SS;
    method send (line 579) | async fn send(&mut self, item: &dyn SendMessage, options: SendOptions)...
    method send (line 648) | async fn send(&mut self, msg: &dyn SendMessage, options: SendOptions) ...
    method send (line 892) | async fn send(&mut self, _item: &dyn SendMessage, _options: SendOption...
  type RecvStream (line 83) | type RecvStream = RS;
    method next (line 589) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseS...
    method next (line 704) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseS...
    method next (line 897) | async fn next(
  function intercept_once (line 85) | async fn intercept_once(
  type Intercepted (line 99) | pub struct Intercepted<Inv, Int> {
  function new (line 105) | pub fn new(invoke: Inv, intercept: Int) -> Self {
  type SendStream (line 115) | type SendStream = Int::SendStream;
  type RecvStream (line 116) | type RecvStream = Int::RecvStream;
  method invoke_once (line 118) | async fn invoke_once(
  type SendStream (line 136) | type SendStream = SS;
  type RecvStream (line 137) | type RecvStream = RS;
  method invoke (line 139) | async fn invoke(
  type InterceptedOnce (line 151) | pub struct InterceptedOnce<Inv, Int> {
  function new (line 157) | pub fn new(invoke: Inv, intercept: Int) -> Self {
  type SendStream (line 169) | type SendStream = SS;
  type RecvStream (line 170) | type RecvStream = RS;
  method invoke_once (line 172) | async fn invoke_once(
  type InvokeExt (line 186) | pub trait InvokeExt: Invoke + Sized {
    method with_interceptor (line 187) | fn with_interceptor<Int>(self, interceptor: Int) -> Intercepted<Self, ...
    method with_once_interceptor (line 194) | fn with_once_interceptor<Int>(self, interceptor: Int) -> InterceptedOn...
  type InvokeOnceExt (line 205) | pub trait InvokeOnceExt: InvokeOnce + Sized {
    method with_interceptor (line 206) | fn with_interceptor<Int>(self, interceptor: Int) -> Intercepted<Self, ...
    method with_once_interceptor (line 213) | fn with_once_interceptor<Int>(self, interceptor: Int) -> Intercepted<S...
  type Reusable (line 273) | struct Reusable;
    type SendStream (line 275) | type SendStream = NopStream;
    type RecvStream (line 276) | type RecvStream = I::RecvStream;
    method intercept (line 278) | async fn intercept(
  type ReusableFanOut (line 290) | struct ReusableFanOut;
    type SendStream (line 292) | type SendStream = RetrySendStream<I::SendStream>;
    type RecvStream (line 293) | type RecvStream = RetryRecvStream<I>;
    method intercept (line 295) | async fn intercept(
  type Oneshot (line 304) | struct Oneshot;
    type SendStream (line 306) | type SendStream = I::SendStream;
    type RecvStream (line 307) | type RecvStream = NopStream;
    method intercept_once (line 309) | async fn intercept_once(
  type OneshotFanOut (line 320) | struct OneshotFanOut;
    type SendStream (line 322) | type SendStream = I::SendStream;
    type RecvStream (line 323) | type RecvStream = I::RecvStream;
    method intercept_once (line 325) | async fn intercept_once(
  function test_interceptor_creation (line 338) | async fn test_interceptor_creation() {
  function test_retry_interceptor_succeeds (line 395) | async fn test_retry_interceptor_succeeds() {
  function test_retry_interceptor_fails (line 440) | async fn test_retry_interceptor_fails() {
  function test_retry_interceptor_commit_on_headers (line 492) | async fn test_retry_interceptor_commit_on_headers() {
  type MockInvoker (line 526) | struct MockInvoker {
    method new (line 537) | fn new() -> (Self, MockInvokerController) {
  type MockInvokerController (line 532) | struct MockInvokerController {
    method recv_req (line 553) | async fn recv_req(&mut self) -> (Bytes, SendOptions) {
    method send_resp (line 556) | async fn send_resp(&mut self, item: ClientResponseStreamItem) {
  type SendStream (line 562) | type SendStream = MockSendStream;
  type RecvStream (line 563) | type RecvStream = MockRecvStream;
  method invoke (line 565) | async fn invoke(
  type MockSendStream (line 577) | struct MockSendStream(mpsc::Sender<(Bytes, SendOptions)>);
  type MockRecvStream (line 587) | struct MockRecvStream(broadcast::Receiver<ClientResponseStreamItem>);
  function start_retry_streams (line 594) | async fn start_retry_streams<I: Invoke + Clone>(
  type Cache (line 621) | struct Cache<S> {
  function new (line 632) | fn new() -> Arc<Mutex<Self>> {
  type RetrySendStream (line 642) | struct RetrySendStream<S> {
  type RetryRecvStream (line 680) | pub struct RetryRecvStream<I: Invoke> {
  function should_retry (line 693) | fn should_retry(i: &ClientResponseStreamItem) -> bool {
  constant MAX_ATTEMPTS (line 701) | const MAX_ATTEMPTS: usize = 3;
  function replay_sends (line 754) | async fn replay_sends<S, F>(
  type RecvStreamState (line 796) | enum RecvStreamState<F> {
  function race_with (line 806) | async fn race_with<F2: Future + Unpin>(&mut self, fut: &mut F2) -> Optio...
  function resolve (line 822) | async fn resolve(self) -> ClientResponseStreamItem {
  type ByteRecvMsg (line 830) | struct ByteRecvMsg {
    method new (line 834) | fn new() -> Self {
  method decode (line 839) | fn decode(&mut self, data: &mut dyn Buf) -> Result<(), String> {
  type ByteSendMsg (line 845) | struct ByteSendMsg<'a> {
  function new (line 849) | fn new(data: &'a Bytes) -> Self {
  method encode (line 854) | fn encode(&self) -> Result<Box<dyn Buf + Send + Sync>, String> {
  type NopInvoker (line 860) | struct NopInvoker;
  type SendStream (line 863) | type SendStream = NopStream;
  type RecvStream (line 864) | type RecvStream = NopStream;
  method invoke (line 866) | async fn invoke(
  type NopOnceInvoker (line 875) | struct NopOnceInvoker;
  type SendStream (line 878) | type SendStream = NopStream;
  type RecvStream (line 879) | type RecvStream = NopStream;
  method invoke_once (line 881) | async fn invoke_once(
  type NopStream (line 890) | struct NopStream;

FILE: grpc/src/client/load_balancing/child_manager.rs
  type ChildManager (line 58) | pub(crate) struct ChildManager<T: Debug> {
  type Child (line 69) | pub(crate) struct Child<T> {
  type ChildUpdate (line 78) | pub(crate) struct ChildUpdate<T> {
  function new (line 99) | pub fn new(runtime: GrpcRuntime, work_scheduler: Arc<dyn WorkScheduler>)...
  function children (line 111) | pub fn children(&self) -> impl Iterator<Item = &Child<T>> {
  function aggregate_states (line 121) | pub fn aggregate_states(&self) -> ConnectivityState {
  function resolve_child_controller (line 157) | fn resolve_child_controller(
  function child_updated (line 175) | pub fn child_updated(&mut self) -> bool {
  function retain_children (line 183) | pub fn retain_children(
  function reset_children (line 194) | fn reset_children(
  function update (line 295) | pub fn update(
  function resolver_update (line 343) | pub fn resolver_update(
  function subchannel_update (line 376) | pub fn subchannel_update(
  function work (line 396) | pub fn work(&mut self, channel_controller: &mut dyn ChannelController) {
  function exit_idle (line 408) | pub fn exit_idle(&mut self, channel_controller: &mut dyn ChannelControll...
  type WrappedController (line 418) | struct WrappedController<'a> {
  function new (line 425) | fn new(channel_controller: &'a mut dyn ChannelController) -> Self {
  method new_subchannel (line 435) | fn new_subchannel(&mut self, address: &Address) -> Arc<dyn Subchannel> {
  method update_picker (line 441) | fn update_picker(&mut self, update: LbState) {
  method request_resolution (line 445) | fn request_resolution(&mut self) {
  type ChildWorkScheduler (line 451) | struct ChildWorkScheduler {
    method invalidate (line 472) | fn invalidate(&self) {
  method schedule_work (line 458) | fn schedule_work(&self) {
  function setup (line 523) | fn setup(
  function create_n_endpoints_with_k_addresses (line 541) | fn create_n_endpoints_with_k_addresses(n: usize, k: usize) -> Vec<Endpoi...
  function send_resolver_update_to_policy (line 560) | fn send_resolver_update_to_policy(
  function move_subchannel_to_state (line 583) | fn move_subchannel_to_state(
  function verify_subchannel_creation_from_policy (line 601) | async fn verify_subchannel_creation_from_policy(
  function create_verifying_funcs_for_aggregate_tests (line 619) | fn create_verifying_funcs_for_aggregate_tests() -> StubPolicyFuncs {
  function childmanager_aggregate_state_is_ready_if_any_child_is_ready (line 650) | async fn childmanager_aggregate_state_is_ready_if_any_child_is_ready() {
  function childmanager_aggregate_state_is_connecting_if_no_child_is_ready (line 705) | async fn childmanager_aggregate_state_is_connecting_if_no_child_is_ready...
  function childmanager_aggregate_state_is_idle_if_only_idle_and_failure (line 756) | async fn childmanager_aggregate_state_is_idle_if_only_idle_and_failure() {
  function childmanager_aggregate_state_is_transient_failure_if_all_children_are (line 798) | async fn childmanager_aggregate_state_is_transient_failure_if_all_childr...
  type ScheduleWorkStubData (line 839) | struct ScheduleWorkStubData {
  function create_funcs_for_schedule_work_tests (line 843) | fn create_funcs_for_schedule_work_tests(name: &'static str) -> StubPolic...
  function childmanager_schedule_work_works (line 888) | async fn childmanager_schedule_work_works() {

FILE: grpc/src/client/load_balancing/graceful_switch.rs
  type GracefulSwitchLbConfig (line 46) | struct GracefulSwitchLbConfig {
  type GracefulSwitchPolicy (line 59) | pub(crate) struct GracefulSwitchPolicy {
    method new (line 138) | pub fn new(runtime: GrpcRuntime, work_scheduler: Arc<dyn WorkScheduler...
    method parse_config (line 151) | pub fn parse_config(
    method update_picker (line 185) | fn update_picker(&mut self, channel_controller: &mut dyn ChannelContro...
    method maybe_swap (line 199) | fn maybe_swap(&mut self, channel_controller: &mut dyn ChannelControlle...
  method resolver_update (line 66) | fn resolver_update(
  method subchannel_update (line 108) | fn subchannel_update(
  method work (line 119) | fn work(&mut self, channel_controller: &mut dyn ChannelController) {
  method exit_idle (line 124) | fn exit_idle(&mut self, channel_controller: &mut dyn ChannelController) {
  type ChildKind (line 131) | enum ChildKind {
  constant DEFAULT_TEST_SHORT_TIMEOUT (line 287) | const DEFAULT_TEST_SHORT_TIMEOUT: Duration = Duration::from_millis(10);
  type TestSubchannelList (line 289) | struct TestSubchannelList {
    method new (line 294) | fn new(addresses: &Vec<Address>, channel_controller: &mut dyn ChannelC...
    method contains (line 305) | fn contains(&self, sc: &Arc<dyn Subchannel>) -> bool {
  type TestPicker (line 311) | struct TestPicker {
    method new (line 316) | fn new(name: &'static str) -> Self {
  method pick (line 321) | fn pick(&self, _req: &RequestHeaders) -> PickResult {
  type TestState (line 336) | struct TestState {
  function create_funcs_for_gracefulswitch_tests (line 341) | fn create_funcs_for_gracefulswitch_tests(name: &'static str) -> StubPoli...
  function setup (line 404) | fn setup() -> (
  function create_endpoint_with_one_address (line 423) | fn create_endpoint_with_one_address(addr: String) -> Endpoint {
  function verify_subchannel_creation_from_policy (line 435) | async fn verify_subchannel_creation_from_policy(
  function verify_correct_picker_from_policy (line 448) | async fn verify_correct_picker_from_policy(
  function move_subchannel_to_state (line 472) | fn move_subchannel_to_state(
  function gracefulswitch_successful_first_update (line 491) | async fn gracefulswitch_successful_first_update() {
  function gracefulswitch_switching_to_resolver_update (line 543) | async fn gracefulswitch_switching_to_resolver_update() {
  function assert_channel_empty (line 623) | async fn assert_channel_empty(rx_events: &mut UnboundedReceiver<TestEven...
  function gracefulswitch_two_policies_same_type (line 635) | async fn gracefulswitch_two_policies_same_type() {
  function gracefulswitch_current_not_ready_pending_update (line 691) | async fn gracefulswitch_current_not_ready_pending_update() {
  function gracefulswitch_current_leaving_ready (line 767) | async fn gracefulswitch_current_leaving_ready() {
  function gracefulswitch_pending_leaving_connecting (line 854) | async fn gracefulswitch_pending_leaving_connecting() {
  function gracefulswitch_subchannels_removed_after_current_child_swapped (line 944) | async fn gracefulswitch_subchannels_removed_after_current_child_swapped() {

FILE: grpc/src/client/load_balancing/mod.rs
  type LbPolicyOptions (line 66) | pub(crate) struct LbPolicyOptions {
  type WorkScheduler (line 76) | pub(crate) trait WorkScheduler: Send + Sync + Debug {
    method schedule_work (line 80) | fn schedule_work(&self);
  type ParsedJsonLbConfig (line 87) | pub(crate) struct ParsedJsonLbConfig {
    method new (line 93) | pub fn new(json: &str) -> Result<Self, String> {
    method from_value (line 100) | pub(crate) fn from_value(value: serde_json::Value) -> Self {
    method convert_to (line 109) | pub fn convert_to<T: serde::de::DeserializeOwned>(
  type LbPolicyBuilder (line 124) | pub(crate) trait LbPolicyBuilder: Send + Sync + Debug {
    method build (line 132) | fn build(&self, options: LbPolicyOptions) -> Box<dyn LbPolicy>;
    method name (line 135) | fn name(&self) -> &'static str;
    method parse_config (line 141) | fn parse_config(
  type LbPolicy (line 154) | pub(crate) trait LbPolicy: Send + Debug {
    method resolver_update (line 157) | fn resolver_update(
    method subchannel_update (line 166) | fn subchannel_update(
    method work (line 175) | fn work(&mut self, channel_controller: &mut dyn ChannelController);
    method exit_idle (line 179) | fn exit_idle(&mut self, channel_controller: &mut dyn ChannelController);
  type ChannelController (line 183) | pub(crate) trait ChannelController: Send + Sync {
    method new_subchannel (line 185) | fn new_subchannel(&mut self, address: &Address) -> Arc<dyn Subchannel>;
    method update_picker (line 188) | fn update_picker(&mut self, update: LbState);
    method request_resolution (line 193) | fn request_resolution(&mut self);
  type SubchannelState (line 198) | pub(crate) struct SubchannelState {
  method default (line 208) | fn default() -> Self {
  method fmt (line 217) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Picker (line 247) | pub(crate) trait Picker: Send + Sync + Debug {
    method pick (line 254) | fn pick(&self, request: &RequestHeaders) -> PickResult;
    method pick (line 606) | fn pick(&self, _request: &RequestHeaders) -> PickResult {
    method pick (line 617) | fn pick(&self, _: &RequestHeaders) -> PickResult {
  type PickResult (line 258) | pub(crate) enum PickResult {
    method unwrap_pick (line 280) | pub fn unwrap_pick(self) -> Pick {
  method eq (line 289) | fn eq(&self, other: &Self) -> bool {
  method fmt (line 309) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type LbState (line 320) | pub(crate) struct LbState {
    method initial (line 343) | pub fn initial() -> Self {
  method eq (line 332) | fn eq(&self, other: &Self) -> bool {
  type CompletionCallback (line 352) | pub(crate) type CompletionCallback = Box<dyn Fn() + Send + Sync>;
  type Pick (line 355) | pub(crate) struct Pick {
  method fmt (line 365) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type DynHash (line 374) | pub(crate) trait DynHash {
    method dyn_hash (line 376) | fn dyn_hash(&self, state: &mut Box<&mut dyn Hasher>);
    method dyn_hash (line 380) | fn dyn_hash(&self, state: &mut Box<&mut dyn Hasher>) {
  type DynPartialEq (line 385) | pub(crate) trait DynPartialEq {
    method dyn_eq (line 386) | fn dyn_eq(&self, other: &&dyn Any) -> bool;
    method dyn_eq (line 390) | fn dyn_eq(&self, other: &&dyn Any) -> bool {
  type Sealed (line 399) | pub trait Sealed {}
  type SealedSubchannel (line 402) | pub(crate) trait SealedSubchannel: private::Sealed {}
  type Subchannel (line 421) | pub(crate) trait Subchannel:
    method address (line 426) | fn address(&self) -> Address;
    method connect (line 429) | fn connect(&self);
    method address (line 535) | fn address(&self) -> Address {
    method connect (line 539) | fn connect(&self) {
    method address (line 590) | fn address(&self) -> Address {
    method connect (line 593) | fn connect(&self) {
  function downcast_ref (line 433) | pub fn downcast_ref<T>(&self) -> Option<&T>
  method hash (line 442) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 448) | fn eq(&self, other: &Self) -> bool {
  method fmt (line 456) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 462) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type WeakSubchannel (line 468) | struct WeakSubchannel(Weak<dyn Subchannel>);
    method from (line 471) | fn from(subchannel: Arc<dyn Subchannel>) -> Self {
    method new (line 477) | pub fn new(subchannel: &Arc<dyn Subchannel>) -> Self {
    method upgrade (line 481) | pub fn upgrade(&self) -> Option<Arc<dyn Subchannel>> {
  method hash (line 487) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 493) | fn eq(&self, other: &Self) -> bool {
  type ExternalSubchannel (line 500) | pub(crate) struct ExternalSubchannel {
    method new (line 507) | pub(super) fn new(isc: Arc<InternalSubchannel>, work_scheduler: WorkQu...
    method set_watcher (line 515) | pub(super) fn set_watcher(&self, watcher: Arc<SubchannelStateWatcher>) {
  method hash (line 521) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method eq (line 527) | fn eq(&self, other: &Self) -> bool {
  method drop (line 549) | fn drop(&mut self) {
  method fmt (line 567) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 573) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ForwardingSubchannel (line 578) | pub(crate) trait ForwardingSubchannel: DynHash + DynPartialEq + Any + Se...
    method delegate (line 579) | fn delegate(&self) -> Arc<dyn Subchannel>;
    method address (line 581) | fn address(&self) -> Address {
    method connect (line 584) | fn connect(&self) {
  type QueuingPicker (line 603) | pub(crate) struct QueuingPicker {}
  type FailingPicker (line 612) | pub(crate) struct FailingPicker {

FILE: grpc/src/client/load_balancing/pick_first.rs
  type Builder (line 52) | struct Builder {}
  method build (line 55) | fn build(&self, options: LbPolicyOptions) -> Box<dyn LbPolicy> {
  method name (line 64) | fn name(&self) -> &'static str {
  function reg (line 69) | pub(crate) fn reg() {
  type PickFirstPolicy (line 74) | struct PickFirstPolicy {
  method resolver_update (line 82) | fn resolver_update(
  method subchannel_update (line 114) | fn subchannel_update(
  method work (line 131) | fn work(&mut self, channel_controller: &mut dyn ChannelController) {}
  method exit_idle (line 133) | fn exit_idle(&mut self, _channel_controller: &mut dyn ChannelController) {
  type OneSubchannelPicker (line 139) | struct OneSubchannelPicker {
  method pick (line 144) | fn pick(&self, _: &RequestHeaders) -> PickResult {

FILE: grpc/src/client/load_balancing/registry.rs
  type LbPolicyRegistry (line 34) | pub(crate) struct LbPolicyRegistry {
    method new (line 40) | pub fn new() -> Self {
    method add_builder (line 44) | pub(crate) fn add_builder(&self, builder: impl LbPolicyBuilder + 'stat...
    method get_policy (line 51) | pub(crate) fn get_policy(&self, name: &str) -> Option<Arc<dyn LbPolicy...
  method default (line 57) | fn default() -> Self {

FILE: grpc/src/client/load_balancing/round_robin.rs
  type RoundRobinBuilder (line 55) | struct RoundRobinBuilder {}
  method build (line 58) | fn build(&self, options: LbPolicyOptions) -> Box<dyn LbPolicy> {
  method name (line 68) | fn name(&self) -> &'static str {
  type RoundRobinPolicy (line 74) | struct RoundRobinPolicy {
    method new (line 80) | fn new(
    method move_to_transient_failure (line 92) | fn move_to_transient_failure(
    method update_picker (line 108) | fn update_picker(&mut self, channel_controller: &mut dyn ChannelContro...
    method handle_resolver_error (line 129) | fn handle_resolver_error(
  method resolver_update (line 153) | fn resolver_update(
  method subchannel_update (line 193) | fn subchannel_update(
  method work (line 204) | fn work(&mut self, channel_controller: &mut dyn ChannelController) {
  method exit_idle (line 209) | fn exit_idle(&mut self, channel_controller: &mut dyn ChannelController) {
  function reg (line 216) | pub(crate) fn reg() {
  type RoundRobinPicker (line 223) | struct RoundRobinPicker {
    method new (line 229) | fn new(pickers: Vec<Arc<dyn Picker>>) -> Self {
  method pick (line 239) | fn pick(&self, request_headers: &RequestHeaders) -> PickResult {
  constant DEFAULT_TEST_SHORT_TIMEOUT (line 281) | const DEFAULT_TEST_SHORT_TIMEOUT: std::time::Duration = std::time::Durat...
  function setup (line 297) | fn setup(
  type TestSubchannelList (line 319) | struct TestSubchannelList {
    method new (line 324) | fn new(addresses: &[Address], channel_controller: &mut dyn ChannelCont...
    method contains (line 333) | fn contains(&self, sc: &Arc<dyn Subchannel>) -> bool {
  function create_endpoints (line 338) | fn create_endpoints(num_endpoints: usize, num_addresses: usize) -> Vec<E...
  function send_resolver_update_to_policy (line 357) | fn send_resolver_update_to_policy(
  function send_resolver_error_to_policy (line 369) | fn send_resolver_error_to_policy(
  function move_subchannel_to_state (line 381) | fn move_subchannel_to_state(
  function move_subchannel_to_transient_failure (line 397) | fn move_subchannel_to_transient_failure(
  type OneSubchannelPicker (line 414) | struct OneSubchannelPicker {
  method pick (line 419) | fn pick(&self, _: &RequestHeaders) -> PickResult {
  function addresses_from_endpoints (line 428) | fn addresses_from_endpoints(endpoints: &[Endpoint]) -> Vec<Address> {
  type PickFirstState (line 438) | struct PickFirstState {
  function create_funcs_for_roundrobin_tests (line 449) | fn create_funcs_for_roundrobin_tests() -> StubPolicyFuncs {
  function create_endpoint (line 556) | fn create_endpoint(num_addresses: usize) -> Endpoint {
  function verify_subchannel_creation (line 572) | async fn verify_subchannel_creation(
  function verify_connecting_picker (line 591) | async fn verify_connecting_picker(
  function verify_ready_picker (line 611) | async fn verify_ready_picker(
  function verify_roundrobin_ready_picker (line 640) | async fn verify_roundrobin_ready_picker(
  function verify_transient_failure_picker (line 666) | async fn verify_transient_failure_picker(
  function verify_resolution_request (line 690) | async fn verify_resolution_request(rx_events: &mut mpsc::UnboundedReceiv...
  function verify_no_activity (line 698) | async fn verify_no_activity(rx_events: &mut mpsc::UnboundedReceiver<Test...
  function roundrobin_resolver_error_before_a_valid_update (line 711) | async fn roundrobin_resolver_error_before_a_valid_update() {
  function roundrobin_resolver_error_after_a_valid_update_in_ready (line 724) | async fn roundrobin_resolver_error_after_a_valid_update_in_ready() {
  function roundrobin_resolver_error_after_a_valid_update_in_connecting (line 764) | async fn roundrobin_resolver_error_after_a_valid_update_in_connecting() {
  function roundrobin_resolver_error_after_a_valid_update_in_tf (line 799) | async fn roundrobin_resolver_error_after_a_valid_update_in_tf() {
  function roundrobin_picks_are_round_robin (line 829) | async fn roundrobin_picks_are_round_robin() {
  function roundrobin_endpoints_removed (line 881) | async fn roundrobin_endpoints_removed() {
  function roundrobin_one_endpoint_down (line 916) | async fn roundrobin_one_endpoint_down() {
  function roundrobin_pick_after_resolved_updated_hosts (line 992) | async fn roundrobin_pick_after_resolved_updated_hosts() {
  function roundrobin_stay_transient_failure_until_ready (line 1133) | async fn roundrobin_stay_transient_failure_until_ready() {
  function roundrobin_zero_endpoints_from_resolver_before_valid_update (line 1182) | async fn roundrobin_zero_endpoints_from_resolver_before_valid_update() {
  function roundrobin_zero_endpoints_from_resolver_after_valid_update (line 1198) | async fn roundrobin_zero_endpoints_from_resolver_after_valid_update() {
  function roundrobin_with_multiple_backends_first_backend_is_ready (line 1238) | async fn roundrobin_with_multiple_backends_first_backend_is_ready() {
  function roundrobin_resolver_update_contains_currently_ready_subchannel (line 1291) | async fn roundrobin_resolver_update_contains_currently_ready_subchannel() {

FILE: grpc/src/client/load_balancing/test_utils.rs
  function new_request_headers (line 51) | pub(crate) fn new_request_headers() -> RequestHeaders {
  type TestSubchannel (line 57) | pub(crate) struct TestSubchannel {
    method new (line 63) | pub fn new(address: Address, tx_connect: mpsc::UnboundedSender<TestEve...
  method delegate (line 72) | fn delegate(&self) -> Arc<dyn Subchannel> {
  method address (line 76) | fn address(&self) -> Address {
  method connect (line 80) | fn connect(&self) {
  method hash (line 89) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method eq (line 95) | fn eq(&self, other: &Self) -> bool {
  type TestEvent (line 101) | pub(crate) enum TestEvent {
  method fmt (line 111) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TestChannelController (line 125) | pub(crate) struct TestChannelController {
  method new_subchannel (line 130) | fn new_subchannel(&mut self, address: &Address) -> Arc<dyn Subchannel> {
  method update_picker (line 140) | fn update_picker(&mut self, update: LbState) {
  method request_resolution (line 146) | fn request_resolution(&mut self) {
  type TestWorkScheduler (line 152) | pub(crate) struct TestWorkScheduler {
  method schedule_work (line 157) | fn schedule_work(&self) {
  type ResolverUpdateFn (line 163) | type ResolverUpdateFn = Arc<
  type SubchannelUpdateFn (line 175) | type SubchannelUpdateFn = Arc<
  type WorkFn (line 181) | type WorkFn = Arc<dyn Fn(&mut StubPolicyData, &mut dyn ChannelController...
  type StubPolicyFuncs (line 186) | pub(crate) struct StubPolicyFuncs {
  method fmt (line 193) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type StubPolicyData (line 200) | pub(crate) struct StubPolicyData {
    method new (line 207) | pub fn new(lb_policy_options: LbPolicyOptions) -> Self {
  type StubPolicy (line 217) | pub(crate) struct StubPolicy {
  method resolver_update (line 223) | fn resolver_update(
  method subchannel_update (line 235) | fn subchannel_update(
  method exit_idle (line 246) | fn exit_idle(&mut self, channel_controller: &mut dyn ChannelController) {
  method work (line 250) | fn work(&mut self, channel_controller: &mut dyn ChannelController) {
  type StubPolicyBuilder (line 259) | pub(crate) struct StubPolicyBuilder {
  type MockConfig (line 266) | pub(super) struct MockConfig {
  method build (line 271) | fn build(&self, options: LbPolicyOptions) -> Box<dyn LbPolicy> {
  method name (line 279) | fn name(&self) -> &'static str {
  method parse_config (line 283) | fn parse_config(
  function reg_stub_policy (line 297) | pub(crate) fn reg_stub_policy(name: &'static str, funcs: StubPolicyFuncs) {

FILE: grpc/src/client/mod.rs
  type ConnectivityState (line 60) | pub enum ConnectivityState {
  method fmt (line 69) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type CallOptions (line 85) | pub struct CallOptions {
  type Invoke (line 96) | pub trait Invoke: Sync {
    method invoke (line 109) | async fn invoke(
  type DynInvoke (line 117) | pub trait DynInvoke: Send + Sync {
    method dyn_invoke (line 118) | async fn dyn_invoke(
    method dyn_invoke (line 127) | async fn dyn_invoke(
  type InvokeOnce (line 140) | pub trait InvokeOnce: Sync {
    method invoke_once (line 144) | async fn invoke_once(
    type SendStream (line 152) | type SendStream = T::SendStream;
    type RecvStream (line 153) | type RecvStream = T::RecvStream;
    method invoke_once (line 155) | async fn invoke_once(
  type SendStream (line 171) | pub trait SendStream {
    method send (line 181) | async fn send(&mut self, msg: &dyn SendMessage, options: SendOptions) ...
    method send (line 197) | async fn send(&mut self, msg: &dyn SendMessage, options: SendOptions) ...
  type DynSendStream (line 185) | pub trait DynSendStream: Send {
    method dyn_send (line 186) | async fn dyn_send(&mut self, msg: &dyn SendMessage, options: SendOptio...
    method dyn_send (line 191) | async fn dyn_send(&mut self, msg: &dyn SendMessage, options: SendOptio...
  type SendOptions (line 208) | pub struct SendOptions {
  type RecvStream (line 222) | pub trait RecvStream {
    method next (line 231) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseS...
    method next (line 247) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseS...
  type DynRecvStream (line 235) | pub trait DynRecvStream: Send {
    method dyn_next (line 236) | async fn dyn_next(&mut self, msg: &mut dyn RecvMessage) -> ClientRespo...
    method dyn_next (line 241) | async fn dyn_next(&mut self, msg: &mut dyn RecvMessage) -> ClientRespo...

FILE: grpc/src/client/name_resolution/backoff.rs
  type BackoffConfig (line 30) | pub(crate) struct BackoffConfig {
    method validate (line 66) | fn validate(&self) -> Result<(), &'static str> {
  type ExponentialBackoff (line 45) | pub(crate) struct ExponentialBackoff {
    method new (line 88) | pub fn new(config: BackoffConfig) -> Result<Self, &'static str> {
    method reset (line 97) | pub fn reset(&mut self) {
    method backoff_duration (line 101) | pub fn backoff_duration(&mut self) -> Duration {
  constant DEFAULT_EXPONENTIAL_CONFIG (line 58) | pub(crate) const DEFAULT_EXPONENTIAL_CONFIG: BackoffConfig = BackoffConf...
  constant EPSILON (line 124) | const EPSILON: f64 = 1e-9;
  function default_config_is_valid (line 127) | fn default_config_is_valid() {
  function base_less_than_max (line 133) | fn base_less_than_max() {
  function base_more_than_max (line 145) | fn base_more_than_max() {
  function negative_multiplier (line 157) | fn negative_multiplier() {
  function negative_jitter (line 169) | fn negative_jitter() {
  function jitter_greater_than_one (line 181) | fn jitter_greater_than_one() {
  function backoff_reset_no_jitter (line 193) | fn backoff_reset_no_jitter() {
  function backoff_with_jitter (line 221) | fn backoff_with_jitter() {

FILE: grpc/src/client/name_resolution/dns/mod.rs
  constant DEFAULT_PORT (line 61) | const DEFAULT_PORT: u16 = 443;
  constant DEFAULT_DNS_PORT (line 62) | const DEFAULT_DNS_PORT: u16 = 53;
  function get_resolving_timeout (line 76) | fn get_resolving_timeout() -> Duration {
  function set_resolving_timeout (line 92) | pub(crate) fn set_resolving_timeout(duration: Duration) {
  function get_min_resolution_interval (line 96) | fn get_min_resolution_interval() -> Duration {
  function set_min_resolution_interval (line 105) | pub(crate) fn set_min_resolution_interval(duration: Duration) {
  function reg (line 109) | pub(crate) fn reg() {
  type Builder (line 113) | struct Builder {}
  type DnsOptions (line 115) | struct DnsOptions {
  method build (line 204) | fn build(&self, target: &Target, options: ResolverOptions) -> Box<dyn Re...
  method scheme (line 236) | fn scheme(&self) -> &'static str {
  method is_valid_uri (line 240) | fn is_valid_uri(&self, target: &Target) -> bool {
  type DnsResolver (line 250) | struct DnsResolver {
    method new (line 124) | fn new(
  type InternalState (line 257) | struct InternalState {
  method resolve_now (line 264) | fn resolve_now(&mut self) {
  method work (line 268) | fn work(&mut self, channel_controller: &mut dyn ChannelController) {
  method drop (line 298) | fn drop(&mut self) {
  type HostPort (line 304) | struct HostPort {
  type ParseResult (line 310) | struct ParseResult {
  function parse_endpoint_and_authority (line 315) | fn parse_endpoint_and_authority(target: &Target) -> Result<ParseResult, ...
  function parse_host_port (line 356) | fn parse_host_port(host_and_port: &str, default_port: u16) -> Result<Opt...
  function nop_resolver_for_ip (line 376) | fn nop_resolver_for_ip(ip: IpAddr, port: u16, options: ResolverOptions) ...
  function nop_resolver_for_err (line 393) | fn nop_resolver_for_err(err: String, options: ResolverOptions) -> Box<dy...

FILE: grpc/src/client/name_resolution/dns/test.rs
  constant DEFAULT_TEST_SHORT_TIMEOUT (line 58) | const DEFAULT_TEST_SHORT_TIMEOUT: Duration = Duration::from_millis(10);
  function target_parsing (line 61) | pub(crate) fn target_parsing() {
  type FakeWorkScheduler (line 176) | struct FakeWorkScheduler {
  method schedule_work (line 181) | fn schedule_work(&self) {
  type FakeChannelController (line 186) | struct FakeChannelController {
  method update (line 192) | fn update(&mut self, update: ResolverUpdate) -> Result<(), String> {
  method parse_service_config (line 198) | fn parse_service_config(&self, _: &str) -> Result<ServiceConfig, String> {
  function dns_basic (line 204) | pub(crate) async fn dns_basic() {
  function invalid_target (line 233) | pub(crate) async fn invalid_target() {
  type FakeDns (line 268) | struct FakeDns {
    method lookup_host_name (line 275) | async fn lookup_host_name(&self, _: &str) -> Result<Vec<std::net::IpAd...
    method lookup_txt (line 280) | async fn lookup_txt(&self, _: &str) -> Result<Vec<String>, String> {
  type FakeRuntime (line 286) | struct FakeRuntime {
    method spawn (line 292) | fn spawn(
    method get_dns_resolver (line 299) | fn get_dns_resolver(&self, _: rt::ResolverOptions) -> Result<Box<dyn r...
    method sleep (line 303) | fn sleep(&self, duration: std::time::Duration) -> Pin<Box<dyn rt::Slee...
    method tcp_stream (line 307) | fn tcp_stream(
    method listen_tcp (line 315) | fn listen_tcp(
  function dns_lookup_error (line 325) | pub(crate) async fn dns_lookup_error() {
  function dns_lookup_timeout (line 361) | pub(crate) async fn dns_lookup_timeout() {
  function rate_limit (line 403) | pub(crate) async fn rate_limit() {
  function re_resolution_after_success (line 453) | pub(crate) async fn re_resolution_after_success() {
  function backoff_on_error (line 497) | pub(crate) async fn backoff_on_error() {

FILE: grpc/src/client/name_resolution/mod.rs
  type Target (line 60) | pub(crate) struct Target {
    method from (line 76) | fn from(url: url::Url) -> Self {
    method scheme (line 92) | pub fn scheme(&self) -> &str {
    method authority_host (line 97) | pub fn authority_host(&self) -> &str {
    method authority_port (line 102) | pub fn authority_port(&self) -> Option<u16> {
    method authority_host_port (line 108) | pub fn authority_host_port(&self) -> String {
    method path (line 119) | pub fn path(&self) -> &str {
  type Err (line 65) | type Err = String;
  method from_str (line 67) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 125) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type ResolverBuilder (line 138) | pub(crate) trait ResolverBuilder: Send + Sync {
    method build (line 143) | fn build(&self, target: &Target, options: ResolverOptions) -> Box<dyn ...
    method scheme (line 146) | fn scheme(&self) -> &str;
    method default_authority (line 156) | fn default_authority(&self, target: &Target) -> String {
    method is_valid_uri (line 163) | fn is_valid_uri(&self, uri: &Target) -> bool;
  type ResolverOptions (line 169) | pub(crate) struct ResolverOptions {
  type WorkScheduler (line 189) | pub(crate) trait WorkScheduler: Send + Sync {
    method schedule_work (line 193) | fn schedule_work(&self);
  type Resolver (line 201) | pub(crate) trait Resolver: Send + Sync {
    method resolve_now (line 211) | fn resolve_now(&mut self);
    method work (line 215) | fn work(&mut self, channel_controller: &mut dyn ChannelController);
    method resolve_now (line 342) | fn resolve_now(&mut self) {}
    method work (line 344) | fn work(&mut self, channel_controller: &mut dyn ChannelController) {
  type ChannelController (line 220) | pub(crate) trait ChannelController: Send + Sync {
    method update (line 226) | fn update(&mut self, update: ResolverUpdate) -> Result<(), String>;
    method parse_service_config (line 230) | fn parse_service_config(&self, config: &str) -> Result<ServiceConfig, ...
  type ResolverUpdate (line 237) | pub(crate) struct ResolverUpdate {
  method default (line 261) | fn default() -> Self {
  type Endpoint (line 276) | pub(crate) struct Endpoint {
  method hash (line 286) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  type Address (line 294) | pub(crate) struct Address {
  method eq (line 311) | fn eq(&self, other: &Self) -> bool {
  method hash (line 317) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method fmt (line 325) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type NopResolver (line 337) | struct NopResolver {
  function parse_target (line 354) | pub fn parse_target() {

FILE: grpc/src/client/name_resolution/registry.rs
  type ResolverRegistry (line 37) | pub(crate) struct ResolverRegistry {
    method new (line 43) | fn new() -> Self {
    method add_builder (line 57) | pub fn add_builder(&self, builder: Box<dyn ResolverBuilder>) {
    method try_add_builder (line 65) | pub fn try_add_builder(&self, builder: Box<dyn ResolverBuilder>) -> Re...
    method get (line 83) | pub fn get(&self, scheme: &str) -> Option<Arc<dyn ResolverBuilder>> {
  function global_registry (line 93) | pub(crate) fn global_registry() -> &'static ResolverRegistry {

FILE: grpc/src/client/service_config.rs
  type ServiceConfig (line 32) | pub(crate) struct ServiceConfig {
  type LbPolicyType (line 37) | pub enum LbPolicyType {
  type LbConfig (line 45) | pub(crate) struct LbConfig {
    method new (line 51) | pub fn new(config: impl Any + Send + Sync) -> Self {
    method convert_to (line 58) | pub fn convert_to<T: 'static + Send + Sync>(&self) -> Option<Arc<T>> {

FILE: grpc/src/client/stream_util.rs
  type ResponseValidator (line 39) | pub struct ResponseValidator {
    method new (line 50) | pub fn new(unary: bool) -> Self {
    type SendStream (line 56) | type SendStream = I::SendStream;
    type RecvStream (line 57) | type RecvStream = RecvStreamValidator<I::RecvStream>;
    method intercept (line 59) | async fn intercept(
  type RecvStreamValidator (line 73) | pub struct RecvStreamValidator<R> {
  type RecvStreamState (line 79) | enum RecvStreamState {
  function new (line 95) | pub fn new(recv_stream: R, unary_response: bool) -> Self {
  function error (line 105) | fn error(&mut self, s: impl Into<String>) -> ClientResponseStreamItem {
  method next (line 115) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseStr...
  function test_validator_messages_before_headers (line 182) | async fn test_validator_messages_before_headers() {
  function test_validator_stream_closed_before_trailers (line 200) | async fn test_validator_stream_closed_before_trailers() {
  function test_validator_headers_repeated (line 229) | async fn test_validator_headers_repeated() {
  function test_validator_unary_ok_without_message (line 256) | async fn test_validator_unary_ok_without_message() {
  function test_validator_unary_multiple_messages (line 282) | async fn test_validator_unary_multiple_messages() {
  function test_validator_successful_stream (line 303) | async fn test_validator_successful_stream() {
  function test_validator_erroring_stream (line 323) | async fn test_validator_erroring_stream() {
  function test_validator_successful_unary (line 349) | async fn test_validator_successful_unary() {
  function test_validator_erroring_unary (line 367) | async fn test_validator_erroring_unary() {
  function validate_scenario (line 403) | async fn validate_scenario(
  type NopSendStream (line 444) | struct NopSendStream;
  method send (line 447) | async fn send(&mut self, _item: &dyn SendMessage, _options: SendOptions)...
  type NopRecvMessage (line 452) | struct NopRecvMessage;
  method decode (line 455) | fn decode(&mut self, data: &mut dyn Buf) -> Result<(), String> {
  type MockRecvStream (line 462) | struct MockRecvStream {
    method new (line 486) | fn new() -> (Self, Sender<ClientResponseStreamItem>) {
  type SendStream (line 467) | type SendStream = NopSendStream;
  type RecvStream (line 468) | type RecvStream = Self;
  method invoke_once (line 470) | async fn invoke_once(
  method next (line 480) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseStr...

FILE: grpc/src/client/subchannel.rs
  type SharedInvoke (line 57) | type SharedInvoke = Arc<dyn DynInvoke>;
  type Backoff (line 59) | pub trait Backoff: Send + Sync {
    method backoff_until (line 60) | fn backoff_until(&self) -> Instant;
    method reset (line 61) | fn reset(&self);
    method min_connect_timeout (line 62) | fn min_connect_timeout(&self) -> Duration;
    method backoff_until (line 68) | fn backoff_until(&self) -> Instant {
    method reset (line 71) | fn reset(&self) {}
    method min_connect_timeout (line 72) | fn min_connect_timeout(&self) -> Duration {
  type NopBackoff (line 66) | pub(crate) struct NopBackoff {}
  type InternalSubchannelState (line 77) | enum InternalSubchannelState {
  method from (line 85) | fn from(iss: &'a InternalSubchannelState) -> SubchannelState {
  method fmt (line 111) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 122) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method eq (line 133) | fn eq(&self, other: &Self) -> bool {
  method dyn_invoke (line 162) | async fn dyn_invoke(
  type InternalSubchannel (line 175) | pub(crate) struct InternalSubchannel {
    method new (line 209) | pub(super) fn new(
    method address (line 238) | pub(super) fn address(&self) -> Address {
    method connect (line 244) | pub(super) fn connect(self: &Arc<Self>) {
    method register_connectivity_state_watcher (line 248) | pub(super) fn register_connectivity_state_watcher(&self, watcher: Arc<...
    method unregister_connectivity_state_watcher (line 255) | pub(super) fn unregister_connectivity_state_watcher(
  type InnerSubchannel (line 183) | struct InnerSubchannel {
    method move_to_idle (line 276) | fn move_to_idle(&self) {
    method begin_connecting (line 285) | fn begin_connecting(&self) {
    method move_to_ready (line 322) | async fn move_to_ready(
    method move_to_transient_failure (line 350) | async fn move_to_transient_failure(&self, err: String) {
  type SharedInnerSubchannelData (line 187) | struct SharedInnerSubchannelData {
    method update_state (line 199) | fn update_state(&mut self, state: InternalSubchannelState) {
  method drop (line 371) | fn drop(&mut self) {
  type SubchannelKey (line 381) | pub(crate) struct SubchannelKey {
    method new (line 386) | pub(crate) fn new(address: Address) -> Self {
  method fmt (line 393) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 399) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type InternalSubchannelPool (line 404) | pub(super) struct InternalSubchannelPool {
    method new (line 409) | pub(super) fn new() -> Self {
    method lookup_subchannel (line 415) | pub(super) fn lookup_subchannel(&self, key: &SubchannelKey) -> Option<...
    method register_subchannel (line 425) | pub(super) fn register_subchannel(
    method unregister_subchannel (line 438) | pub(super) fn unregister_subchannel(&self, key: &SubchannelKey) {
  type SubchannelStateWatcher (line 453) | pub(super) struct SubchannelStateWatcher {
    method new (line 459) | pub(super) fn new(sc: Arc<ExternalSubchannel>, work_scheduler: WorkQue...
    method on_state_change (line 466) | fn on_state_change(&self, state: SubchannelState) {

FILE: grpc/src/client/transport/mod.rs
  type TransportOptions (line 48) | pub(crate) struct TransportOptions {
  type Transport (line 64) | pub(crate) trait Transport: Sync {
    method connect (line 67) | async fn connect(
  type DynTransport (line 76) | pub(crate) trait DynTransport: Send + Sync {
    method dyn_connect (line 77) | async fn dyn_connect(
    method dyn_connect (line 87) | async fn dyn_connect(

FILE: grpc/src/client/transport/registry.rs
  type TransportRegistry (line 37) | pub(crate) struct TransportRegistry {
    method new (line 53) | pub(crate) fn new() -> Self {
    method add_transport (line 57) | pub(crate) fn add_transport<T>(&self, address_type: &str, transport: T)
    method get_transport (line 68) | pub(crate) fn get_transport(
  method fmt (line 42) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: grpc/src/client/transport/tonic/mod.rs
  constant DEFAULT_BUFFER_SIZE (line 92) | const DEFAULT_BUFFER_SIZE: usize = 1024;
  type BoxError (line 93) | pub(crate) type BoxError = Box<dyn Error + Send + Sync>;
  type BoxFuture (line 95) | type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
  type BoxStream (line 96) | type BoxStream<T> = Pin<Box<dyn Stream<Item = Result<T, TonicStatus>> + ...
  function reg (line 98) | pub(crate) fn reg() {
  type TransportBuilder (line 102) | struct TransportBuilder {}
  type TonicTransport (line 104) | struct TonicTransport {
  method drop (line 111) | fn drop(&mut self) {
  type SendStream (line 117) | type SendStream = TonicSendStream;
  type RecvStream (line 118) | type RecvStream = TonicRecvStream;
  method invoke (line 120) | async fn invoke(
  function trailers_from_tonic_status (line 165) | fn trailers_from_tonic_status(status: TonicStatus) -> ClientResponseStre...
  function trailers_from_status (line 173) | fn trailers_from_status(code: StatusCode, msg: impl Into<String>) -> Cli...
  type TonicSendStream (line 177) | struct TonicSendStream {
  method send (line 182) | async fn send(&mut self, msg: &dyn SendMessage, options: SendOptions) ->...
  type TonicRecvStream (line 196) | struct TonicRecvStream {
  type StreamState (line 200) | enum StreamState {
  method next (line 208) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseStr...
  function err_streams (line 253) | fn err_streams(status: Status) -> (TonicSendStream, TonicRecvStream) {
  type Service (line 263) | type Service = TonicTransport;
  method connect (line 265) | async fn connect(
  type SendRequestWrapper (line 357) | struct SendRequestWrapper {
    method from (line 362) | fn from(inner: SendRequest<Body>) -> Self {
    type Response (line 368) | type Response = HttpResponse<Body>;
    type Error (line 369) | type Error = BoxError;
    type Future (line 370) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
    method poll_ready (line 372) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 376) | fn call(&mut self, req: http::Request<Body>) -> Self::Future {
  type TonicService (line 383) | struct TonicService {
    type ResponseBody (line 388) | type ResponseBody = Body;
    type Error (line 389) | type Error = BoxError;
    type Future (line 390) | type Future = ResponseFuture;
    method poll_ready (line 392) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 396) | fn call(&mut self, request: http::Request<Body>) -> Self::Future {
  type ResponseFuture (line 406) | pub(crate) struct ResponseFuture {
  type Output (line 411) | type Output = Result<http::Response<Body>, BoxError>;
  method poll (line 413) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type BufCodec (line 418) | pub(crate) struct BufCodec {}
  type Encode (line 421) | type Encode = Box<dyn Buf + Send + Sync>;
  type Decode (line 422) | type Decode = Bytes;
  type Encoder (line 423) | type Encoder = BufEncoder;
  type Decoder (line 424) | type Decoder = BytesDecoder;
  method encoder (line 426) | fn encoder(&mut self) -> Self::Encoder {
  method decoder (line 430) | fn decoder(&mut self) -> Self::Decoder {
  type BytesEncoder (line 435) | pub struct BytesEncoder {}
  type Item (line 438) | type Item = Bytes;
  type Error (line 439) | type Error = TonicStatus;
  method encode (line 441) | fn encode(&mut self, item: Self::Item, dst: &mut EncodeBuf<'_>) -> Resul...
  type BufEncoder (line 447) | pub struct BufEncoder {}
  type Item (line 450) | type Item = Box<dyn Buf + Send + Sync>;
  type Error (line 451) | type Error = TonicStatus;
  method encode (line 453) | fn encode(&mut self, mut item: Self::Item, dst: &mut EncodeBuf<'_>) -> R...
  type BytesDecoder (line 460) | pub struct BytesDecoder {}
  type Item (line 463) | type Item = Bytes;
  type Error (line 464) | type Error = TonicStatus;
  method decode (line 466) | fn decode(

FILE: grpc/src/client/transport/tonic/test.rs
  constant DEFAULT_TEST_DURATION (line 65) | const DEFAULT_TEST_DURATION: Duration = Duration::from_secs(10);
  constant DEFAULT_TEST_SHORT_DURATION (line 66) | const DEFAULT_TEST_SHORT_DURATION: Duration = Duration::from_millis(10);
  function tonic_transport_rpc (line 70) | pub(crate) async fn tonic_transport_rpc() {
  function grpc_invoke_tonic_unary (line 163) | async fn grpc_invoke_tonic_unary() {
  type WrappedEchoRequest (line 243) | struct WrappedEchoRequest(EchoRequest);
  type WrappedEchoResponse (line 244) | struct WrappedEchoResponse(EchoResponse);
  method encode (line 247) | fn encode(&self) -> Result<Box<dyn Buf + Send + Sync>, String> {
  method decode (line 253) | fn decode(&mut self, data: &mut dyn Buf) -> Result<(), String> {
  type EchoService (line 261) | pub(crate) struct EchoService {}
  method unary_echo (line 265) | async fn unary_echo(
  type ServerStreamingEchoStream (line 273) | type ServerStreamingEchoStream = ReceiverStream<Result<EchoResponse, Sta...
  method server_streaming_echo (line 275) | async fn server_streaming_echo(
  method client_streaming_echo (line 282) | async fn client_streaming_echo(
  type BidirectionalStreamingEchoStream (line 288) | type BidirectionalStreamingEchoStream =
  method bidirectional_streaming_echo (line 291) | async fn bidirectional_streaming_echo(

FILE: grpc/src/core/mod.rs
  type SendMessage (line 37) | pub trait SendMessage: Send + Sync {
    method encode (line 38) | fn encode(&self) -> Result<Box<dyn Buf + Send + Sync>, String>;
    method _ptr_for (line 41) | unsafe fn _ptr_for(&self, id: TypeId) -> Option<*const ()> {
  type RecvMessage (line 47) | pub trait RecvMessage: Send + Sync {
    method decode (line 48) | fn decode(&mut self, data: &mut dyn Buf) -> Result<(), String>;
    method _ptr_for (line 51) | unsafe fn _ptr_for(&mut self, id: TypeId) -> Option<*mut ()> {
  type MessageType (line 59) | pub trait MessageType {
  function msg_type_id (line 64) | fn msg_type_id<T: MessageType>() -> TypeId
  function downcast_ref (line 73) | pub fn downcast_ref<T: MessageType>(&self) -> Option<&T::Target<'_>>
  function downcast_mut (line 90) | pub fn downcast_mut<T: MessageType>(&mut self) -> Option<&mut T::Target<...
  type ResponseStreamItem (line 116) | pub enum ResponseStreamItem<M> {
  type ClientResponseStreamItem (line 130) | pub type ClientResponseStreamItem = ResponseStreamItem<()>;
  type ServerResponseStreamItem (line 134) | pub type ServerResponseStreamItem<'a> = ResponseStreamItem<&'a dyn SendM...
  type ResponseHeaders (line 138) | pub struct ResponseHeaders {
    method new (line 144) | pub fn new() -> Self {
    method with_metadata (line 149) | pub fn with_metadata(mut self, metadata: MetadataMap) -> Self {
    method metadata (line 155) | pub fn metadata(&self) -> &MetadataMap {
    method metadata_mut (line 160) | pub fn metadata_mut(&mut self) -> &mut MetadataMap {
  type RequestHeaders (line 167) | pub struct RequestHeaders {
    method new (line 176) | pub fn new() -> Self {
    method with_method_name (line 181) | pub fn with_method_name(mut self, method_name: impl Into<String>) -> S...
    method with_metadata (line 187) | pub fn with_metadata(mut self, metadata: MetadataMap) -> Self {
    method method_name (line 193) | pub fn method_name(&self) -> &String {
    method metadata (line 198) | pub fn metadata(&self) -> &MetadataMap {
    method metadata_mut (line 203) | pub fn metadata_mut(&mut self) -> &mut MetadataMap {
    method into_parts (line 209) | pub(crate) fn into_parts(self) -> (String, MetadataMap) {
  type Trailers (line 217) | pub struct Trailers {
    method new (line 224) | pub fn new(status: Status) -> Self {
    method with_status (line 232) | pub fn with_status(mut self, status: Status) -> Self {
    method status (line 238) | pub fn status(&self) -> &Status {
    method with_metadata (line 243) | pub fn with_metadata(mut self, metadata: MetadataMap) -> Self {
    method metadata_mut (line 249) | pub fn metadata_mut(&mut self) -> &mut MetadataMap {
    method metadata (line 254) | pub fn metadata(&self) -> &MetadataMap {

FILE: grpc/src/credentials/call.rs
  type CallDetails (line 39) | pub struct CallDetails {
    method new (line 45) | pub(crate) fn new(service_url: String, method_name: String) -> Self {
    method service_url (line 53) | pub fn service_url(&self) -> &str {
    method method_name (line 58) | pub fn method_name(&self) -> &str {
  type ChannelSecurityInfo (line 63) | pub struct ChannelSecurityInfo {
    method new (line 71) | pub(crate) fn new(
    method security_protocol (line 83) | pub fn security_protocol(&self) -> &'static str {
    method security_level (line 87) | pub fn security_level(&self) -> SecurityLevel {
    method attributes (line 91) | pub fn attributes(&self) -> &Attributes {
  type CallCredentials (line 99) | pub trait CallCredentials: Send + Sync + Debug {
    method get_metadata (line 114) | async fn get_metadata(
    method minimum_channel_security_level (line 124) | fn minimum_channel_security_level(&self) -> SecurityLevel {
    method get_metadata (line 155) | async fn get_metadata(
    method minimum_channel_security_level (line 167) | fn minimum_channel_security_level(&self) -> SecurityLevel {
    method get_metadata (line 191) | async fn get_metadata(
    method minimum_channel_security_level (line 206) | fn minimum_channel_security_level(&self) -> SecurityLevel {
  type CompositeCallCredentials (line 134) | pub struct CompositeCallCredentials {
    method new (line 140) | pub fn new(first: Arc<dyn CallCredentials>, second: Arc<dyn CallCreden...
    method with_call_credentials (line 147) | pub fn with_call_credentials(mut self, creds: Arc<dyn CallCredentials>...
  type MockCallCredentials (line 183) | struct MockCallCredentials {
  function test_composite_call_credentials (line 212) | async fn test_composite_call_credentials() {

FILE: grpc/src/credentials/client.rs
  type ChannelCredsInternal (line 39) | pub trait ChannelCredsInternal {
    method connect (line 56) | async fn connect<Input: GrpcEndpoint>(
    method get_call_credentials (line 65) | fn get_call_credentials(&self) -> Option<&Arc<dyn CallCredentials>>;
    type ContextType (line 204) | type ContextType = T::ContextType;
    type Output (line 205) | type Output<I> = T::Output<I>;
    method connect (line 207) | async fn connect<Input: GrpcEndpoint>(
    method get_call_credentials (line 219) | fn get_call_credentials(&self) -> Option<&Arc<dyn CallCredentials>> {
  type HandshakeOutput (line 68) | pub struct HandshakeOutput<T, C: ClientConnectionSecurityContext> {
  type ClientConnectionSecurityContext (line 73) | pub trait ClientConnectionSecurityContext: Send + Sync + 'static {
    method validate_authority (line 85) | fn validate_authority(&self, authority: &Authority) -> bool {
    method validate_authority (line 91) | fn validate_authority(&self, authority: &Authority) -> bool {
  type ClientConnectionSecurityInfo (line 97) | pub struct ClientConnectionSecurityInfo<C> {
  function new (line 106) | pub fn new(
  function security_protocol (line 120) | pub fn security_protocol(&self) -> &'static str {
  function security_level (line 124) | pub fn security_level(&self) -> SecurityLevel {
  function security_context (line 128) | pub fn security_context(&self) -> &C {
  function attributes (line 132) | pub fn attributes(&self) -> &Attributes {
  function into_boxed (line 136) | pub fn into_boxed(
  type ClientHandshakeInfo (line 159) | pub struct ClientHandshakeInfo {
    method new (line 165) | pub fn new(attributes: Attributes) -> Self {
    method attributes (line 169) | pub fn attributes(&self) -> &Attributes {
  type CompositeChannelCredentials (line 178) | pub struct CompositeChannelCredentials<T> {
  function new (line 184) | pub fn new(channel_creds: T, call_creds: Arc<dyn CallCredentials>) -> Re...
  method info (line 225) | fn info(&self) -> &ProtocolInfo {
  type MockCallCredentials (line 248) | struct MockCallCredentials {
  method get_metadata (line 256) | async fn get_metadata(
  method minimum_channel_security_level (line 271) | fn minimum_channel_security_level(&self) -> SecurityLevel {
  function test_multiple_composition (line 277) | async fn test_multiple_composition() {
  function test_composite_channel_credentials_insecure (line 342) | fn test_composite_channel_credentials_insecure() {

FILE: grpc/src/credentials/dyn_wrapper.rs
  type BoxEndpoint (line 39) | type BoxEndpoint = Box<dyn GrpcEndpoint>;
  type DynChannelCredentials (line 43) | pub(crate) trait DynChannelCredentials: Send + Sync {
    method connect (line 44) | async fn connect(
    method info (line 52) | fn info(&self) -> &ProtocolInfo;
    method connect (line 61) | async fn connect(
    method info (line 83) | fn info(&self) -> &ProtocolInfo {
  type DynServerCredentials (line 90) | pub(crate) trait DynServerCredentials: Send + Sync {
    method accept (line 91) | async fn accept(
    method info (line 97) | fn info(&self) -> &ProtocolInfo;
    method accept (line 106) | async fn accept(
    method info (line 118) | fn info(&self) -> &ProtocolInfo {
  function test_dyn_client_credential_dispatch (line 139) | async fn test_dyn_client_credential_dispatch() {
  function test_dyn_server_credential_dispatch (line 188) | async fn test_dyn_server_credential_dispatch() {

FILE: grpc/src/credentials/insecure.rs
  type InsecureChannelCredentials (line 49) | pub struct InsecureChannelCredentials {
    method new (line 57) | pub fn new() -> Self {
    type ContextType (line 73) | type ContextType = InsecureConnectionSecurityContext;
    type Output (line 74) | type Output<I> = I;
    method connect (line 76) | async fn connect<Input: GrpcEndpoint>(
    method get_call_credentials (line 94) | fn get_call_credentials(&self) -> Option<&Arc<dyn CallCredentials>> {
  constant PROTOCOL_NAME (line 53) | pub const PROTOCOL_NAME: &str = "insecure";
  type InsecureConnectionSecurityContext (line 64) | pub struct InsecureConnectionSecurityContext;
  method validate_authority (line 67) | fn validate_authority(&self, _authority: &Authority) -> bool {
  method info (line 100) | fn info(&self) -> &ProtocolInfo {
  type InsecureServerCredentials (line 108) | pub struct InsecureServerCredentials {
    method new (line 113) | pub fn new() -> Self {
    type Output (line 119) | type Output<I> = I;
    method accept (line 121) | async fn accept<Input: GrpcEndpoint>(
  method info (line 138) | fn info(&self) -> &ProtocolInfo {
  function test_insecure_client_credentials (line 167) | async fn test_insecure_client_credentials() {
  function test_insecure_server_credentials (line 219) | async fn test_insecure_server_credentials() {

FILE: grpc/src/credentials/local.rs
  constant PROTOCOL_NAME (line 47) | pub const PROTOCOL_NAME: &str = "local";
  type LocalChannelCredentials (line 55) | pub struct LocalChannelCredentials {
    method new (line 61) | pub fn new() -> Self {
    type ContextType (line 100) | type ContextType = LocalConnectionSecurityContext;
    type Output (line 101) | type Output<I> = I;
    method connect (line 103) | async fn connect<Input: GrpcEndpoint>(
    method get_call_credentials (line 123) | fn get_call_credentials(&self) -> Option<&Arc<dyn CallCredentials>> {
  type LocalConnectionSecurityContext (line 69) | pub struct LocalConnectionSecurityContext;
  method validate_authority (line 72) | fn validate_authority(&self, _authority: &Authority) -> bool {
  function security_level_for_endpoint (line 80) | fn security_level_for_endpoint(
  method info (line 129) | fn info(&self) -> &ProtocolInfo {
  type LocalServerCredentials (line 137) | pub struct LocalServerCredentials {
    method new (line 142) | pub fn new() -> Self {
    type Output (line 148) | type Output<I> = I;
    method accept (line 150) | async fn accept<Input: GrpcEndpoint>(
  method info (line 169) | fn info(&self) -> &ProtocolInfo {
  function test_security_level_for_endpoint_success (line 196) | fn test_security_level_for_endpoint_success() {
  function test_security_level_for_endpoint_failure (line 208) | fn test_security_level_for_endpoint_failure() {
  function test_local_client_credentials (line 215) | async fn test_local_client_credentials() {
  function test_local_server_credentials (line 267) | async fn test_local_server_credentials() {

FILE: grpc/src/credentials/mod.rs
  type ChannelCredentials (line 42) | pub trait ChannelCredentials: client::ChannelCredsInternal + Sync + 'sta...
    method info (line 44) | fn info(&self) -> &ProtocolInfo;
  type ServerCredentials (line 47) | pub trait ServerCredentials: server::ServerCredsInternal + Sync + 'static {
    method info (line 49) | fn info(&self) -> &ProtocolInfo;
  type SecurityLevel (line 55) | pub enum SecurityLevel {
  type Authority (line 74) | pub struct Authority {
    method new (line 80) | pub fn new(host: String, port: Option<u16>) -> Self {
    method host (line 84) | pub fn host(&self) -> &str {
    method port (line 88) | pub fn port(&self) -> Option<u16> {
  type ProtocolInfo (line 94) | pub struct ProtocolInfo {
    method new (line 99) | pub(crate) const fn new(security_protocol: &'static str) -> Self {
    method security_protocol (line 103) | pub fn security_protocol(&self) -> &'static str {

FILE: grpc/src/credentials/rustls/client/mod.rs
  type ClientTlsConfig (line 64) | pub struct ClientTlsConfig {
    method new (line 71) | pub fn new() -> Self {
    method with_root_certificates_provider (line 84) | pub fn with_root_certificates_provider<R>(mut self, provider: R) -> Self
    method with_identity_provider (line 97) | pub fn with_identity_provider<I>(mut self, provider: I) -> Self
    method insecure_with_key_log_path (line 111) | pub fn insecure_with_key_log_path(mut self, path: impl Into<PathBuf>) ...
  method default (line 118) | fn default() -> Self {
  type RustlsClientTlsCredendials (line 124) | pub struct RustlsClientTlsCredendials {
    method new (line 131) | pub fn new(config: ClientTlsConfig) -> Result<RustlsClientTlsCredendia...
    method new_impl (line 144) | fn new_impl(
    type ContextType (line 218) | type ContextType = ClientTlsSecContext;
    type Output (line 219) | type Output<I> = TlsStream<I>;
    method connect (line 220) | async fn connect<Input: GrpcEndpoint>(
    method get_call_credentials (line 266) | fn get_call_credentials(&self) -> Option<&Arc<dyn CallCredentials>> {
  type ClientTlsSecContext (line 192) | pub struct ClientTlsSecContext {
  method validate_authority (line 197) | fn validate_authority(&self, authority: &Authority) -> bool {
  method info (line 272) | fn info(&self) -> &ProtocolInfo {

FILE: grpc/src/credentials/rustls/client/test.rs
  function init_provider (line 57) | fn init_provider() {
  function test_tls_handshake (line 64) | async fn test_tls_handshake() {
  function test_tls_handshake_no_alpn (line 70) | async fn test_tls_handshake_no_alpn() {
  function test_tls_handshake_bad_alpn (line 77) | async fn test_tls_handshake_bad_alpn() {
  function test_tls_handshake_alpn_h1_and_h2 (line 84) | async fn test_tls_handshake_alpn_h1_and_h2() {
  function test_tls_cipher_suites_secure (line 91) | async fn test_tls_cipher_suites_secure() {
  function test_tls_cipher_suites_insecure (line 112) | async fn test_tls_cipher_suites_insecure() {
  function test_tls_key_log (line 146) | async fn test_tls_key_log() {
  function test_tls_handshake_wrong_server_name (line 199) | async fn test_tls_handshake_wrong_server_name() {
  function test_tls_validate_authority (line 242) | async fn test_tls_validate_authority() {
  function test_mtls_handshake_no_identity (line 300) | async fn test_mtls_handshake_no_identity() {
  function test_mtls_handshake_with_identitiy (line 347) | async fn test_mtls_handshake_with_identitiy() {
  function check_client_resumption_disabled (line 390) | async fn check_client_resumption_disabled(
  function test_tls_resumption_disabled_tls13 (line 461) | async fn test_tls_resumption_disabled_tls13() {
  function test_tls_resumption_disabled_tls12 (line 466) | async fn test_tls_resumption_disabled_tls12() {
  function load_identity (line 470) | fn load_identity(cert_file: &str, key_file: &str) -> Identity {
  function mtls_server_config (line 476) | fn mtls_server_config() -> ServerConfig {
  function test_certs_path (line 500) | fn test_certs_path() -> PathBuf {
  function load_certs (line 507) | fn load_certs(filename: &str) -> Vec<CertificateDer<'static>> {
  function load_private_key (line 516) | fn load_private_key(filename: &str) -> PrivateKeyDer<'static> {
  function load_root_certs (line 531) | fn load_root_certs(filename: &str) -> RootCertificates {
  function default_server_config (line 537) | fn default_server_config() -> ServerConfig {
  function setup_server (line 548) | async fn setup_server(config: ServerConfig) -> (SocketAddr, JoinHandle<(...
  function setup_server_multi_connection (line 552) | async fn setup_server_multi_connection(
  function run_handshake_test (line 580) | async fn run_handshake_test(server_alpn: Vec<Vec<u8>>, expect_success: b...

FILE: grpc/src/credentials/rustls/key_log.rs
  type KeyLogFileInner (line 29) | struct KeyLogFileInner {
    method new (line 35) | fn new(path: &PathBuf) -> Self {
    method try_write (line 50) | fn try_write(&mut self, label: &str, client_random: &[u8], secret: &[u...
  method fmt (line 70) | fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
  type KeyLogFile (line 83) | pub struct KeyLogFile(Mutex<KeyLogFileInner>);
    method new (line 88) | pub fn new(path: &PathBuf) -> Self {
  method log (line 94) | fn log(&self, label: &str, client_random: &[u8], secret: &[u8]) {
  method fmt (line 110) | fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {

FILE: grpc/src/credentials/rustls/mod.rs
  constant ALPN_PROTO_STR_H2 (line 39) | const ALPN_PROTO_STR_H2: &[u8; 2] = b"h2";
  type RootCertificates (line 43) | pub struct RootCertificates {
    method from_pem (line 51) | pub fn from_pem(pem: impl AsRef<[u8]>) -> Self {
    method get_ref (line 57) | fn get_ref(&self) -> &[u8] {
  type Identity (line 64) | pub struct Identity {
    method from_pem (line 75) | pub fn from_pem(cert: impl AsRef<[u8]>, key: impl AsRef<[u8]>) -> Self {
  type IdentityList (line 69) | pub type IdentityList = Vec<Identity>;
  type ProviderInternal (line 90) | pub trait ProviderInternal<T> {
    method get_receiver (line 95) | fn get_receiver(self) -> Receiver<T>;
  type Provider (line 111) | pub trait Provider<T>: provider::ProviderInternal<T> {}
  type StaticProvider (line 114) | pub struct StaticProvider<T> {
  function new (line 120) | pub fn new(value: T) -> Self {
  function get_receiver (line 126) | fn get_receiver(self) -> watch::Receiver<T> {
  type StaticRootCertificatesProvider (line 137) | pub type StaticRootCertificatesProvider = StaticProvider<RootCertificates>;
  type StaticIdentityProvider (line 138) | pub type StaticIdentityProvider = StaticProvider<Identity>;
  function sanitize_crypto_provider (line 144) | fn sanitize_crypto_provider(mut crypto_provider: CryptoProvider) -> Resu...
  function parse_certs (line 167) | fn parse_certs(pem: &[u8]) -> Result<Vec<CertificateDer<'static>>, Strin...
  function parse_key (line 174) | fn parse_key(pem: &[u8]) -> Result<PrivateKeyDer<'static>, String> {

FILE: grpc/src/credentials/rustls/server/mod.rs
  type SniResolver (line 64) | struct SniResolver {
  method resolve (line 69) | fn resolve(&self, client_hello: ClientHello) -> Option<Arc<CertifiedKey>> {
  type TlsClientCertificateRequestType (line 99) | pub enum TlsClientCertificateRequestType<R = StaticRootCertificatesProvi...
  type InnerClientCertificateRequestType (line 133) | enum InnerClientCertificateRequestType {
    method from (line 144) | fn from(value: TlsClientCertificateRequestType) -> Self {
  type RustlsServerTlsCredendials (line 164) | pub struct RustlsServerTlsCredendials {
    method new (line 209) | pub fn new(config: ServerTlsConfig) -> Result<RustlsServerTlsCredendia...
    method new_impl (line 222) | fn new_impl(
  type ServerTlsConfig (line 169) | pub struct ServerTlsConfig {
    method new (line 176) | pub fn new<I>(identities_provider: I) -> Self
    method with_request_type (line 191) | pub fn with_request_type(mut self, request_type: TlsClientCertificateR...
    method insecure_with_key_log_path (line 202) | pub fn insecure_with_key_log_path(mut self, path: impl Into<PathBuf>) ...
  type NoTicketer (line 306) | struct NoTicketer;
  method enabled (line 309) | fn enabled(&self) -> bool {
  method lifetime (line 312) | fn lifetime(&self) -> u32 {
  method encrypt (line 315) | fn encrypt(&self, _plain: &[u8]) -> Option<Vec<u8>> {
  method decrypt (line 318) | fn decrypt(&self, _cipher: &[u8]) -> Option<Vec<u8>> {
  type Output (line 324) | type Output<Input> = TlsStream<Input>;
  method accept (line 326) | async fn accept<Input: GrpcEndpoint>(
  method info (line 356) | fn info(&self) -> &ProtocolInfo {

FILE: grpc/src/credentials/rustls/server/test.rs
  function init_provider (line 51) | fn init_provider() {
  function test_tls_server_handshake (line 58) | async fn test_tls_server_handshake() {
  function test_tls_server_handshake_no_alpn (line 117) | async fn test_tls_server_handshake_no_alpn() {
  function test_tls_server_handshake_bad_alpn (line 161) | async fn test_tls_server_handshake_bad_alpn() {
  function test_tls_handshake_alpn_h1_and_h2 (line 200) | async fn test_tls_handshake_alpn_h1_and_h2() {
  function test_tls_server_mtls_require_fail (line 238) | async fn test_tls_server_mtls_require_fail() {
  function test_tls_server_mtls_success (line 291) | async fn test_tls_server_mtls_success() {
  function test_tls_server_mtls_optional (line 353) | async fn test_tls_server_mtls_optional() {
  function test_tls_server_key_log (line 411) | async fn test_tls_server_key_log() {
  function check_resumption_disabled (line 469) | async fn check_resumption_disabled(versions: Vec<&'static rustls::Suppor...
  function test_tls_server_resumption_disabled_tls13 (line 532) | async fn test_tls_server_resumption_disabled_tls13() {
  function test_tls_server_resumption_disabled_tls12 (line 537) | async fn test_tls_server_resumption_disabled_tls12() {
  function test_tls_server_sni (line 542) | async fn test_tls_server_sni() {
  function test_tls_server_cipher_suites_insecure (line 636) | async fn test_tls_server_cipher_suites_insecure() {
  function create_root_store (line 669) | fn create_root_store() -> rustls::RootCertStore {
  function test_certs_path (line 678) | fn test_certs_path() -> PathBuf {
  function load_certs (line 685) | fn load_certs(filename: &str) -> Vec<rustls_pki_types::CertificateDer<'s...
  function load_private_key (line 694) | fn load_private_key(filename: &str) -> rustls_pki_types::PrivateKeyDer<'...
  function load_root_certs (line 709) | fn load_root_certs(filename: &str) -> RootCertificates {
  function load_identity (line 715) | fn load_identity(cert_file: &str, key_file: &str) -> Identity {

FILE: grpc/src/credentials/rustls/tls_stream.rs
  type TlsStream (line 38) | pub struct TlsStream<T> {
  method poll_read (line 46) | fn poll_read(
  method poll_write (line 60) | fn poll_write(
  method poll_flush (line 69) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 74) | fn poll_shutdown(
  method poll_write_vectored (line 82) | fn poll_write_vectored(
  method is_write_vectored (line 91) | fn is_write_vectored(&self) -> bool {
  method get_local_address (line 102) | fn get_local_address(&self) -> &str {
  method get_peer_address (line 109) | fn get_peer_address(&self) -> &str {
  method get_network_type (line 116) | fn get_network_type(&self) -> &'static str {
  function new (line 125) | pub fn new(inner: RustlsStream<T>) -> Self {
  function inner (line 129) | pub fn inner(&self) -> &RustlsStream<T> {

FILE: grpc/src/credentials/server.rs
  type ServerCredsInternal (line 31) | pub trait ServerCredsInternal {
    method accept (line 42) | async fn accept<Input: GrpcEndpoint>(
  type HandshakeOutput (line 49) | pub struct HandshakeOutput<T> {
  type ServerConnectionSecurityInfo (line 55) | pub struct ServerConnectionSecurityInfo {
    method new (line 64) | pub fn new(
    method security_protocol (line 77) | pub fn security_protocol(&self) -> &'static str {
    method security_level (line 82) | pub fn security_level(&self) -> SecurityLevel {
    method attributes (line 87) | pub fn attributes(&self) -> &Attributes {

FILE: grpc/src/generated/echo_fds.rs
  constant FILE_DESCRIPTOR_SET (line 20) | pub const FILE_DESCRIPTOR_SET: &[u8] = &[

FILE: grpc/src/generated/grpc_examples_echo.rs
  type EchoRequest (line 4) | pub struct EchoRequest {
  type EchoResponse (line 10) | pub struct EchoResponse {
  type EchoClient (line 27) | pub struct EchoClient<T> {
  function new (line 37) | pub fn new(inner: T) -> Self {
  function with_origin (line 41) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function with_interceptor (line 45) | pub fn with_interceptor<F>(
  function send_compressed (line 69) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 75) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 83) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 91) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function unary_echo (line 96) | pub async fn unary_echo(
  function server_streaming_echo (line 118) | pub async fn server_streaming_echo(
  function client_streaming_echo (line 145) | pub async fn client_streaming_echo(
  function bidirectional_streaming_echo (line 169) | pub async fn bidirectional_streaming_echo(
  type Echo (line 212) | pub trait Echo: std::marker::Send + std::marker::Sync + 'static {
    method unary_echo (line 214) | async fn unary_echo(
    method server_streaming_echo (line 225) | async fn server_streaming_echo(
    method client_streaming_echo (line 233) | async fn client_streaming_echo(
    method bidirectional_streaming_echo (line 244) | async fn bidirectional_streaming_echo(
  type EchoServer (line 254) | pub struct EchoServer<T> {
  function new (line 262) | pub fn new(inner: T) -> Self {
  function from_arc (line 265) | pub fn from_arc(inner: Arc<T>) -> Self {
  function with_interceptor (line 274) | pub fn with_interceptor<F>(
  function accept_compressed (line 285) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 291) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 299) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 307) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  type Response (line 318) | type Response = http::Response<tonic::body::Body>;
  type Error (line 319) | type Error = std::convert::Infallible;
  type Future (line 320) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 321) | fn poll_ready(
  function call (line 327) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  method clone (line 531) | fn clone(&self) -> Self {
  constant SERVICE_NAME (line 543) | pub const SERVICE_NAME: &str = "grpc.examples.echo.Echo";
  constant NAME (line 545) | const NAME: &'static str = SERVICE_NAME;

FILE: grpc/src/inmemory/mod.rs
  type InMemoryServerCall (line 77) | struct InMemoryServerCall {
  type InMemoryRequestStreamItem (line 83) | enum InMemoryRequestStreamItem {
  type InMemoryResponseStreamItem (line 88) | enum InMemoryResponseStreamItem {
  type InMemoryListener (line 96) | pub struct InMemoryListener {
    method new (line 120) | pub fn new() -> Self {
    method id (line 135) | pub fn id(&self) -> String {
    method close (line 139) | pub async fn close(self) {
    method await_connection (line 159) | pub async fn await_connection(&self) {}
  type InMemoryListenerInner (line 100) | struct InMemoryListenerInner {
  method drop (line 108) | fn drop(&mut self) {
  method default (line 114) | fn default() -> Self {
  type SendStream (line 163) | type SendStream = InMemoryServerSendStream;
  type RecvStream (line 164) | type RecvStream = InMemoryServerRecvStream;
  method accept (line 166) | async fn accept(&self) -> Option<ServerCall<Self::SendStream, Self::Recv...
  type InMemoryServerSendStream (line 184) | pub struct InMemoryServerSendStream {
  method send (line 189) | async fn send<'a>(
  type InMemoryServerRecvStream (line 208) | pub struct InMemoryServerRecvStream {
  method next (line 213) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> Result<(), ()> {
  type InMemoryConnection (line 223) | pub struct InMemoryConnection {
  type SendStream (line 229) | type SendStream = Box<dyn ClientDynSendStream>;
  type RecvStream (line 230) | type RecvStream = Box<dyn ClientDynRecvStream>;
  method invoke (line 232) | async fn invoke(
  method drop (line 255) | fn drop(&mut self) {
  type InMemoryClientSendStream (line 260) | pub struct InMemoryClientSendStream {
  method send (line 265) | async fn send(&mut self, msg: &dyn SendMessage, _options: ClientSendOpti...
  method drop (line 283) | fn drop(&mut self) {
  type InMemoryClientRecvStream (line 290) | pub struct InMemoryClientRecvStream {
  method next (line 295) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> ClientResponseStr...
  type InMemoryTransport (line 308) | pub struct InMemoryTransport {}
  type Service (line 311) | type Service = InMemoryConnection;
  method connect (line 313) | async fn connect(
  type InMemoryResolverBuilder (line 334) | pub struct InMemoryResolverBuilder {}
  method build (line 337) | fn build(&self, target: &Target, options: ResolverOptions) -> Box<dyn Re...
  method scheme (line 344) | fn scheme(&self) -> &str {
  method is_valid_uri (line 348) | fn is_valid_uri(&self, _uri: &Target) -> bool {
  type InMemoryResolver (line 353) | struct InMemoryResolver {
  method resolve_now (line 358) | fn resolve_now(&mut self) {}
  method work (line 360) | fn work(&mut self, channel_controller: &mut dyn ResolverChannelControlle...
  function reg (line 386) | pub fn reg() {

FILE: grpc/src/rt/hyper_wrapper.rs
  type HyperCompatExec (line 44) | pub(crate) struct HyperCompatExec {
    method execute (line 53) | fn execute(&self, fut: F) {
  type HyperCompatSleep (line 60) | struct HyperCompatSleep {
  type Output (line 65) | type Output = ();
  method poll (line 67) | fn poll(
  type HyperCompatTimer (line 78) | pub(crate) struct HyperCompatTimer {
  method sleep (line 83) | fn sleep(&self, duration: std::time::Duration) -> Pin<Box<dyn hyper::rt:...
  method sleep_until (line 88) | fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn hyper::rt::Sleep...
  method new (line 109) | pub fn new(stream: Box<dyn GrpcEndpoint>) -> Self {
  method poll_read (line 115) | fn poll_read(
  method poll_write (line 126) | fn poll_write(
  method poll_flush (line 134) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 138) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_read (line 144) | fn poll_read(
  method poll_write (line 165) | fn poll_write(
  method poll_flush (line 173) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 177) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method is_write_vectored (line 181) | fn is_write_vectored(&self) -> bool {
  method poll_write_vectored (line 185) | fn poll_write_vectored(

FILE: grpc/src/rt/mod.rs
  type BoxFuture (line 36) | pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
  type BoxedTaskHandle (line 37) | pub type BoxedTaskHandle = Box<dyn TaskHandle>;
  type BoxEndpoint (line 38) | pub type BoxEndpoint = Box<dyn GrpcEndpoint>;
  type ScopedBoxFuture (line 39) | pub type ScopedBoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send ...
  type Runtime (line 48) | pub trait Runtime: Send + Sync + Debug {
    method spawn (line 50) | fn spawn(&self, task: Pin<Box<dyn Future<Output = ()> + Send + 'static...
    method get_dns_resolver (line 55) | fn get_dns_resolver(&self, opts: ResolverOptions) -> Result<Box<dyn Dn...
    method sleep (line 58) | fn sleep(&self, duration: std::time::Duration) -> Pin<Box<dyn Sleep>>;
    method tcp_stream (line 62) | fn tcp_stream(
    method listen_tcp (line 69) | fn listen_tcp(
    method spawn (line 167) | fn spawn(&self, task: Pin<Box<dyn Future<Output = ()> + Send + 'static...
    method get_dns_resolver (line 171) | fn get_dns_resolver(&self, opts: ResolverOptions) -> Result<Box<dyn Dn...
    method sleep (line 175) | fn sleep(&self, duration: std::time::Duration) -> Pin<Box<dyn Sleep>> {
    method tcp_stream (line 179) | fn tcp_stream(
    method listen_tcp (line 187) | fn listen_tcp(
  type Sleep (line 77) | pub trait Sleep: Send + Sync + Future<Output = ()> {}
  type TaskHandle (line 79) | pub trait TaskHandle: Send + Sync {
    method abort (line 81) | fn abort(&self);
  type DnsResolver (line 86) | pub trait DnsResolver: Send + Sync {
    method lookup_host_name (line 88) | async fn lookup_host_name(&self, name: &str) -> Result<Vec<std::net::I...
    method lookup_txt (line 91) | async fn lookup_txt(&self, name: &str) -> Result<Vec<String>, String>;
  type ResolverOptions (line 95) | pub struct ResolverOptions {
  type TcpOptions (line 102) | pub struct TcpOptions {
  type Sealed (line 115) | pub trait Sealed: tokio::io::AsyncRead + tokio::io::AsyncWrite {}
  type GrpcEndpoint (line 119) | pub trait GrpcEndpoint: endpoint::Sealed + Send + Unpin + 'static {
    method get_local_address (line 121) | fn get_local_address(&self) -> &str;
    method get_peer_address (line 124) | fn get_peer_address(&self) -> &str;
    method get_network_type (line 126) | fn get_network_type(&self) -> &'static str;
    method get_local_address (line 131) | fn get_local_address(&self) -> &str {
    method get_peer_address (line 135) | fn get_peer_address(&self) -> &str {
    method get_network_type (line 139) | fn get_network_type(&self) -> &'static str {
  type TcpListener (line 146) | pub trait TcpListener: Send + Sync {
    method accept (line 152) | fn accept(&mut self) -> ScopedBoxFuture<'_, Result<(BoxEndpoint, Socke...
    method local_addr (line 155) | fn local_addr(&self) -> &SocketAddr;
  type NoOpRuntime (line 164) | pub(crate) struct NoOpRuntime {}
  function default_runtime (line 196) | pub(crate) fn default_runtime() -> GrpcRuntime {
  type GrpcRuntime (line 206) | pub struct GrpcRuntime {
    method new (line 211) | pub fn new<T: Runtime + 'static>(runtime: T) -> Self {
    method spawn (line 217) | pub fn spawn(
    method get_dns_resolver (line 224) | pub fn get_dns_resolver(&self, opts: ResolverOptions) -> Result<Box<dy...
    method sleep (line 228) | pub fn sleep(&self, duration: std::time::Duration) -> Pin<Box<dyn Slee...
    method tcp_stream (line 232) | pub fn tcp_stream(
    method listen_tcp (line 240) | pub fn listen_tcp(

FILE: grpc/src/rt/tokio/hickory_resolver.rs
  type DnsResolver (line 40) | pub(super) struct DnsResolver {
    method lookup_host_name (line 46) | async fn lookup_host_name(&self, name: &str) -> Result<Vec<IpAddr>, St...
    method lookup_txt (line 55) | async fn lookup_txt(&self, name: &str) -> Result<Vec<String>, String> {
    method new (line 75) | pub(super) fn new(opts: ResolverOptions) -> Result<Self, String> {
  function compare_hickory_and_default (line 121) | async fn compare_hickory_and_default() {
  function resolve_txt (line 143) | async fn resolve_txt() {
  function custom_authority (line 180) | async fn custom_authority() {
  type FakeDns (line 196) | struct FakeDns {
    method shutdown (line 203) | async fn shutdown(mut self) {
  function start_in_memory_dns_server (line 215) | async fn start_in_memory_dns_server(host: &str, records: Vec<Record>) ->...

FILE: grpc/src/rt/tokio/mod.rs
  type TokioDefaultDnsResolver (line 55) | struct TokioDefaultDnsResolver {
    method new (line 162) | pub fn new(opts: ResolverOptions) -> Result<Self, String> {
  method lookup_host_name (line 61) | async fn lookup_host_name(&self, name: &str) -> Result<Vec<IpAddr>, Stri...
  method lookup_txt (line 74) | async fn lookup_txt(&self, _name: &str) -> Result<Vec<String>, String> {
  type TokioRuntime (line 80) | pub(crate) struct TokioRuntime {
  method abort (line 85) | fn abort(&self) {
  method spawn (line 93) | fn spawn(&self, task: Pin<Box<dyn Future<Output = ()> + Send + 'static>>...
  method get_dns_resolver (line 97) | fn get_dns_resolver(&self, opts: ResolverOptions) -> Result<Box<dyn DnsR...
  method sleep (line 108) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
  method tcp_stream (line 112) | fn tcp_stream(
  method listen_tcp (line 142) | fn listen_tcp(
  type TokioTcpStream (line 170) | struct TokioTcpStream {
    method get_local_address (line 225) | fn get_local_address(&self) -> &str {
    method get_peer_address (line 229) | fn get_peer_address(&self) -> &str {
    method get_network_type (line 233) | fn get_network_type(&self) -> &'static str {
  method poll_read (line 177) | fn poll_read(
  method poll_write (line 187) | fn poll_write(
  method poll_write_vectored (line 195) | fn poll_write_vectored(
  method is_write_vectored (line 203) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 207) | fn poll_flush(
  method poll_shutdown (line 214) | fn poll_shutdown(
  type TokioListener (line 238) | struct TokioListener {
    method accept (line 244) | fn accept(&mut self) -> ScopedBoxFuture<'_, Result<(BoxEndpoint, Socke...
    method local_addr (line 262) | fn local_addr(&self) -> &SocketAddr {
  function lookup_hostname (line 276) | async fn lookup_hostname() {
  function default_resolver_txt_fails (line 290) | async fn default_resolver_txt_fails() {
  function default_resolver_custom_authority (line 298) | async fn default_resolver_custom_authority() {

FILE: grpc/src/send_future.rs
  type SendFuture (line 67) | pub trait SendFuture: Future {
    method make_send (line 74) | fn make_send(self) -> impl Future<Output = Self::Output> + Send

FILE: grpc/src/server/mod.rs
  type Server (line 33) | pub struct Server {
    method new (line 51) | pub fn new() -> Self {
    method set_handler (line 55) | pub fn set_handler<H>(&mut self, h: H)
    method serve (line 62) | pub async fn serve(&self, l: &impl Listener) {
  type Call (line 37) | pub struct Call<SS, RS> {
  type Listener (line 44) | pub trait Listener {
    method accept (line 47) | async fn accept(&self) -> Option<Call<Self::SendStream, Self::RecvStre...
  method default (line 76) | fn default() -> Self {
  type Handle (line 84) | pub trait Handle: Send + Sync {
    method handle (line 88) | async fn handle(
  type DynHandle (line 97) | trait DynHandle: Send + Sync {
    method dyn_handle (line 98) | async fn dyn_handle(
    method dyn_handle (line 108) | async fn dyn_handle(
  type SendStream (line 122) | pub trait SendStream {
    method send (line 130) | async fn send<'a>(
    method send (line 158) | async fn send<'a>(
    method send (line 168) | async fn send<'a>(
  type DynSendStream (line 138) | trait DynSendStream: Send {
    method dyn_send (line 139) | async fn dyn_send<'a>(
    method dyn_send (line 148) | async fn dyn_send<'a>(
  type SendOptions (line 180) | pub struct SendOptions {
  type RecvStream (line 190) | pub trait RecvStream {
    method next (line 199) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> Result<(), ()>;
    method next (line 215) | async fn next(&mut self, msg: &mut dyn RecvMessage) -> Result<(), ()> {
  type DynRecvStream (line 203) | trait DynRecvStream: Send {
    method dyn_next (line 204) | async fn dyn_next(&mut self, msg: &mut dyn RecvMessage) -> Result<(), ...
    method dyn_next (line 209) | async fn dyn_next(&mut self, msg: &mut dyn RecvMessage) -> Result<(), ...

FILE: grpc/src/status.rs
  type Status (line 33) | pub struct Status {
    method new (line 40) | pub fn new(code: StatusCode, message: impl Into<String>) -> Self {
    method code (line 48) | pub fn code(&self) -> StatusCode {
    method message (line 53) | pub fn message(&self) -> &str {
  function test_status_new (line 63) | fn test_status_new() {
  function test_status_debug (line 70) | fn test_status_debug() {

FILE: grpc/src/status/server_status.rs
  type ServerStatus (line 33) | pub struct ServerStatus(Status);
    type Target (line 36) | type Target = Status;
    method deref (line 38) | fn deref(&self) -> &Self::Target {
    method new (line 45) | pub fn new(code: StatusCode, message: impl Into<String>) -> Self {
    method from_status (line 50) | pub fn from_status(status: Status) -> Self {
    method into_status (line 55) | pub(crate) fn into_status(self) -> Status {
  function test_server_status_new (line 65) | fn test_server_status_new() {
  function test_server_status_deref (line 72) | fn test_server_status_deref() {
  function test_server_status_from_status (line 78) | fn test_server_status_from_status() {
  function test_server_status_into_status (line 85) | fn test_server_status_into_status() {

FILE: grpc/src/status/status_code.rs
  type StatusCode (line 28) | pub enum StatusCode {
    method from (line 49) | fn from(i: i32) -> Self {

FILE: interop/build.rs
  function main (line 1) | fn main() {

FILE: interop/src/bin/client.rs
  type Opts (line 8) | struct Opts {
    method parse (line 33) | fn parse() -> Result<Self, pico_args::Error> {
  type Codec (line 15) | enum Codec {
  type Err (line 21) | type Err = String;
  method from_str (line 23) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function main (line 46) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  type Testcase (line 134) | enum Testcase {

FILE: interop/src/bin/server.rs
  type Opts (line 7) | struct Opts {
    method parse (line 31) | fn parse() -> Result<Self, pico_args::Error> {
  type Codec (line 13) | enum Codec {
  type Err (line 19) | type Err = String;
  method from_str (line 21) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function main (line 41) | async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {

FILE: interop/src/client.rs
  type InteropTest (line 5) | pub trait InteropTest: Send {
    method empty_unary (line 6) | async fn empty_unary(&mut self, assertions: &mut Vec<TestAssertion>);
    method large_unary (line 8) | async fn large_unary(&mut self, assertions: &mut Vec<TestAssertion>);
    method client_streaming (line 10) | async fn client_streaming(&mut self, assertions: &mut Vec<TestAssertio...
    method server_streaming (line 12) | async fn server_streaming(&mut self, assertions: &mut Vec<TestAssertio...
    method ping_pong (line 14) | async fn ping_pong(&mut self, assertions: &mut Vec<TestAssertion>);
    method empty_stream (line 16) | async fn empty_stream(&mut self, assertions: &mut Vec<TestAssertion>);
    method status_code_and_message (line 18) | async fn status_code_and_message(&mut self, assertions: &mut Vec<TestA...
    method special_status_message (line 20) | async fn special_status_message(&mut self, assertions: &mut Vec<TestAs...
    method unimplemented_method (line 22) | async fn unimplemented_method(&mut self, assertions: &mut Vec<TestAsse...
    method custom_metadata (line 24) | async fn custom_metadata(&mut self, assertions: &mut Vec<TestAssertion>);
  type InteropTestUnimplemented (line 28) | pub trait InteropTestUnimplemented: Send {
    method unimplemented_service (line 29) | async fn unimplemented_service(&mut self, assertions: &mut Vec<TestAss...

FILE: interop/src/client_prost.rs
  type TestClient (line 12) | pub type TestClient = TestServiceClient<Channel>;
  type UnimplementedClient (line 13) | pub type UnimplementedClient = UnimplementedServiceClient<Channel>;
  constant LARGE_REQ_SIZE (line 15) | const LARGE_REQ_SIZE: usize = 271_828;
  constant LARGE_RSP_SIZE (line 16) | const LARGE_RSP_SIZE: i32 = 314_159;
  constant REQUEST_LENGTHS (line 17) | const REQUEST_LENGTHS: &[i32] = &[27182, 8, 1828, 45904];
  constant RESPONSE_LENGTHS (line 18) | const RESPONSE_LENGTHS: &[i32] = &[31415, 9, 2653, 58979];
  constant TEST_STATUS_MESSAGE (line 19) | const TEST_STATUS_MESSAGE: &str = "test status message";
  constant SPECIAL_TEST_STATUS_MESSAGE (line 20) | const SPECIAL_TEST_STATUS_MESSAGE: &str =
  method empty_unary (line 25) | async fn empty_unary(&mut self, assertions: &mut Vec<TestAssertion>) {
  method large_unary (line 44) | async fn large_unary(&mut self, assertions: &mut Vec<TestAssertion>) {
  method client_streaming (line 88) | async fn client_streaming(&mut self, assertions: &mut Vec<TestAssertion>) {
  method server_streaming (line 115) | async fn server_streaming(&mut self, assertions: &mut Vec<TestAssertion>) {
  method ping_pong (line 157) | async fn ping_pong(&mut self, assertions: &mut Vec<TestAssertion>) {
  method empty_stream (line 213) | async fn empty_stream(&mut self, assertions: &mut Vec<TestAssertion>) {
  method status_code_and_message (line 234) | async fn status_code_and_message(&mut self, assertions: &mut Vec<TestAss...
  method special_status_message (line 290) | async fn special_status_message(&mut self, assertions: &mut Vec<TestAsse...
  method unimplemented_method (line 320) | async fn unimplemented_method(&mut self, assertions: &mut Vec<TestAssert...
  method custom_metadata (line 332) | async fn custom_metadata(&mut self, assertions: &mut Vec<TestAssertion>) {
  method unimplemented_service (line 391) | async fn unimplemented_service(&mut self, assertions: &mut Vec<TestAsser...
  function make_ping_pong_request (line 404) | fn make_ping_pong_request(idx: usize) -> StreamingOutputCallRequest {
  function make_streaming_input_request (line 414) | fn make_streaming_input_request(len: &i32) -> StreamingInputCallRequest {

FILE: interop/src/client_protobuf.rs
  type TestClient (line 38) | pub type TestClient = TestServiceClient<Channel>;
  type UnimplementedClient (line 39) | pub type UnimplementedClient = UnimplementedServiceClient<Channel>;
  constant LARGE_REQ_SIZE (line 41) | const LARGE_REQ_SIZE: usize = 271_828;
  constant LARGE_RSP_SIZE (line 42) | const LARGE_RSP_SIZE: i32 = 314_159;
  constant REQUEST_LENGTHS (line 43) | const REQUEST_LENGTHS: &[i32] = &[27182, 8, 1828, 45904];
  constant RESPONSE_LENGTHS (line 44) | const RESPONSE_LENGTHS: &[i32] = &[31415, 9, 2653, 58979];
  constant TEST_STATUS_MESSAGE (line 45) | const TEST_STATUS_MESSAGE: &str = "test status message";
  constant SPECIAL_TEST_STATUS_MESSAGE (line 46) | const SPECIAL_TEST_STATUS_MESSAGE: &str =
  method empty_unary (line 51) | async fn empty_unary(&mut self, assertions: &mut Vec<TestAssertion>) {
  method large_unary (line 70) | async fn large_unary(&mut self, assertions: &mut Vec<TestAssertion>) {
  method client_streaming (line 99) | async fn client_streaming(&mut self, assertions: &mut Vec<TestAssertion>) {
  method server_streaming (line 129) | async fn server_streaming(&mut self, assertions: &mut Vec<TestAssertion>) {
  method ping_pong (line 169) | async fn ping_pong(&mut self, assertions: &mut Vec<TestAssertion>) {
  method empty_stream (line 225) | async fn empty_stream(&mut self, assertions: &mut Vec<TestAssertion>) {
  method status_code_and_message (line 246) | async fn status_code_and_message(&mut self, assertions: &mut Vec<TestAss...
  method special_status_message (line 300) | async fn special_status_message(&mut self, assertions: &mut Vec<TestAsse...
  method unimplemented_method (line 329) | async fn unimplemented_method(&mut self, assertions: &mut Vec<TestAssert...
  method custom_metadata (line 343) | async fn custom_metadata(&mut self, assertions: &mut Vec<TestAssertion>) {
  method unimplemented_service (line 401) | async fn unimplemented_service(&mut self, assertions: &mut Vec<TestAsser...
  function make_ping_pong_request (line 416) | fn make_ping_pong_request(idx: usize) -> StreamingOutputCallRequest {
  function make_streaming_input_request (line 425) | fn make_streaming_input_request(len: &i32) -> StreamingInputCallRequest {

FILE: interop/src/lib.rs
  function trace_init (line 28) | pub fn trace_init() {
  function client_payload (line 32) | pub fn client_payload(size: usize) -> pb::Payload {
  function server_payload (line 39) | pub fn server_payload(size: usize) -> pb::Payload {
  function with_size (line 47) | fn with_size(size: i32) -> Self {
  function response_length (line 55) | fn response_length(response: &pb::StreamingOutputCallResponse) -> i32 {
  function response_lengths (line 62) | fn response_lengths(responses: &[pb::StreamingOutputCallResponse]) -> Ve...
  function client_payload (line 71) | pub(crate) fn client_payload(size: usize) -> grpc_pb::Payload {
  function with_size (line 78) | pub(crate) fn with_size(size: i32) -> Self {
  function response_length (line 83) | pub(crate) fn response_length(response: &grpc_pb::StreamingOutputCallRes...
  function response_lengths (line 87) | pub(crate) fn response_lengths(responses: &[grpc_pb::StreamingOutputCall...
  function server_payload (line 91) | pub(crate) fn server_payload(size: usize) -> grpc_pb::Payload {
  type TestAssertion (line 99) | pub enum TestAssertion {
    method is_failed (line 111) | pub fn is_failed(&self) -> bool {
    method fmt (line 117) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: interop/src/server_prost.rs
  type TestService (line 18) | pub struct TestService {}
    method empty_call (line 27) | async fn empty_call(&self, _request: Request<Empty>) -> Result<Empty> {
    method unary_call (line 31) | async fn unary_call(&self, request: Request<SimpleRequest>) -> Result<...
    method cacheable_unary_call (line 57) | async fn cacheable_unary_call(&self, _: Request<SimpleRequest>) -> Res...
    type StreamingOutputCallStream (line 61) | type StreamingOutputCallStream = Stream<StreamingOutputCallResponse>;
    method streaming_output_call (line 63) | async fn streaming_output_call(
    method streaming_input_call (line 86) | async fn streaming_input_call(
    type FullDuplexCallStream (line 104) | type FullDuplexCallStream = Stream<StreamingOutputCallResponse>;
    method full_duplex_call (line 106) | async fn full_duplex_call(
    type HalfDuplexCallStream (line 144) | type HalfDuplexCallStream = Stream<StreamingOutputCallResponse>;
    method half_duplex_call (line 146) | async fn half_duplex_call(
    method unimplemented_call (line 153) | async fn unimplemented_call(&self, _: Request<Empty>) -> Result<Empty> {
  type Result (line 20) | type Result<T> = StdResult<Response<T>, Status>;
  type Streaming (line 21) | type Streaming<T> = Request<tonic::Streaming<T>>;
  type Stream (line 22) | type Stream<T> = Pin<Box<dyn tokio_stream::Stream<Item = StdResult<T, St...
  type BoxFuture (line 23) | type BoxFuture<T, E> = Pin<Box<dyn Future<Output = StdResult<T, E>> + Se...
  type UnimplementedService (line 159) | pub struct UnimplementedService {}
    method unimplemented_call (line 163) | async fn unimplemented_call(&self, _req: Request<Empty>) -> Result<Emp...
  type EchoHeadersSvc (line 169) | pub struct EchoHeadersSvc<S> {
  constant NAME (line 174) | const NAME: &'static str = S::NAME;
  function new (line 178) | pub fn new(inner: S) -> Self {
  type Response (line 188) | type Response = S::Response;
  type Error (line 189) | type Error = S::Error;
  type Future (line 190) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 192) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<StdResult<(), Se...
  function call (line 196) | fn call(&mut self, req: http::Request<Body>) -> Self::Future {

FILE: interop/src/server_protobuf.rs
  type TestService (line 20) | pub struct TestService {}
    method empty_call (line 28) | async fn empty_call(&self, _request: Request<Empty>) -> Result<Empty> {
    method unary_call (line 32) | async fn unary_call(&self, request: Request<SimpleRequest>) -> Result<...
    method cacheable_unary_call (line 60) | async fn cacheable_unary_call(&self, _: Request<SimpleRequest>) -> Res...
    method streaming_output_call (line 64) | async fn streaming_output_call(
    method streaming_input_call (line 81) | async fn streaming_input_call(
    method full_duplex_call (line 99) | async fn full_duplex_call(
    method half_duplex_call (line 143) | async fn half_duplex_call(
    method unimplemented_call (line 151) | async fn unimplemented_call(&self, _: Request<Empty>) -> Result<Empty> {
  type Result (line 22) | type Result<T> = StdResult<Response<T>, Status>;
  type Streaming (line 23) | type Streaming<T> = Request<tonic::Streaming<T>>;
  type BoxFuture (line 24) | type BoxFuture<T, E> = Pin<Box<dyn Future<Output = StdResult<T, E>> + Se...
  type UnimplementedService (line 157) | pub struct UnimplementedService {}
    method unimplemented_call (line 161) | async fn unimplemented_call(&self, _req: Request<Empty>) -> Result<Emp...
  type EchoHeadersSvc (line 167) | pub struct EchoHeadersSvc<S> {
  constant NAME (line 172) | const NAME: &'static str = S::NAME;
  function new (line 176) | pub fn new(inner: S) -> Self {
  type Response (line 186) | type Response = S::Response;
  type Error (line 187) | type Error = S::Error;
  type Future (line 188) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 190) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<StdResult<(), Se...
  function call (line 194) | fn call(&mut self, req: http::Request<Body>) -> Self::Future {

FILE: protoc-gen-rust-grpc/src/grpc_rust_generator.cc
  type rust_grpc_generator (line 34) | namespace rust_grpc_generator {
    function GrpcGetCommentsForDescriptor (line 47) | std::string GrpcGetCommentsForDescriptor(const DescriptorType *descrip...
    function RustModuleForContainingType (line 56) | std::string RustModuleForContainingType(const GrpcOpts &opts,
    function RsTypePathWithinMessageModule (line 87) | std::string RsTypePathWithinMessageModule(const GrpcOpts &opts,
    function RsTypePath (line 94) | std::string RsTypePath(const Descriptor &msg, const GrpcOpts &opts, in...
    function ReadFileToString (line 117) | absl::Status ReadFileToString(const absl::string_view name, std::strin...
    function GetImportPathToCrateNameMap (line 143) | absl::StatusOr<absl::flat_hash_map<std::string, std::string>>
    class Method (line 176) | class Method {
      method Method (line 178) | Method() = delete;
      method Method (line 180) | explicit Method(const MethodDescriptor *method) : method_(method) {}
      method Name (line 183) | std::string Name() const {
      method FullName (line 188) | absl::string_view FullName() const { return method_->full_name(); }
      method ProtoFieldName (line 191) | absl::string_view ProtoFieldName() const { return method_->name(); }
      method IsClientStreaming (line 194) | bool IsClientStreaming() const { return method_->client_streaming(); }
      method IsServerStreaming (line 197) | bool IsServerStreaming() const { return method_->server_streaming(); }
      method Comment (line 200) | std::string Comment() const { return GrpcGetCommentsForDescriptor(me...
      method IsDeprecated (line 203) | bool IsDeprecated() const { return method_->options().deprecated(); }
      method RequestName (line 206) | std::string RequestName(const GrpcOpts &opts, int depth) const {
      method ResponseName (line 212) | std::string ResponseName(const GrpcOpts &opts, int depth) const {
    class Service (line 226) | class Service {
      method Service (line 228) | Service() = delete;
      method Service (line 230) | explicit Service(const ServiceDescriptor *service) : service_(servic...
      method Name (line 233) | std::string Name() const {
      method FullName (line 238) | absl::string_view FullName() const { return service_->full_name(); }
      method Methods (line 241) | std::vector<Method> Methods() const {
      method Comment (line 252) | virtual std::string Comment() const {
    function FormatMethodPath (line 262) | static std::string FormatMethodPath(const Service &service,
    function SanitizeForRustDoc (line 267) | static std::string SanitizeForRustDoc(absl::string_view raw_comment) {
    function ProtoCommentToRustDoc (line 286) | static std::string ProtoCommentToRustDoc(absl::string_view proto_comme...
    function GenerateDeprecated (line 304) | static void GenerateDeprecated(Printer &ctx) { ctx.Emit("#[deprecated]...
    type client (line 306) | namespace client {
      function GenerateMethods (line 308) | static void GenerateMethods(Printer &printer, const Service &service,
      function GenerateClient (line 408) | static void GenerateClient(const Service &service, Printer &printer,
    type server (line 521) | namespace server {
      function GenerateTraitMethods (line 522) | static void GenerateTraitMethods(Printer &printer, const Service &se...
      function GenerateTrait (line 581) | static void GenerateTrait(Printer &printer, const Service &service,
      function GenerateMethods (line 601) | static void GenerateMethods(Printer &printer, const Service &service,
      function GenerateServer (line 791) | static void GenerateServer(const Service &service, Printer &printer,
    function GenerateService (line 939) | void GenerateService(protobuf::io::Printer &printer,
    function GetRsGrpcFile (line 948) | std::string GetRsGrpcFile(const protobuf::FileDescriptor &file) {

FILE: protoc-gen-rust-grpc/src/grpc_rust_generator.h
  function class (line 30) | class GrpcOpts {
  function SetImportPathToCrateName (line 40) | void SetImportPathToCrateName(
  function SetFilesInCurrentCrate (line 45) | void SetFilesInCurrentCrate(

FILE: protoc-gen-rust-grpc/src/grpc_rust_plugin.cc
  class RustGrpcGenerator (line 31) | class RustGrpcGenerator : public protobuf::compiler::CodeGenerator {
    method GetSupportedFeatures (line 35) | uint64_t GetSupportedFeatures() const override {
    method GetMinimumEdition (line 39) | protobuf::Edition GetMinimumEdition() const override {
    method GetMaximumEdition (line 42) | protobuf::Edition GetMaximumEdition() const override {
    method GetSupportedFeatures (line 46) | uint64_t GetSupportedFeatures() const override {
    method Generate (line 51) | bool Generate(const protobuf::FileDescriptor *file,
  function main (line 95) | int main(int argc, char *argv[]) {

FILE: tests/compile/build.rs
  function main (line 1) | fn main() {

FILE: tests/compile/tests/ui.rs
  function ui (line 2) | fn ui() {

FILE: tests/compile/tests/ui/ambiguous_methods.rs
  function main (line 3) | fn main() {}

FILE: tests/compile/tests/ui/includer.rs
  type _Test (line 8) | type _Test = dyn pb::top_service_server::TopService;
  function main (line 10) | fn main() {}

FILE: tests/compile/tests/ui/result.rs
  function main (line 3) | fn main() {}

FILE: tests/compile/tests/ui/root_file_path.rs
  type Animal (line 2) | struct Animal {
  function main (line 11) | fn main() {}

FILE: tests/compile/tests/ui/same_name.rs
  function main (line 3) | fn main() {}

FILE: tests/compile/tests/ui/service.rs
  function main (line 3) | fn main() {}

FILE: tests/compile/tests/ui/skip_debug.rs
  function main (line 7) | fn main() {}

FILE: tests/compile/tests/ui/stream.rs
  function main (line 3) | fn main() {}

FILE: tests/compile/tests/ui/use_arc_self.rs
  type Svc (line 6) | struct Svc;
    method test_request (line 10) | async fn test_request(
  function main (line 18) | fn main() {}

FILE: tests/compression/build.rs
  function main (line 1) | fn main() {

FILE: tests/compression/src/bidirectional_stream.rs
  function client_enabled_server_enabled (line 13) | async fn client_enabled_server_enabled(encoding: CompressionEncoding) {

FILE: tests/compression/src/client_stream.rs
  function client_enabled_server_enabled (line 13) | async fn client_enabled_server_enabled(encoding: CompressionEncoding) {
  function client_disabled_server_enabled (line 86) | async fn client_disabled_server_enabled(encoding: CompressionEncoding) {
  function client_enabled_server_disabled (line 137) | async fn client_enabled_server_disabled(encoding: CompressionEncoding) {
  function compressing_response_from_client_stream (line 180) | async fn compressing_response_from_client_stream(encoding: CompressionEn...

FILE: tests/compression/src/compressing_request.rs
  function client_enabled_server_enabled (line 13) | async fn client_enabled_server_enabled(encoding: CompressionEncoding) {
  function client_enabled_server_enabled_multi_encoding (line 90) | async fn client_enabled_server_enabled_multi_encoding(encoding: Compress...
  function client_enabled_server_disabled (line 152) | async fn client_enabled_server_disabled(encoding: CompressionEncoding) {
  function client_mark_compressed_without_header_server_enabled (line 200) | async fn client_mark_compressed_without_header_server_enabled(encoding: ...
  function limit_decoded_message_size (line 246) | async fn limit_decoded_message_size(encoding: CompressionEncoding) {

FILE: tests/compression/src/compressing_response.rs
  function client_enabled_server_enabled (line 12) | async fn client_enabled_server_enabled(encoding: CompressionEncoding) {
  function client_enabled_server_disabled (line 110) | async fn client_enabled_server_disabled(encoding: CompressionEncoding) {
  function client_enabled_server_disabled_multi_encoding (line 151) | async fn client_enabled_server_disabled_multi_encoding() {
  function client_disabled (line 201) | async fn client_disabled(encoding: CompressionEncoding) {
  function server_replying_with_unsupported_encoding (line 272) | async fn server_replying_with_unsupported_encoding(encoding: Compression...
  function disabling_compression_on_single_response (line 316) | async fn disabling_compression_on_single_response(encoding: CompressionE...
  function disabling_compression_on_response_but_keeping_compression_on_stream (line 372) | async fn disabling_compression_on_response_but_keeping_compression_on_st...
  function disabling_compression_on_response_from_client_stream (line 443) | async fn disabling_compression_on_response_from_client_stream(encoding: ...
  function limit_decoded_message_size (line 500) | async fn limit_decoded_message_size(encoding: CompressionEncoding) {

FILE: tests/compression/src/lib.rs
  type Svc (line 31) | struct Svc {
    method prepare_response (line 38) | fn prepare_response<B>(&self, mut res: Response<B>) -> Response<B> {
    method compress_output_unary (line 49) | async fn compress_output_unary(&self, _req: Request<()>) -> Result<Res...
    method compress_input_unary (line 57) | async fn compress_input_unary(&self, req: Request<SomeData>) -> Result...
    type CompressOutputServerStreamStream (line 62) | type CompressOutputServerStreamStream =
    method compress_output_server_stream (line 65) | async fn compress_output_server_stream(
    method compress_input_client_stream (line 76) | async fn compress_input_client_stream(
    method compress_output_client_stream (line 87) | async fn compress_output_client_stream(
    type CompressInputOutputBidirectionalStreamStream (line 103) | type CompressInputOutputBidirectionalStreamStream =
    method compress_input_output_bidirectional_stream (line 106) | async fn compress_input_output_bidirectional_stream(
  constant UNCOMPRESSED_MIN_BODY_SIZE (line 35) | const UNCOMPRESSED_MIN_BODY_SIZE: usize = 1024;

FILE: tests/compression/src/server_stream.rs
  function client_enabled_server_enabled (line 13) | async fn client_enabled_server_enabled(encoding: CompressionEncoding) {
  function client_disabled_server_enabled (line 78) | async fn client_disabled_server_enabled(encoding: CompressionEncoding) {
  function client_enabled_server_disabled (line 130) | async fn client_enabled_server_disabled(encoding: CompressionEncoding) {

FILE: tests/compression/src/util.rs
  type CountBytesBody (line 39) | pub struct CountBytesBody<B> {
  type Data (line 49) | type Data = B::Data;
  type Error (line 50) | type Error = B::Error;
  method poll_frame (line 52) | fn poll_frame(
  method is_end_stream (line 68) | fn is_end_stream(&self) -> bool {
  method size_hint (line 72) | fn size_hint(&self) -> http_body::SizeHint {
  function frame_data_length (line 77) | fn frame_data_length(frame: &http_body::Frame<Bytes>) -> usize {
  type ChannelBody (line 86) | struct ChannelBody<T> {
  function new (line 92) | pub fn new() -> (tokio::sync::mpsc::Sender<Frame<T>>, Self) {
  type Data (line 102) | type Data = T;
  type Error (line 103) | type Error = tonic::Status;
  method poll_frame (line 105) | fn poll_frame(
  function measure_request_body_size_layer (line 115) | pub fn measure_request_body_size_layer(
  function mock_io_channel (line 136) | pub async fn mock_io_channel(client: tokio::io::DuplexStream) -> Channel {
  type AssertRightEncoding (line 150) | pub struct AssertRightEncoding {
    method new (line 156) | pub fn new(encoding: CompressionEncoding) -> Self {
    method call (line 160) | pub fn call<B: HttpBody>(self, req: http::Request<B>) -> http::Request...

FILE: tests/default_stubs/build.rs
  function main (line 1) | fn main() {

FILE: tests/default_stubs/src/lib.rs
  type Svc (line 9) | pub struct Svc;
    type ServerStreamStream (line 13) | type ServerStreamStream = Pin<Box<dyn Stream<Item = Result<(), Status>...
    type BidirectionalStreamStream (line 14) | type BidirectionalStreamStream =
    method unary (line 17) | async fn unary(&self, _: Request<()>) -> Result<Response<()>, Status> {
    method server_stream (line 21) | async fn server_stream(
    method client_stream (line 28) | async fn client_stream(&self, _: Request<Streaming<()>>) -> Result<Res...
    method bidirectional_stream (line 32) | async fn bidirectional_stream(

FILE: tests/default_stubs/tests/default.rs
  function echo_requests_iter (line 9) | fn echo_requests_iter() -> impl Stream<Item = ()> {
  function test_default_stubs (line 13) | async fn test_default_stubs(
  function test_default_stubs_tcp (line 77) | async fn test_default_stubs_tcp() {
  function test_default_stubs_uds (line 90) | async fn test_default_stubs_uds() {
  function run_services_in_background (line 97) | async fn run_services_in_background() -> (SocketAddr, SocketAddr) {
  function run_services_in_background_uds (line 129) | async fn run_services_in_background_uds() -> (String, String) {

FILE: tests/deprecated_methods/build.rs
  function main (line 1) | fn main() {

FILE: tests/deprecated_methods/tests/deprecated_methods.rs
  function test (line 4) | fn test() {

FILE: tests/disable_comments/build.rs
  function main (line 1) | fn main() {

FILE: tests/disable_comments/tests/disable_comments.rs
  function test (line 4) | fn test() {

FILE: tests/extern_path/my_application/build.rs
  function main (line 1) | fn main() -> Result<(), std::io::Error> {

FILE: tests/extern_path/my_application/src/main.rs
  function main (line 5) | fn main() {
  function service_types_have_extern_types (line 17) | fn service_types_have_extern_types() {

FILE: tests/extern_path/uuid/build.rs
  function main (line 1) | fn main() {

FILE: tests/extern_path/uuid/src/lib.rs
  type DoSomething (line 3) | pub trait DoSomething {
    method do_it (line 4) | fn do_it(&self) -> String;
    method do_it (line 8) | fn do_it(&self) -> String {

FILE: tests/integration_tests/build.rs
  function main (line 1) | fn main() {

FILE: tests/integration_tests/src/lib.rs
  type MockStream (line 17) | pub struct MockStream(pub tokio::io::DuplexStream);
  type ConnectInfo (line 20) | type ConnectInfo = ();
  method connect_info (line 23) | fn connect_info(&self) -> Self::ConnectInfo {}
  method poll_read (line 27) | fn poll_read(
  method poll_write (line 37) | fn poll_write(
  method poll_flush (line 45) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<st...
  method poll_shutdown (line 49) | fn poll_shutdown(
  method poll_write_vectored (line 56) | fn poll_write_vectored(
  method is_write_vectored (line 64) | fn is_write_vectored(&self) -> bool {
  function trace_init (line 70) | pub fn trace_init() {
  type BoxFuture (line 74) | pub type BoxFuture<'a, T> = std::pin::Pin<Box<dyn std::future::Future<Ou...

FILE: tests/integration_tests/tests/client_layer.rs
  function connect_supports_standard_tower_layers (line 13) | async fn connect_supports_standard_tower_layers() {

FILE: tests/integration_tests/tests/complex_tower_middleware.rs
  function complex_tower_layers_work (line 14) | async fn complex_tower_layers_work() {
  type MyServiceLayer (line 35) | struct MyServiceLayer {}
    method new (line 38) | fn new() -> Self {
    type Service (line 44) | type Service = MyService<S>;
    method layer (line 46) | fn layer(&self, inner: S) -> Self::Service {
  type MyService (line 52) | struct MyService<S> {
  type Response (line 60) | type Response = http::Response<MyBody<ResBody>>;
  type Error (line 61) | type Error = BoxError;
  type Future (line 62) | type Future = MyFuture<S::Future, ResBody>;
    type Output (line 82) | type Output = Result<http::Response<MyBody<B>>, BoxError>;
    method poll (line 84) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 64) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 68) | fn call(&mut self, req: R) -> Self::Future {
  type MyFuture (line 73) | struct MyFuture<F, B> {
  type MyBody (line 89) | struct MyBody<B> {
  type Data (line 97) | type Data = B::Data;
  type Error (line 98) | type Error = BoxError;
  method poll_frame (line 100) | fn poll_frame(

FILE: tests/integration_tests/tests/connect_info.rs
  function getting_connect_info (line 13) | async fn getting_connect_info() {
  type Svc (line 78) | struct Svc {}
    method unary_call (line 82) | async fn unary_call(&self, req: Request<Input>) -> Result<Response<Out...
  function getting_connect_info (line 97) | async fn getting_connect_info() {

FILE: tests/integration_tests/tests/connection.rs
  type Svc (line 10) | struct Svc(Arc<Mutex<Option<oneshot::Sender<()>>>>);
    method unary_call (line 14) | async fn unary_call(&self, _: Request<Input>) -> Result<Response<Outpu...
  function connect_returns_err (line 23) | async fn connect_returns_err() {
  function connect_handles_tls (line 30) | async fn connect_handles_tls() {
  function connect_returns_err_via_call_after_connected (line 38) | async fn connect_returns_err_via_call_after_connected() {
  function connect_lazy_reconnects_after_first_failure (line 73) | async fn connect_lazy_reconnects_after_first_failure() {

FILE: tests/integration_tests/tests/extensions.rs
  type ExtensionValue (line 19) | struct ExtensionValue(i32);
  function setting_extension_from_interceptor (line 22) | async fn setting_extension_from_interceptor() {
  function setting_extension_from_tower (line 72) | async fn setting_extension_from_tower() {
  type InterceptedService (line 121) | struct InterceptedService<S> {
  type Response (line 134) | type Response = S::Response;
  type Error (line 135) | type Error = S::Error;
  type Future (line 136) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
  function poll_ready (line 138) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 142) | fn call(&mut self, mut req: http::Request<Body>) -> Self::Future {
  constant NAME (line 156) | const NAME: &'static str = S::NAME;

FILE: tests/integration_tests/tests/http2_keep_alive.rs
  type Svc (line 9) | struct Svc;
    method unary_call (line 13) | async fn unary_call(&self, _: Request<Input>) -> Result<Response<Outpu...
  function http2_keepalive_does_not_cause_panics (line 19) | async fn http2_keepalive_does_not_cause_panics() {
  function http2_keepalive_does_not_cause_panics_on_client_side (line 49) | async fn http2_keepalive_does_not_cause_panics_on_client_side() {

FILE: tests/integration_tests/tests/http2_max_header_list_size.rs
  function test_http_max_header_list_size_and_long_errors (line 13) | async fn test_http_max_header_list_size_and_long_errors() {

FILE: tests/integration_tests/tests/interceptor.rs
  function interceptor_retrieves_grpc_method (line 10) | async fn interceptor_retrieves_grpc_method() {

FILE: tests/integration_tests/tests/load_shed.rs
  function service_resource_exhausted (line 7) | async fn service_resource_exhausted() {
  function service_resource_not_exhausted (line 22) | async fn service_resource_not_exhausted() {
  function run_service_in_background (line 35) | async fn run_service_in_background(concurrency_limit: usize) -> SocketAd...

FILE: tests/integration_tests/tests/max_message_size.rs
  function max_message_recv_size (line 15) | fn max_message_recv_size() {
  function max_message_send_size (line 65) | fn max_message_send_size() {
  function response_stream_limit (line 118) | async fn response_stream_limit() {
  function assert_server_recv_max_success (line 195) | fn assert_server_recv_max_success(size: usize) {
  function assert_server_recv_max_failure (line 206) | fn assert_server_recv_max_failure(size: usize) {
  function assert_client_recv_max_success (line 218) | fn assert_client_recv_max_success(size: usize) {
  function assert_client_recv_max_failure (line 229) | fn assert_client_recv_max_failure(size: usize) {
  function assert_test_case (line 241) | fn assert_test_case(case: TestCase) {
  type TestCase (line 259) | struct TestCase {
  function max_message_run (line 271) | async fn max_message_run(case: &TestCase) -> Result<(), Status> {

FILE: tests/integration_tests/tests/origin.rs
  function writes_origin_header (line 17) | async fn writes_origin_header() {
  type OriginLayer (line 69) | struct OriginLayer {}
    type Service (line 72) | type Service = OriginService<S>;
    method layer (line 74) | fn layer(&self, inner: S) -> Self::Service {
  type OriginService (line 80) | struct OriginService<S> {
  type Response (line 90) | type Response = T::Response;
  type Error (line 91) | type Error = Box<dyn std::error::Error + Send + Sync>;
  type Future (line 92) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
  function poll_ready (line 94) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 98) | fn call(&mut self, req: Request<tonic::body::Body>) -> Self::Future {

FILE: tests/integration_tests/tests/routes_builder.rs
  function multiple_service_using_routes_builder (line 18) | async fn multiple_service_using_routes_builder() {

FILE: tests/integration_tests/tests/status.rs
  function status_with_details (line 22) | async fn status_with_details() {
  function status_with_metadata (line 72) | async fn status_with_metadata() {
  type Stream (line 141) | type Stream<T> = std::pin::Pin<
  function status_from_server_stream (line 146) | async fn status_from_server_stream() {
  function status_from_server_stream_with_source (line 198) | async fn status_from_server_stream_with_source() {
  function status_from_server_stream_with_inferred_status (line 216) | async fn status_from_server_stream_with_inferred_status() {
  function message_and_then_status_from_server_stream (line 303) | async fn message_and_then_status_from_server_stream() {

FILE: tests/integration_tests/tests/streams.rs
  type Stream (line 5) | type Stream<T> = std::pin::Pin<
  function status_from_server_stream_with_source (line 10) | async fn status_from_server_stream_with_source() {
  type Unsync (line 45) | struct Unsync(*mut ());
    type Item (line 50) | type Item = Result<OutputStream, Status>;
    method poll_next (line 52) | fn poll_next(

FILE: tests/integration_tests/tests/timeout.rs
  function cancelation_on_timeout (line 7) | async fn cancelation_on_timeout() {
  function picks_server_timeout_if_thats_sorter (line 27) | async fn picks_server_timeout_if_thats_sorter() {
  function picks_client_timeout_if_thats_sorter (line 46) | async fn picks_client_timeout_if_thats_sorter() {
  function run_service_in_background (line 64) | async fn run_service_in_background(latency: Duration, server_timeout: Du...

FILE: tests/integration_tests/tests/user_agent.rs
  function writes_user_agent_header (line 10) | async fn writes_user_agent_header() {

FILE: tests/web/build.rs
  function main (line 1) | fn main() {

FILE: tests/web/src/lib.rs
  type BoxStream (line 12) | type BoxStream<T> = Pin<Box<dyn Stream<Item = Result<T, Status>> + Send ...
  type Svc (line 14) | pub struct Svc;
  method unary_call (line 18) | async fn unary_call(&self, req: Request<Input>) -> Result<Response<Outpu...
  type ServerStreamStream (line 31) | type ServerStreamStream = BoxStream<Output>;
  method server_stream (line 33) | async fn server_stream(
  method client_stream (line 49) | async fn client_stream(
  constant STANDARD (line 81) | pub const STANDARD: GeneralPurpose = GeneralPurpose::new(

FILE: tests/web/tests/grpc.rs
  function smoke_unary (line 17) | async fn smoke_unary() {
  function smoke_client_stream (line 33) | async fn smoke_client_stream() {
  function smoke_server_stream (line 51) | async fn smoke_server_stream() {
  function smoke_error (line 72) | async fn smoke_error() {
  function bind (line 95) | async fn bind() -> (TcpListener, String) {
  function grpc (line 103) | async fn grpc(accept_h1: bool) -> (impl Future<Output = Result<(), Error...
  function grpc_web (line 114) | async fn grpc_web(accept_h1: bool) -> (impl Future<Output = Result<(), E...
  type Client (line 126) | type Client = TestClient<Channel>;
  function spawn (line 128) | async fn spawn() -> Result<(Client, Client, Client, Client), Error> {
  function input (line 144) | fn input() -> Input {
  function meta (line 151) | fn meta<T>(r: &Response<T>) -> String {
  function data (line 155) | fn data<T>(r: &Response<T>) -> &T {
  function stream (line 159) | async fn stream<T>(r: Response<Streaming<T>>) -> Vec<T> {
  function status (line 163) | fn status(s: &tonic::Status) -> (String, tonic::Code) {

FILE: tests/web/tests/grpc_web.rs
  function binary_request (line 23) | async fn binary_request() {
  function text_request (line 46) | async fn text_request() {
  function spawn (line 68) | async fn spawn() -> String {
  function encode_body (line 87) | fn encode_body() -> Bytes {
  function build_request (line 111) | fn build_request(base_uri: String, content_type: &str, accept: &str) -> ...
  function decode_body (line 138) | async fn decode_body(body: Incoming, content_type: &str) -> (Output, Byt...

FILE: tests/wellknown-compiled/build.rs
  function main (line 1) | fn main() {

FILE: tests/wellknown-compiled/src/lib.rs
  function grok (line 14) | pub fn grok() {

FILE: tests/wellknown/build.rs
  function main (line 1) | fn main() {

FILE: tonic-build/src/client.rs
  function generate_internal (line 11) | pub(crate) fn generate_internal<T: Service>(
  function generate_connect (line 140) | fn generate_connect(service_ident: &syn::Ident, enabled: bool) -> TokenS...
  function generate_connect (line 163) | fn generate_connect(_service_ident: &syn::Ident, _enabled: bool) -> Toke...
  function generate_methods (line 167) | fn generate_methods<T: Service>(
  function generate_unary (line 221) | fn generate_unary<T: Service>(
  function generate_server_streaming (line 252) | fn generate_server_streaming<T: Service>(
  function generate_client_streaming (line 283) | fn generate_client_streaming<T: Service>(
  function generate_streaming (line 314) | fn generate_streaming<T: Service>(

FILE: tonic-build/src/code_gen.rs
  type CodeGenBuilder (line 14) | pub struct CodeGenBuilder {
    method new (line 26) | pub fn new() -> Self {
    method emit_package (line 31) | pub fn emit_package(&mut self, enable: bool) -> &mut Self {
    method attributes (line 39) | pub fn attributes(&mut self, attributes: Attributes) -> &mut Self {
    method build_transport (line 49) | pub fn build_transport(&mut self, build_transport: bool) -> &mut Self {
    method compile_well_known_types (line 56) | pub fn compile_well_known_types(&mut self, enable: bool) -> &mut Self {
    method disable_comments (line 62) | pub fn disable_comments(&mut self, disable_comments: HashSet<String>) ...
    method use_arc_self (line 68) | pub fn use_arc_self(&mut self, enable: bool) -> &mut Self {
    method generate_default_stubs (line 74) | pub fn generate_default_stubs(&mut self, generate_default_stubs: bool)...
    method generate_client (line 83) | pub fn generate_client(&self, service: &impl Service, proto_path: &str...
    method generate_server (line 99) | pub fn generate_server(&self, service: &impl Service, proto_path: &str...
  method default (line 114) | fn default() -> Self {

FILE: tonic-build/src/lib.rs
  type Service (line 31) | pub trait Service {
    method name (line 39) | fn name(&self) -> &str;
    method package (line 41) | fn package(&self) -> &str;
    method identifier (line 43) | fn identifier(&self) -> &str;
    method methods (line 45) | fn methods(&self) -> &[Self::Method];
    method comment (line 47) | fn comment(&self) -> &[Self::Comment];
  type Method (line 56) | pub trait Method {
    method name (line 61) | fn name(&self) -> &str;
    method identifier (line 63) | fn identifier(&self) -> &str;
    method codec_path (line 65) | fn codec_path(&self) -> &str;
    method client_streaming (line 67) | fn client_streaming(&self) -> bool;
    method server_streaming (line 69) | fn server_streaming(&self) -> bool;
    method comment (line 71) | fn comment(&self) -> &[Self::Comment];
    method deprecated (line 73) | fn deprecated(&self) -> bool {
    method request_response_name (line 77) | fn request_response_name(
  type Attributes (line 86) | pub struct Attributes {
    method for_mod (line 96) | fn for_mod(&self, name: &str) -> Vec<syn::Attribute> {
    method for_struct (line 100) | fn for_struct(&self, name: &str) -> Vec<syn::Attribute> {
    method for_trait (line 104) | fn for_trait(&self, name: &str) -> Vec<syn::Attribute> {
    method push_mod (line 117) | pub fn push_mod(&mut self, pattern: impl Into<String>, attr: impl Into...
    method push_struct (line 130) | pub fn push_struct(&mut self, pattern: impl Into<String>, attr: impl I...
    method push_trait (line 143) | pub fn push_trait(&mut self, pattern: impl Into<String>, attr: impl In...
  function format_service_name (line 148) | fn format_service_name<T: Service>(service: &T, emit_package: bool) -> S...
  function format_method_path (line 158) | fn format_method_path<T: Service>(service: &T, method: &T::Method, emit_...
  function format_method_name (line 166) | fn format_method_name<T: Service>(service: &T, method: &T::Method, emit_...
  function generate_attributes (line 175) | fn generate_attributes<'a>(
  function generate_deprecated (line 191) | fn generate_deprecated() -> TokenStream {
  function generate_doc_comment (line 205) | fn generate_doc_comment<S: AsRef<str>>(comment: S) -> TokenStream {
  function generate_doc_comments (line 229) | fn generate_doc_comments<T: AsRef<str>>(comments: &[T]) -> TokenStream {
  function match_name (line 240) | pub(crate) fn match_name(pattern: &str, path: &str) -> bool {
  function naive_snake_case (line 265) | fn naive_snake_case(name: &str) -> String {
  function test_match_name (line 286) | fn test_match_name() {
  function test_snake_case (line 307) | fn test_snake_case() {

FILE: tonic-build/src/manual.rs
  type ServiceBuilder (line 57) | pub struct ServiceBuilder {
    method name (line 74) | pub fn name(mut self, name: impl AsRef<str>) -> Self {
    method package (line 83) | pub fn package(mut self, package: impl AsRef<str>) -> Self {
    method comment (line 89) | pub fn comment(mut self, comment: impl AsRef<str>) -> Self {
    method method (line 95) | pub fn method(mut self, method: Method) -> Self {
    method build (line 103) | pub fn build(self) -> Service {
  type Service (line 115) | pub struct Service {
    method builder (line 128) | pub fn builder() -> ServiceBuilder {
    type Comment (line 134) | type Comment = String;
    type Method (line 136) | type Method = Method;
    method name (line 138) | fn name(&self) -> &str {
    method package (line 142) | fn package(&self) -> &str {
    method identifier (line 146) | fn identifier(&self) -> &str {
    method methods (line 150) | fn methods(&self) -> &[Self::Method] {
    method comment (line 154) | fn comment(&self) -> &[Self::Comment] {
  type Method (line 161) | pub struct Method {
    method builder (line 184) | pub fn builder() -> MethodBuilder {
    type Comment (line 190) | type Comment = String;
    method name (line 192) | fn name(&self) -> &str {
    method identifier (line 196) | fn identifier(&self) -> &str {
    method codec_path (line 200) | fn codec_path(&self) -> &str {
    method client_streaming (line 204) | fn client_streaming(&self) -> bool {
    method server_streaming (line 208) | fn server_streaming(&self) -> bool {
    method comment (line 212) | fn comment(&self) -> &[Self::Comment] {
    method deprecated (line 216) | fn deprecated(&self) -> bool {
    method request_response_name (line 220) | fn request_response_name(
  type MethodBuilder (line 256) | pub struct MethodBuilder {
    method name (line 283) | pub fn name(mut self, name: impl AsRef<str>) -> Self {
    method route_name (line 294) | pub fn route_name(mut self, route_name: impl AsRef<str>) -> Self {
    method comment (line 300) | pub fn comment(mut self, comment: impl AsRef<str>) -> Self {
    method input_type (line 306) | pub fn input_type(mut self, input_type: impl AsRef<str>) -> Self {
    method output_type (line 312) | pub fn output_type(mut self, output_type: impl AsRef<str>) -> Self {
    method codec_path (line 320) | pub fn codec_path(mut self, codec_path: impl AsRef<str>) -> Self {
    method client_streaming (line 326) | pub fn client_streaming(mut self) -> Self {
    method server_streaming (line 332) | pub fn server_streaming(mut self) -> Self {
    method build (line 340) | pub fn build(self) -> Method {
  type ServiceGenerator (line 355) | struct ServiceGenerator {
    method generate (line 362) | fn generate(&mut self, service: &Service) {
    method finalize (line 383) | fn finalize(&mut self, buf: &mut String) {
  type Builder (line 416) | pub struct Builder {
    method new (line 437) | pub fn new() -> Self {
    method build_client (line 444) | pub fn build_client(mut self, enable: bool) -> Self {
    method build_server (line 452) | pub fn build_server(mut self, enable: bool) -> Self {
    method build_transport (line 461) | pub fn build_transport(mut self, enable: bool) -> Self {
    method out_dir (line 469) | pub fn out_dir(mut self, out_dir: impl AsRef<Path>) -> Self {
    method compile (line 478) | pub fn compile(self, services: &[Service]) {
  method default (line 425) | fn default() -> Self {

FILE: tonic-build/src/server.rs
  function generate_internal (line 13) | pub(crate) fn generate_internal<T: Service>(
  function generate_trait (line 199) | fn generate_trait<T: Service>(
  function generate_trait_methods (line 234) | fn generate_trait_methods<T: Service>(
  function generate_named (line 359) | fn generate_named(server_service: &syn::Ident, service_name: &str) -> To...
  function generate_methods (line 373) | fn generate_methods<T: Service>(
  function generate_unary (line 439) | fn generate_unary<T: Method>(
  function generate_server_streaming (line 497) | fn generate_server_streaming<T: Method>(
  function generate_client_streaming (line 564) | fn generate_client_streaming<T: Method>(
  function generate_streaming (line 622) | fn generate_streaming<T: Method>(

FILE: tonic-health/src/generated/grpc_health_v1.rs
  type HealthCheckRequest (line 3) | pub struct HealthCheckRequest {
  type HealthCheckResponse (line 8) | pub struct HealthCheckResponse {
  type ServingStatus (line 26) | pub enum ServingStatus {
    method as_str_name (line 38) | pub fn as_str_name(&self) -> &'static str {
    method from_str_name (line 47) | pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
  type HealthClient (line 70) | pub struct HealthClient<T> {
  function new (line 80) | pub fn new(inner: T) -> Self {
  function with_origin (line 84) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function with_interceptor (line 88) | pub fn with_interceptor<F>(
  function send_compressed (line 112) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 118) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 126) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 134) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function check (line 140) | pub async fn check(
  function watch (line 179) | pub async fn watch(
  type Health (line 217) | pub trait Health: std::marker::Send + std::marker::Sync + 'static {
    method check (line 220) | async fn check(
    method watch (line 248) | async fn watch(
  type HealthServer (line 254) | pub struct HealthServer<T> {
  function new (line 262) | pub fn new(inner: T) -> Self {
  function from_arc (line 265) | pub fn from_arc(inner: Arc<T>) -> Self {
  function with_interceptor (line 274) | pub fn with_interceptor<F>(
  function accept_compressed (line 285) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 291) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 299) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 307) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  type Response (line 318) | type Response = http::Response<tonic::body::Body>;
  type Error (line 319) | type Error = std::convert::Infallible;
  type Future (line 320) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 321) | fn poll_ready(
  function call (line 327) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  method clone (line 443) | fn clone(&self) -> Self {
  constant SERVICE_NAME (line 455) | pub const SERVICE_NAME: &str = "grpc.health.v1.Health";
  constant NAME (line 457) | const NAME: &'static str = SERVICE_NAME;

FILE: tonic-health/src/generated/grpc_health_v1_fds.rs
  constant FILE_DESCRIPTOR_SET (line 19) | pub const FILE_DESCRIPTOR_SET: &[u8] = &[

FILE: tonic-health/src/lib.rs
  function file_descriptor_set_is_valid (line 34) | fn file_descriptor_set_is_valid() {
  type ServingStatus (line 49) | pub enum ServingStatus {
  method fmt (line 59) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function from (line 69) | fn from(s: ServingStatus) -> Self {

FILE: tonic-health/src/server.rs
  function health_reporter (line 21) | pub fn health_reporter() -> (HealthReporter, HealthServer<impl Health>) {
  type StatusPair (line 29) | type StatusPair = (watch::Sender<ServingStatus>, watch::Receiver<Serving...
  type HealthReporter (line 35) | pub struct HealthReporter {
    method new (line 41) | pub fn new() -> Self {
    method set_serving (line 52) | pub async fn set_serving<S>(&self)
    method set_not_serving (line 63) | pub async fn set_not_serving<S>(&self)
    method set_service_status (line 74) | pub async fn set_service_status<S>(&self, service_name: S, status: Ser...
    method clear_service_status (line 95) | pub async fn clear_service_status(&mut self, service_name: &str) {
  method default (line 102) | fn default() -> Self {
  type HealthService (line 109) | pub struct HealthService {
    method new (line 114) | fn new(services: Arc<RwLock<HashMap<String, StatusPair>>>) -> Self {
    method from_health_reporter (line 119) | pub fn from_health_reporter(health_reporter: HealthReporter) -> Self {
    method service_health (line 123) | async fn service_health(&self, service_name: &str) -> Option<ServingSt...
  method check (line 131) | async fn check(
  type WatchStream (line 143) | type WatchStream = WatchStream;
  method watch (line 145) | async fn watch(
  type WatchStream (line 160) | pub struct WatchStream {
    method new (line 165) | fn new(status_rx: watch::Receiver<ServingStatus>) -> Self {
    method fmt (line 185) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 172) | type Item = Result<HealthCheckResponse, Status>;
  method poll_next (line 174) | fn poll_next(
  method new (line 191) | fn new(status: ServingStatus) -> Self {
  function assert_serving_status (line 207) | fn assert_serving_status(wire: i32, expected: ServingStatus) {
  function assert_grpc_status (line 212) | fn assert_grpc_status(wire: Option<Status>, expected: Code) {
  function make_test_service (line 217) | async fn make_test_service() -> (HealthReporter, HealthService) {
  function test_service_check (line 234) | async fn test_service_check() {
  function test_service_watch (line 281) | async fn test_service_watch() {

FILE: tonic-prost-build/src/lib.rs
  function configure (line 59) | pub fn configure() -> Builder {
  function compile_protos (line 96) | pub fn compile_protos(proto: impl AsRef<Path>) -> io::Result<()> {
  function compile_fds (line 108) | pub fn compile_fds(fds: prost_types::FileDescriptorSet) -> io::Result<()> {
  constant EXTENDED_NON_PATH_TYPE_ALLOWLIST (line 114) | const EXTENDED_NON_PATH_TYPE_ALLOWLIST: &[&str] =
  constant DEFAULT_NON_PATH_TYPE_ALLOWLIST (line 117) | const DEFAULT_NON_PATH_TYPE_ALLOWLIST: &[&str] = &["()"];
  type TonicBuildService (line 128) | struct TonicBuildService {
    method new (line 134) | fn new(prost_service: Service, codec_path: String) -> Self {
    type Method (line 157) | type Method = TonicBuildMethod;
    type Comment (line 158) | type Comment = String;
    method name (line 160) | fn name(&self) -> &str {
    method package (line 164) | fn package(&self) -> &str {
    method identifier (line 168) | fn identifier(&self) -> &str {
    method methods (line 172) | fn methods(&self) -> &[Self::Method] {
    method comment (line 176) | fn comment(&self) -> &[Self::Comment] {
  type TonicBuildMethod (line 151) | struct TonicBuildMethod {
    type Comment (line 182) | type Comment = String;
    method name (line 184) | fn name(&self) -> &str {
    method identifier (line 188) | fn identifier(&self) -> &str {
    method client_streaming (line 192) | fn client_streaming(&self) -> bool {
    method server_streaming (line 196) | fn server_streaming(&self) -> bool {
    method comment (line 200) | fn comment(&self) -> &[Self::Comment] {
    method request_response_name (line 204) | fn request_response_name(
    method codec_path (line 296) | fn codec_path(&self) -> &str {
    method deprecated (line 300) | fn deprecated(&self) -> bool {
  function is_non_path_type (line 305) | fn is_non_path_type(ty: &str) -> bool {
  function is_google_type (line 314) | fn is_google_type(ty: &str) -> bool {
  type ServiceGenerator (line 320) | struct ServiceGenerator {
    method new (line 337) | fn new(
    method generate (line 367) | fn generate(&mut self, service: Service, buf: &mut String) {
  type Builder (line 400) | pub struct Builder {
    method build_client (line 433) | pub fn build_client(mut self, enable: bool) -> Self {
    method build_server (line 439) | pub fn build_server(mut self, enable: bool) -> Self {
    method build_transport (line 445) | pub fn build_transport(mut self, enable: bool) -> Self {
    method out_dir (line 454) | pub fn out_dir(mut self, out_dir: impl AsRef<Path>) -> Self {
    method extern_path (line 464) | pub fn extern_path(mut self, proto_path: impl AsRef<str>, rust_path: i...
    method field_attribute (line 475) | pub fn field_attribute<P: AsRef<str>, A: AsRef<str>>(mut self, path: P...
    method message_attribute (line 484) | pub fn message_attribute<P: AsRef<str>, A: AsRef<str>>(
    method enum_attribute (line 497) | pub fn enum_attribute<P: AsRef<str>, A: AsRef<str>>(mut self, path: P,...
    method type_attribute (line 506) | pub fn type_attribute<P: AsRef<str>, A: AsRef<str>>(mut self, path: P,...
    method boxed (line 515) | pub fn boxed<P: AsRef<str>>(mut self, path: P) -> Self {
    method btree_map (line 523) | pub fn btree_map<P: AsRef<str>>(mut self, path: P) -> Self {
    method bytes (line 534) | pub fn bytes<P: AsRef<str>>(mut self, path: P) -> Self {
    method server_mod_attribute (line 544) | pub fn server_mod_attribute<P: AsRef<str>, A: AsRef<str>>(
    method server_attribute (line 556) | pub fn server_attribute<P: AsRef<str>, A: AsRef<str>>(mut self, path: ...
    method trait_attribute (line 564) | pub fn trait_attribute<P: AsRef<str>, A: AsRef<str>>(mut self, path: P...
    method client_mod_attribute (line 572) | pub fn client_mod_attribute<P: AsRef<str>, A: AsRef<str>>(
    method client_attribute (line 584) | pub fn client_attribute<P: AsRef<str>, A: AsRef<str>>(mut self, path: ...
    method proto_path (line 602) | pub fn proto_path(mut self, proto_path: impl AsRef<str>) -> Self {
    method compile_well_known_types (line 610) | pub fn compile_well_known_types(mut self, enable: bool) -> Self {
    method with_extended_rust_types (line 618) | pub fn with_extended_rust_types(mut self, enable: bool) -> Self {
    method emit_package (line 626) | pub fn emit_package(mut self, enable: bool) -> Self {
    method file_descriptor_set_path (line 634) | pub fn file_descriptor_set_path(mut self, path: impl AsRef<Path>) -> S...
    method skip_protoc_run (line 642) | pub fn skip_protoc_run(mut self) -> Self {
    method protoc_arg (line 650) | pub fn protoc_arg<A: AsRef<str>>(mut self, arg: A) -> Self {
    method include_file (line 658) | pub fn include_file(mut self, path: impl AsRef<Path>) -> Self {
    method emit_rerun_if_changed (line 666) | pub fn emit_rerun_if_changed(mut self, enable: bool) -> Self {
    method disable_comments (line 674) | pub fn disable_comments<I, S>(mut self, path: I) -> Self
    method use_arc_self (line 685) | pub fn use_arc_self(mut self, enable: bool) -> Self {
    method generate_default_stubs (line 692) | pub fn generate_default_stubs(mut self, enable: bool) -> Self {
    method codec_path (line 698) | pub fn codec_path(mut self, path: impl AsRef<str>) -> Self {
    method skip_debug (line 707) | pub fn skip_debug<I, S>(mut self, paths: I) -> Self
    method compile_protos (line 718) | pub fn compile_protos<P>(self, protos: &[P], includes: &[P]) -> io::Re...
    method compile_with_config (line 729) | pub fn compile_with_config<P>(
    method compile_fds (line 845) | pub fn compile_fds(self, fds: prost_types::FileDescriptorSet) -> io::R...
    method compile_fds_with_config (line 850) | pub fn compile_fds_with_config(
    method service_generator (line 948) | pub fn service_generator(self) -> Box<dyn prost_build::ServiceGenerato...

FILE: tonic-prost-build/src/tests.rs
  function create_test_method (line 5) | fn create_test_method(input_type: String, output_type: String) -> TonicB...
  function test_request_response_name_google_types_not_compiled (line 28) | fn test_request_response_name_google_types_not_compiled() {
  function test_request_response_name_google_types_compiled (line 63) | fn test_request_response_name_google_types_compiled() {
  function test_request_response_name_non_path_types (line 96) | fn test_request_response_name_non_path_types() {
  function test_request_response_name_extern_types (line 106) | fn test_request_response_name_extern_types() {
  function test_request_response_name_regular_protobuf_types (line 140) | fn test_request_response_name_regular_protobuf_types() {
  function test_request_response_name_different_proto_paths (line 170) | fn test_request_response_name_different_proto_paths() {
  function test_request_response_name_mixed_types (line 214) | fn test_request_response_name_mixed_types() {
  function test_is_google_type (line 237) | fn test_is_google_type() {
  function test_extended_non_path_type_allowlist (line 249) | fn test_extended_non_path_type_allowlist() {
  function test_default_non_path_type_allowlist (line 292) | fn test_default_non_path_type_allowlist() {
  function test_edge_cases (line 303) | fn test_edge_cases() {

FILE: tonic-prost/src/codec.rs
  type ProstCodec (line 8) | pub struct ProstCodec<T, U> {
  function new (line 15) | pub fn new() -> Self {
  method default (line 21) | fn default() -> Self {
  function raw_encoder (line 33) | pub fn raw_encoder(buffer_settings: BufferSettings) -> <Self as Codec>::...
  function raw_decoder (line 42) | pub fn raw_decoder(buffer_settings: BufferSettings) -> <Self as Codec>::...
  type Encode (line 55) | type Encode = T;
  type Decode (line 56) | type Decode = U;
  type Encoder (line 58) | type Encoder = ProstEncoder<T>;
  type Decoder (line 59) | type Decoder = ProstDecoder<U>;
  method encoder (line 61) | fn encoder(&mut self) -> Self::Encoder {
  method decoder (line 68) | fn decoder(&mut self) -> Self::Decoder {
  type ProstEncoder (line 78) | pub struct ProstEncoder<T> {
  function new (line 85) | pub fn new(buffer_settings: BufferSettings) -> Self {
  type Item (line 94) | type Item = T;
  type Error (line 95) | type Error = Status;
  method encode (line 97) | fn encode(&mut self, item: Self::Item, buf: &mut EncodeBuf<'_>) -> Resul...
  method buffer_settings (line 104) | fn buffer_settings(&self) -> BufferSettings {
  type ProstDecoder (line 111) | pub struct ProstDecoder<U> {
  function new (line 118) | pub fn new(buffer_settings: BufferSettings) -> Self {
  type Item (line 127) | type Item = U;
  type Error (line 128) | type Error = Status;
  method decode (line 130) | fn decode(&mut self, buf: &mut DecodeBuf<'_>) -> Result<Option<Self::Ite...
  method buffer_settings (line 138) | fn buffer_settings(&self) -> BufferSettings {
  function from_decode_error (line 143) | fn from_decode_error(error: prost::DecodeError) -> Status {
  constant LEN (line 159) | const LEN: usize = 10000;
  constant MAX_MESSAGE_SIZE (line 161) | const MAX_MESSAGE_SIZE: usize = 2 * 1024 * 1024;
  function decode (line 164) | async fn decode() {
  function decode_max_message_size_exceeded (line 190) | async fn decode_max_message_size_exceeded() {
  function encode (line 220) | async fn encode() {
  function encode_max_message_size_exceeded (line 242) | async fn encode_max_message_size_exceeded() {
  function encode_too_big (line 277) | async fn encode_too_big() {
  type MockEncoder (line 310) | struct MockEncoder {}
  type Item (line 313) | type Item = Vec<u8>;
  type Error (line 314) | type Error = Status;
  method encode (line 316) | fn encode(&mut self, item: Self::Item, buf: &mut EncodeBuf<'_>) -> Resul...
  method buffer_settings (line 321) | fn buffer_settings(&self) -> BufferSettings {
  type MockDecoder (line 327) | struct MockDecoder {}
  type Item (line 330) | type Item = Vec<u8>;
  type Error (line 331) | type Error = Status;
  method decode (line 333) | fn decode(&mut self, buf: &mut DecodeBuf<'_>) -> Result<Option<Self::Ite...
  method buffer_settings (line 339) | fn buffer_settings(&self) -> BufferSettings {
  type MockBody (line 354) | pub(super) struct MockBody {
    method new (line 365) | pub(super) fn new(b: &[u8], partial_len: usize, count: usize) -> Self {
  type Data (line 375) | type Data = Bytes;
  type Error (line 376) | type Error = Status;
  method poll_frame (line 378) | fn poll_frame(

FILE: tonic-protobuf-build/build.rs
  function main (line 1) | fn main() {

FILE: tonic-protobuf-build/src/lib.rs
  function protoc (line 31) | pub fn protoc() -> String {
  function protoc_gen_rust_grpc (line 35) | pub fn protoc_gen_rust_grpc() -> String {
  function bin (line 39) | pub fn bin() -> String {
  type Dependency (line 46) | pub struct Dependency {
    method builder (line 53) | pub fn builder() -> DependencyBuilder {
  type DependencyBuilder (line 59) | pub struct DependencyBuilder {
    method crate_name (line 67) | pub fn crate_name(mut self, name: impl Into<String>) -> Self {
    method proto_import_path (line 74) | pub fn proto_import_path(mut self, path: impl Into<PathBuf>) -> Self {
    method proto_import_paths (line 80) | pub fn proto_import_paths(mut self, paths: Vec<PathBuf>) -> Self {
    method proto_file (line 85) | pub fn proto_file(mut self, file: impl Into<String>) -> Self {
    method proto_files (line 90) | pub fn proto_files(mut self, files: Vec<String>) -> Self {
    method build (line 95) | pub fn build(self) -> Result<Dependency, &'static str> {
  function from (line 106) | fn from(val: &Dependency) -> Self {
  type CodeGen (line 117) | pub struct CodeGen {
    method new (line 129) | pub fn new() -> Self {
    method generate_message_code (line 143) | pub fn generate_message_code(&mut self, enable: bool) -> &mut Self {
    method input (line 149) | pub fn input(&mut self, input: impl AsRef<Path>) -> &mut Self {
    method inputs (line 155) | pub fn inputs(&mut self, inputs: impl IntoIterator<Item = impl AsRef<P...
    method should_format_code (line 162) | pub fn should_format_code(&mut self, enable: bool) -> &mut Self {
    method output_dir (line 170) | pub fn output_dir(&mut self, output_dir: impl AsRef<Path>) -> &mut Self {
    method include (line 176) | pub fn include(&mut self, include: impl AsRef<Path>) -> &mut Self {
    method includes (line 182) | pub fn includes(&mut self, includes: impl Iterator<Item = impl AsRef<P...
    method dependencies (line 193) | pub fn dependencies(&mut self, deps: Vec<Dependency>) -> &mut Self {
    method message_module_path (line 202) | pub fn message_module_path(&mut self, message_path: &str) -> &mut Self {
    method compile (line 207) | pub fn compile(&self) -> Result<(), String> {
    method format_code (line 278) | fn format_code(&self) {
    method generate_crate_mapping_file (line 306) | fn generate_crate_mapping_file(&self) -> PathBuf {
  method default (line 323) | fn default() -> Self {

FILE: tonic-protobuf/src/lib.rs
  type ProtoCodec (line 38) | pub struct ProtoCodec<T, U> {
  method default (line 43) | fn default() -> Self {
  type Encode (line 53) | type Encode = T;
  type Decode (line 54) | type Decode = U;
  type Encoder (line 56) | type Encoder = ProtoEncoder<T>;
  type Decoder (line 57) | type Decoder = ProtoDecoder<U>;
  method encoder (line 59) | fn encoder(&mut self) -> Self::Encoder {
  method decoder (line 63) | fn decoder(&mut self) -> Self::Decoder {
  type ProtoEncoder (line 70) | pub struct ProtoEncoder<T> {
  function new (line 76) | pub fn new() -> Self {
  type Item (line 82) | type Item = T;
  type Error (line 83) | type Error = Status;
  method encode (line 85) | fn encode(&mut self, item: Self::Item, buf: &mut EncodeBuf<'_>) -> Resul...
  type ProtoDecoder (line 98) | pub struct ProtoDecoder<U> {
  function new (line 104) | pub fn new() -> Self {
  type Item (line 110) | type Item = U;
  type Error (line 111) | type Error = Status;
  method decode (line 113) | fn decode(&mut self, buf: &mut DecodeBuf<'_>) -> Result<Option<Self::Ite...
  function from_decode_error (line 121) | fn from_decode_error(error: impl std::error::Error) -> tonic::Status {

FILE: tonic-reflection/src/generated/grpc_reflection_v1.rs
  type ServerReflectionRequest (line 4) | pub struct ServerReflectionRequest {
  type MessageRequest (line 21) | pub enum MessageRequest {
  type ExtensionRequest (line 53) | pub struct ExtensionRequest {
  type ServerReflectionResponse (line 62) | pub struct ServerReflectionResponse {
  type MessageResponse (line 79) | pub enum MessageResponse {
  type FileDescriptorResponse (line 103) | pub struct FileDescriptorResponse {
  type ExtensionNumberResponse (line 113) | pub struct ExtensionNumberResponse {
  type ListServiceResponse (line 123) | pub struct ListServiceResponse {
  type ServiceResponse (line 132) | pub struct ServiceResponse {
  type ErrorResponse (line 140) | pub struct ErrorResponse {
  type ServerReflectionClient (line 159) | pub struct ServerReflectionClient<T> {
  function new (line 169) | pub fn new(inner: T) -> Self {
  function with_origin (line 173) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function with_interceptor (line 177) | pub fn with_interceptor<F>(
  function send_compressed (line 201) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 207) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 215) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 223) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function server_reflection_info (line 229) | pub async fn server_reflection_info(
  type ServerReflection (line 274) | pub trait ServerReflection: std::marker::Send + std::marker::Sync + 'sta...
    method server_reflection_info (line 286) | async fn server_reflection_info(
  type ServerReflectionServer (line 295) | pub struct ServerReflectionServer<T> {
  function new (line 303) | pub fn new(inner: T) -> Self {
  function from_arc (line 306) | pub fn from_arc(inner: Arc<T>) -> Self {
  function with_interceptor (line 315) | pub fn with_interceptor<F>(
  function accept_compressed (line 326) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 332) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 340) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 348) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  type Response (line 359) | type Response = http::Response<tonic::body::Body>;
  type Error (line 360) | type Error = std::convert::Infallible;
  type Future (line 361) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 362) | fn poll_ready(
  function call (line 368) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  method clone (line 445) | fn clone(&self) -> Self {
  constant SERVICE_NAME (line 457) | pub const SERVICE_NAME: &str = "grpc.reflection.v1.ServerReflection";
  constant NAME (line 459) | const NAME: &'static str = SERVICE_NAME;

FILE: tonic-reflection/src/generated/grpc_reflection_v1alpha.rs
  type ServerReflectionRequest (line 4) | pub struct ServerReflectionRequest {
  type MessageRequest (line 21) | pub enum MessageRequest {
  type ExtensionRequest (line 53) | pub struct ExtensionRequest {
  type ServerReflectionResponse (line 62) | pub struct ServerReflectionResponse {
  type MessageResponse (line 79) | pub enum MessageResponse {
  type FileDescriptorResponse (line 103) | pub struct FileDescriptorResponse {
  type ExtensionNumberResponse (line 113) | pub struct ExtensionNumberResponse {
  type ListServiceResponse (line 123) | pub struct ListServiceResponse {
  type ServiceResponse (line 132) | pub struct ServiceResponse {
  type ErrorResponse (line 140) | pub struct ErrorResponse {
  type ServerReflectionClient (line 159) | pub struct ServerReflectionClient<T> {
  function new (line 169) | pub fn new(inner: T) -> Self {
  function with_origin (line 173) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function with_interceptor (line 177) | pub fn with_interceptor<F>(
  function send_compressed (line 201) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 207) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 215) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 223) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function server_reflection_info (line 229) | pub async fn server_reflection_info(
  type ServerReflection (line 274) | pub trait ServerReflection: std::marker::Send + std::marker::Sync + 'sta...
    method server_reflection_info (line 286) | async fn server_reflection_info(
  type ServerReflectionServer (line 295) | pub struct ServerReflectionServer<T> {
  function new (line 303) | pub fn new(inner: T) -> Self {
  function from_arc (line 306) | pub fn from_arc(inner: Arc<T>) -> Self {
  function with_interceptor (line 315) | pub fn with_interceptor<F>(
  function accept_compressed (line 326) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 332) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 340) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 348) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  type Response (line 359) | type Response = http::Response<tonic::body::Body>;
  type Error (line 360) | type Error = std::convert::Infallible;
  type Future (line 361) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 362) | fn poll_ready(
  function call (line 368) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  method clone (line 445) | fn clone(&self) -> Self {
  constant SERVICE_NAME (line 457) | pub const SERVICE_NAME: &str = "grpc.reflection.v1alpha.ServerReflection";
  constant NAME (line 459) | const NAME: &'static str = SERVICE_NAME;

FILE: tonic-reflection/src/generated/reflection_v1_fds.rs
  constant FILE_DESCRIPTOR_SET (line 23) | pub const FILE_DESCRIPTOR_SET: &[u8] = &[

FILE: tonic-reflection/src/generated/reflection_v1alpha1_fds.rs
  constant FILE_DESCRIPTOR_SET (line 18) | pub const FILE_DESCRIPTOR_SET: &[u8] = &[

FILE: tonic-reflection/src/lib.rs
  function v1alpha_file_descriptor_set_is_valid (line 36) | fn v1alpha_file_descriptor_set_is_valid() {
  function v1_file_descriptor_set_is_valid (line 41) | fn v1_file_descriptor_set_is_valid() {

FILE: tonic-reflection/src/server/mod.rs
  type Builder (line 19) | pub struct Builder<'b> {
  function configure (line 30) | pub fn configure() -> Self {
  function register_file_descriptor_set (line 43) | pub fn register_file_descriptor_set(mut self, file_descriptor_set: FileD...
  function register_encoded_file_descriptor_set (line 50) | pub fn register_encoded_file_descriptor_set(
  function include_reflection_service (line 61) | pub fn include_reflection_service(mut self, include: bool) -> Self {
  function with_service_name (line 70) | pub fn with_service_name(mut self, name: impl Into<String>) -> Self {
  function build_v1 (line 77) | pub fn build_v1(
  function build_v1alpha (line 95) | pub fn build_v1alpha(
  type ReflectionServiceState (line 115) | struct ReflectionServiceState {
    method new (line 122) | fn new(
    method process_file (line 160) | fn process_file(
    method process_message (line 191) | fn process_message(
    method process_enum (line 220) | fn process_enum(
    method process_field (line 237) | fn process_field(
    method list_services (line 248) | fn list_services(&self) -> &[String] {
    method symbol_by_name (line 252) | fn symbol_by_name(&self, symbol: &str) -> Result<Vec<u8>, Status> {
    method file_by_filename (line 266) | fn file_by_filename(&self, filename: &str) -> Result<Vec<u8>, Status> {
  function extract_name (line 281) | fn extract_name(
  type Error (line 302) | pub enum Error {
    method from (line 310) | fn from(e: DecodeError) -> Self {
  method fmt (line 318) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

FILE: tonic-reflection/src/server/v1.rs
  type ReflectionService (line 18) | pub struct ReflectionService {
    method from (line 100) | fn from(state: ReflectionServiceState) -> Self {
  type ServerReflectionInfoStream (line 24) | type ServerReflectionInfoStream = ServerReflectionInfoStream;
  method server_reflection_info (line 26) | async fn server_reflection_info(
  type ServerReflectionInfoStream (line 108) | pub struct ServerReflectionInfoStream {
    method new (line 113) | fn new(resp_rx: mpsc::Receiver<Result<ServerReflectionResponse, Status...
    method fmt (line 135) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 120) | type Item = Result<ServerReflectionResponse, Status>;
  method poll_next (line 122) | fn poll_next(
  method size_hint (line 129) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tonic-reflection/src/server/v1alpha.rs
  type ReflectionService (line 18) | pub struct ReflectionService {
    method from (line 100) | fn from(state: ReflectionServiceState) -> Self {
  type ServerReflectionInfoStream (line 24) | type ServerReflectionInfoStream = ServerReflectionInfoStream;
  method server_reflection_info (line 26) | async fn server_reflection_info(
  type ServerReflectionInfoStream (line 108) | pub struct ServerReflectionInfoStream {
    method new (line 113) | fn new(resp_rx: mpsc::Receiver<Result<ServerReflectionResponse, Status...
    method fmt (line 135) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 120) | type Item = Result<ServerReflectionResponse, Status>;
  method poll_next (line 122) | fn poll_next(
  method size_hint (line 129) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: tonic-reflection/tests/server.rs
  function get_encoded_reflection_service_fd (line 17) | pub(crate) fn get_encoded_reflection_service_fd() -> Vec<u8> {
  function test_list_services (line 28) | async fn test_list_services() {
  function test_file_by_filename (line 48) | async fn test_file_by_filename() {
  function test_file_containing_symbol (line 72) | async fn test_file_containing_symbol() {
  function make_test_reflection_request (line 95) | async fn make_test_reflection_request(request: ServerReflectionRequest) ...

FILE: tonic-reflection/tests/versions.rs
  function test_v1 (line 13) | async fn test_v1() {
  function test_v1alpha (line 37) | async fn test_v1alpha() {
  function make_v1_request (line 60) | async fn make_v1_request(
  function make_v1alpha_request (line 117) | async fn make_v1alpha_request(

FILE: tonic-types/src/generated/google_rpc.rs
  type Status (line 10) | pub struct Status {
  type ErrorInfo (line 53) | pub struct ErrorInfo {
  type RetryInfo (line 98) | pub struct RetryInfo {
  type DebugInfo (line 105) | pub struct DebugInfo {
  type QuotaFailure (line 125) | pub struct QuotaFailure {
  type Violation (line 135) | pub struct Violation {
  type PreconditionFailure (line 226) | pub struct PreconditionFailure {
  type Violation (line 235) | pub struct Violation {
  type BadRequest (line 257) | pub struct BadRequest {
  type FieldViolation (line 266) | pub struct FieldViolation {
  type RequestInfo (line 328) | pub struct RequestInfo {
  type ResourceInfo (line 340) | pub struct ResourceInfo {
  type Help (line 369) | pub struct Help {
  type Link (line 378) | pub struct Link {
  type LocalizedMessage (line 390) | pub struct LocalizedMessage {

FILE: tonic-types/src/generated/types_fds.rs
  constant FILE_DESCRIPTOR_SET (line 30) | pub const FILE_DESCRIPTOR_SET: &[u8] = &[

FILE: tonic-types/src/lib.rs
  function file_descriptor_set_is_valid (line 164) | fn file_descriptor_set_is_valid() {
  type Sealed (line 186) | pub trait Sealed {}

FILE: tonic-types/src/richer_error/error_details/mod.rs
  type ErrorDetails (line 17) | pub struct ErrorDetails {
    method new (line 59) | pub fn new() -> Self {
    method with_retry_info (line 74) | pub fn with_retry_info(retry_delay: Option<time::Duration>) -> Self {
    method with_debug_info (line 93) | pub fn with_debug_info(
    method with_quota_failure (line 116) | pub fn with_quota_failure(violations: impl Into<Vec<QuotaViolation>>) ...
    method with_quota_failure_violation (line 133) | pub fn with_quota_failure_violation(
    method with_error_info (line 157) | pub fn with_error_info(
    method with_precondition_failure (line 189) | pub fn with_precondition_failure(violations: impl Into<Vec<Preconditio...
    method with_precondition_failure_violation (line 211) | pub fn with_precondition_failure_violation(
    method with_bad_request (line 239) | pub fn with_bad_request(field_violations: impl Into<Vec<FieldViolation...
    method with_bad_request_violation (line 259) | pub fn with_bad_request_violation(
    method with_request_info (line 282) | pub fn with_request_info(
    method with_resource_info (line 307) | pub fn with_resource_info(
    method with_help (line 337) | pub fn with_help(links: impl Into<Vec<HelpLink>>) -> Self {
    method with_help_link (line 357) | pub fn with_help_link(description: impl Into<String>, url: impl Into<S...
    method with_localized_message (line 377) | pub fn with_localized_message(locale: impl Into<String>, message: impl...
    method retry_info (line 385) | pub fn retry_info(&self) -> Option<&RetryInfo> {
    method debug_info (line 390) | pub fn debug_info(&self) -> Option<&DebugInfo> {
    method quota_failure (line 395) | pub fn quota_failure(&self) -> Option<&QuotaFailure> {
    method error_info (line 400) | pub fn error_info(&self) -> Option<&ErrorInfo> {
    method precondition_failure (line 405) | pub fn precondition_failure(&self) -> Option<&PreconditionFailure> {
    method bad_request (line 410) | pub fn bad_request(&self) -> Option<&BadRequest> {
    method request_info (line 415) | pub fn request_info(&self) -> Option<&RequestInfo> {
    method resource_info (line 420) | pub fn resource_info(&self) -> Option<&ResourceInfo> {
    method help (line 425) | pub fn help(&self) -> Option<&Help> {
    method localized_message (line 430) | pub fn localized_message(&self) -> Option<&LocalizedMessage> {
    method set_retry_info (line 447) | pub fn set_retry_info(&mut self, retry_delay: Option<time::Duration>) ...
    method set_debug_info (line 466) | pub fn set_debug_info(
    method set_quota_failure (line 490) | pub fn set_quota_failure(&mut self, violations: impl Into<Vec<QuotaVio...
    method add_quota_failure_violation (line 508) | pub fn add_quota_failure_violation(
    method has_quota_failure_violations (line 540) | pub fn has_quota_failure_violations(&self) -> bool {
    method set_error_info (line 563) | pub fn set_error_info(
    method set_precondition_failure (line 596) | pub fn set_precondition_failure(
    method add_precondition_failure_violation (line 621) | pub fn add_precondition_failure_violation(
    method has_precondition_failure_violations (line 662) | pub fn has_precondition_failure_violations(&self) -> bool {
    method set_bad_request (line 684) | pub fn set_bad_request(&mut self, violations: impl Into<Vec<FieldViola...
    method add_bad_request_violation (line 702) | pub fn add_bad_request_violation(
    method has_bad_request_violations (line 734) | pub fn has_bad_request_violations(&self) -> bool {
    method set_request_info (line 753) | pub fn set_request_info(
    method set_resource_info (line 774) | pub fn set_resource_info(
    method set_help (line 805) | pub fn set_help(&mut self, links: impl Into<Vec<HelpLink>>) -> &mut Se...
    method add_help_link (line 823) | pub fn add_help_link(
    method has_help_links (line 855) | pub fn has_help_links(&self) -> bool {
    method set_localized_message (line 874) | pub fn set_localized_message(

FILE: tonic-types/src/richer_error/error_details/vec.rs
  type ErrorDetail (line 10) | pub enum ErrorDetail {
    method from (line 43) | fn from(err_detail: RetryInfo) -> Self {
    method from (line 49) | fn from(err_detail: DebugInfo) -> Self {
    method from (line 55) | fn from(err_detail: QuotaFailure) -> Self {
    method from (line 61) | fn from(err_detail: ErrorInfo) -> Self {
    method from (line 67) | fn from(err_detail: PreconditionFailure) -> Self {
    method from (line 73) | fn from(err_detail: BadRequest) -> Self {
    method from (line 79) | fn from(err_detail: RequestInfo) -> Self {
    method from (line 85) | fn from(err_detail: ResourceInfo) -> Self {
    method from (line 91) | fn from(err_detail: Help) -> Self {
    method from (line 97) | fn from(err_detail: LocalizedMessage) -> Self {

FILE: tonic-types/src/richer_error/mod.rs
  type IntoAny (line 20) | trait IntoAny {
    method into_any (line 21) | fn into_any(self) -> Any;
  type FromAny (line 25) | trait FromAny {
    method from_any (line 26) | fn from_any(any: Any) -> Result<Self, DecodeError>
  type FromAnyRef (line 31) | trait FromAnyRef {
    method from_any_ref (line 32) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError>
  function gen_details_bytes (line 37) | fn gen_details_bytes(code: Code, message: &str, details: Vec<Any>) -> By...
  type StatusExt (line 55) | pub trait StatusExt: crate::sealed::Sealed {
    method with_error_details_and_metadata (line 72) | fn with_error_details_and_metadata(
    method with_error_details (line 94) | fn with_error_details(
    method with_error_details_vec_and_metadata (line 118) | fn with_error_details_vec_and_metadata(
    method with_error_details_vec (line 142) | fn with_error_details_vec(
    method check_error_details (line 175) | fn check_error_details(&self) -> Result<ErrorDetails, DecodeError>;
    method get_error_details (line 200) | fn get_error_details(&self) -> ErrorDetails;
    method check_error_details_vec (line 229) | fn check_error_details_vec(&self) -> Result<Vec<ErrorDetail>, DecodeEr...
    method get_error_details_vec (line 258) | fn get_error_details_vec(&self) -> Vec<ErrorDetail>;
    method get_details_retry_info (line 280) | fn get_details_retry_info(&self) -> Option<RetryInfo>;
    method get_details_debug_info (line 302) | fn get_details_debug_info(&self) -> Option<DebugInfo>;
    method get_details_quota_failure (line 324) | fn get_details_quota_failure(&self) -> Option<QuotaFailure>;
    method get_details_error_info (line 346) | fn get_details_error_info(&self) -> Option<ErrorInfo>;
    method get_details_precondition_failure (line 368) | fn get_details_precondition_failure(&self) -> Option<PreconditionFailu...
    method get_details_bad_request (line 390) | fn get_details_bad_request(&self) -> Option<BadRequest>;
    method get_details_request_info (line 412) | fn get_details_request_info(&self) -> Option<RequestInfo>;
    method get_details_resource_info (line 434) | fn get_details_resource_info(&self) -> Option<ResourceInfo>;
    method get_details_help (line 456) | fn get_details_help(&self) -> Option<Help>;
    method get_details_localized_message (line 478) | fn get_details_localized_message(&self) -> Option<LocalizedMessage>;
    method with_error_details_and_metadata (line 484) | fn with_error_details_and_metadata(
    method with_error_details (line 539) | fn with_error_details(code: Code, message: impl Into<String>, details:...
    method with_error_details_vec_and_metadata (line 543) | fn with_error_details_vec_and_metadata(
    method with_error_details_vec (line 593) | fn with_error_details_vec(
    method check_error_details (line 606) | fn check_error_details(&self) -> Result<ErrorDetails, DecodeError> {
    method get_error_details (line 612) | fn get_error_details(&self) -> ErrorDetails {
    method check_error_details_vec (line 616) | fn check_error_details_vec(&self) -> Result<Vec<ErrorDetail>, DecodeEr...
    method get_error_details_vec (line 622) | fn get_error_details_vec(&self) -> Vec<ErrorDetail> {
    method get_details_retry_info (line 626) | fn get_details_retry_info(&self) -> Option<RetryInfo> {
    method get_details_debug_info (line 632) | fn get_details_debug_info(&self) -> Option<DebugInfo> {
    method get_details_quota_failure (line 638) | fn get_details_quota_failure(&self) -> Option<QuotaFailure> {
    method get_details_error_info (line 644) | fn get_details_error_info(&self) -> Option<ErrorInfo> {
    method get_details_precondition_failure (line 650) | fn get_details_precondition_failure(&self) -> Option<PreconditionFailu...
    method get_details_bad_request (line 656) | fn get_details_bad_request(&self) -> Option<BadRequest> {
    method get_details_request_info (line 662) | fn get_details_request_info(&self) -> Option<RequestInfo> {
    method get_details_resource_info (line 668) | fn get_details_resource_info(&self) -> Option<ResourceInfo> {
    method get_details_help (line 674) | fn get_details_help(&self) -> Option<Help> {
    method get_details_localized_message (line 680) | fn get_details_localized_message(&self) -> Option<LocalizedMessage> {
  type RpcStatusExt (line 692) | pub trait RpcStatusExt: crate::sealed::Sealed {
    method check_error_details (line 699) | fn check_error_details(&self) -> Result<ErrorDetails, DecodeError>;
    method get_error_details (line 704) | fn get_error_details(&self) -> ErrorDetails;
    method check_error_details_vec (line 712) | fn check_error_details_vec(&self) -> Result<Vec<ErrorDetail>, DecodeEr...
    method get_error_details_vec (line 716) | fn get_error_details_vec(&self) -> Vec<ErrorDetail>;
    method get_details_retry_info (line 720) | fn get_details_retry_info(&self) -> Option<RetryInfo>;
    method get_details_debug_info (line 724) | fn get_details_debug_info(&self) -> Option<DebugInfo>;
    method get_details_quota_failure (line 728) | fn get_details_quota_failure(&self) -> Option<QuotaFailure>;
    method get_details_error_info (line 732) | fn get_details_error_info(&self) -> Option<ErrorInfo>;
    method get_details_precondition_failure (line 736) | fn get_details_precondition_failure(&self) -> Option<PreconditionFailu...
    method get_details_bad_request (line 740) | fn get_details_bad_request(&self) -> Option<BadRequest>;
    method get_details_request_info (line 744) | fn get_details_request_info(&self) -> Option<RequestInfo>;
    method get_details_resource_info (line 748) | fn get_details_resource_info(&self) -> Option<ResourceInfo>;
    method get_details_help (line 752) | fn get_details_help(&self) -> Option<Help>;
    method get_details_localized_message (line 756) | fn get_details_localized_message(&self) -> Option<LocalizedMessage>;
    method check_error_details (line 760) | fn check_error_details(&self) -> Result<ErrorDetails, DecodeError> {
    method get_error_details (line 802) | fn get_error_details(&self) -> ErrorDetails {
    method check_error_details_vec (line 806) | fn check_error_details_vec(&self) -> Result<Vec<ErrorDetail>, DecodeEr...
    method get_error_details_vec (line 848) | fn get_error_details_vec(&self) -> Vec<ErrorDetail> {
    method get_details_retry_info (line 852) | fn get_details_retry_info(&self) -> Option<RetryInfo> {
    method get_details_debug_info (line 864) | fn get_details_debug_info(&self) -> Option<DebugInfo> {
    method get_details_quota_failure (line 876) | fn get_details_quota_failure(&self) -> Option<QuotaFailure> {
    method get_details_error_info (line 888) | fn get_details_error_info(&self) -> Option<ErrorInfo> {
    method get_details_precondition_failure (line 900) | fn get_details_precondition_failure(&self) -> Option<PreconditionFailu...
    method get_details_bad_request (line 912) | fn get_details_bad_request(&self) -> Option<BadRequest> {
    method get_details_request_info (line 924) | fn get_details_request_info(&self) -> Option<RequestInfo> {
    method get_details_resource_info (line 936) | fn get_details_resource_info(&self) -> Option<ResourceInfo> {
    method get_details_help (line 948) | fn get_details_help(&self) -> Option<Help> {
    method get_details_localized_message (line 960) | fn get_details_localized_message(&self) -> Option<LocalizedMessage> {
  function gen_status_with_details (line 984) | fn gen_status_with_details() {

FILE: tonic-types/src/richer_error/std_messages/bad_request.rs
  type FieldViolation (line 11) | pub struct FieldViolation {
    method new (line 31) | pub fn new(field: impl Into<String>, description: impl Into<String>) -...
    method from (line 41) | fn from(value: pb::bad_request::FieldViolation) -> Self {
  function from (line 52) | fn from(value: FieldViolation) -> Self {
  type BadRequest (line 67) | pub struct BadRequest {
    constant TYPE_URL (line 74) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Bad...
    method new (line 77) | pub fn new(field_violations: impl Into<Vec<FieldViolation>>) -> Self {
    method with_violation (line 85) | pub fn with_violation(field: impl Into<String>, description: impl Into...
    method add_violation (line 96) | pub fn add_violation(
    method is_empty (line 111) | pub fn is_empty(&self) -> bool {
    method from (line 144) | fn from(value: pb::BadRequest) -> Self {
  method into_any (line 117) | fn into_any(self) -> Any {
  method from_any (line 129) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 135) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 152) | fn from(value: BadRequest) -> Self {
  function gen_bad_request (line 165) | fn gen_bad_request() {

FILE: tonic-types/src/richer_error/std_messages/debug_info.rs
  type DebugInfo (line 13) | pub struct DebugInfo {
    constant TYPE_URL (line 23) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Deb...
    method new (line 26) | pub fn new(stack_entries: impl Into<Vec<String>>, detail: impl Into<St...
    method is_empty (line 35) | pub fn is_empty(&self) -> bool {
    method from (line 68) | fn from(debug_info: pb::DebugInfo) -> Self {
  method into_any (line 41) | fn into_any(self) -> Any {
  method from_any (line 53) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 59) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 77) | fn from(debug_info: DebugInfo) -> Self {
  function gen_debug_info (line 91) | fn gen_debug_info() {

FILE: tonic-types/src/richer_error/std_messages/error_info.rs
  type ErrorInfo (line 16) | pub struct ErrorInfo {
    constant TYPE_URL (line 34) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Err...
    method new (line 37) | pub fn new(
    method is_empty (line 51) | pub fn is_empty(&self) -> bool {
    method from (line 84) | fn from(error_info: pb::ErrorInfo) -> Self {
  method into_any (line 57) | fn into_any(self) -> Any {
  method from_any (line 69) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 75) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 94) | fn from(error_info: ErrorInfo) -> Self {
  function gen_error_info (line 111) | fn gen_error_info() {

FILE: tonic-types/src/richer_error/std_messages/help.rs
  type HelpLink (line 10) | pub struct HelpLink {
    method new (line 20) | pub fn new(description: impl Into<String>, url: impl Into<String>) -> ...
    method from (line 29) | fn from(value: pb::help::Link) -> Self {
  function from (line 38) | fn from(value: HelpLink) -> Self {
  type Help (line 52) | pub struct Help {
    constant TYPE_URL (line 59) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Help";
    method new (line 62) | pub fn new(links: impl Into<Vec<HelpLink>>) -> Self {
    method with_link (line 69) | pub fn with_link(description: impl Into<String>, url: impl Into<String...
    method add_link (line 79) | pub fn add_link(
    method is_empty (line 93) | pub fn is_empty(&self) -> bool {
    method from (line 126) | fn from(value: pb::Help) -> Self {
  method into_any (line 99) | fn into_any(self) -> Any {
  method from_any (line 111) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 117) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 134) | fn from(value: Help) -> Self {
  function gen_help (line 147) | fn gen_help() {

FILE: tonic-types/src/richer_error/std_messages/loc_message.rs
  type LocalizedMessage (line 14) | pub struct LocalizedMessage {
    constant TYPE_URL (line 27) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Loc...
    method new (line 30) | pub fn new(locale: impl Into<String>, message: impl Into<String>) -> S...
    method is_empty (line 39) | pub fn is_empty(&self) -> bool {
    method from (line 72) | fn from(loc_message: pb::LocalizedMessage) -> Self {
  method into_any (line 45) | fn into_any(self) -> Any {
  method from_any (line 57) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 63) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 81) | fn from(loc_message: LocalizedMessage) -> Self {
  function gen_localized_message (line 95) | fn gen_localized_message() {

FILE: tonic-types/src/richer_error/std_messages/prec_failure.rs
  type PreconditionViolation (line 11) | pub struct PreconditionViolation {
    method new (line 28) | pub fn new(
    method from (line 42) | fn from(value: pb::precondition_failure::Violation) -> Self {
  function from (line 52) | fn from(value: PreconditionViolation) -> Self {
  type PreconditionFailure (line 67) | pub struct PreconditionFailure {
    constant TYPE_URL (line 74) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Pre...
    method new (line 77) | pub fn new(violations: impl Into<Vec<PreconditionViolation>>) -> Self {
    method with_violation (line 85) | pub fn with_violation(
    method add_violation (line 101) | pub fn add_violation(
    method is_empty (line 117) | pub fn is_empty(&self) -> bool {
    method from (line 150) | fn from(value: pb::PreconditionFailure) -> Self {
  method into_any (line 123) | fn into_any(self) -> Any {
  method from_any (line 135) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 141) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 158) | fn from(value: PreconditionFailure) -> Self {
  function gen_prec_failure (line 171) | fn gen_prec_failure() {

FILE: tonic-types/src/richer_error/std_messages/quota_failure.rs
  type QuotaViolation (line 13) | pub struct QuotaViolation {
    method new (line 42) | pub fn new(subject: impl Into<String>, description: impl Into<String>)...
    method from (line 52) | fn from(value: pb::quota_failure::Violation) -> Self {
  function from (line 67) | fn from(value: QuotaViolation) -> Self {
  type QuotaFailure (line 86) | pub struct QuotaFailure {
    constant TYPE_URL (line 93) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Quo...
    method new (line 96) | pub fn new(violations: impl Into<Vec<QuotaViolation>>) -> Self {
    method with_violation (line 104) | pub fn with_violation(subject: impl Into<String>, description: impl In...
    method add_violation (line 115) | pub fn add_violation(
    method is_empty (line 130) | pub fn is_empty(&self) -> bool {
    method from (line 163) | fn from(value: pb::QuotaFailure) -> Self {
  method into_any (line 136) | fn into_any(self) -> Any {
  method from_any (line 148) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 154) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 171) | fn from(value: QuotaFailure) -> Self {
  function gen_quota_failure (line 184) | fn gen_quota_failure() {

FILE: tonic-types/src/richer_error/std_messages/request_info.rs
  type RequestInfo (line 14) | pub struct RequestInfo {
    constant TYPE_URL (line 26) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Req...
    method new (line 29) | pub fn new(request_id: impl Into<String>, serving_data: impl Into<Stri...
    method is_empty (line 38) | pub fn is_empty(&self) -> bool {
    method from (line 71) | fn from(req_info: pb::RequestInfo) -> Self {
  method into_any (line 44) | fn into_any(self) -> Any {
  method from_any (line 56) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 62) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 80) | fn from(req_info: RequestInfo) -> Self {
  function gen_request_info (line 94) | fn gen_request_info() {

FILE: tonic-types/src/richer_error/std_messages/resource_info.rs
  type ResourceInfo (line 13) | pub struct ResourceInfo {
    constant TYPE_URL (line 29) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Res...
    method new (line 32) | pub fn new(
    method is_empty (line 48) | pub fn is_empty(&self) -> bool {
    method from (line 84) | fn from(res_info: pb::ResourceInfo) -> Self {
  method into_any (line 57) | fn into_any(self) -> Any {
  method from_any (line 69) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 75) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 95) | fn from(res_info: ResourceInfo) -> Self {
  function gen_resource_info (line 111) | fn gen_resource_info() {

FILE: tonic-types/src/richer_error/std_messages/retry_info.rs
  type RetryInfo (line 18) | pub struct RetryInfo {
    constant TYPE_URL (line 25) | pub const TYPE_URL: &'static str = "type.googleapis.com/google.rpc.Ret...
    constant MAX_RETRY_DELAY (line 29) | pub const MAX_RETRY_DELAY: time::Duration = time::Duration::new(315_57...
    method new (line 34) | pub fn new(retry_delay: Option<time::Duration>) -> Self {
    method is_empty (line 50) | pub fn is_empty(&self) -> bool {
    method from (line 83) | fn from(retry_info: pb::RetryInfo) -> Self {
  method into_any (line 56) | fn into_any(self) -> Any {
  method from_any (line 68) | fn from_any(any: Any) -> Result<Self, DecodeError> {
  method from_any_ref (line 74) | fn from_any_ref(any: &Any) -> Result<Self, DecodeError> {
  function from (line 98) | fn from(value: RetryInfo) -> Self {
  function gen_retry_info (line 126) | fn gen_retry_info() {

FILE: tonic-web/src/call.rs
  constant GRPC_HEADER_SIZE (line 16) | const GRPC_HEADER_SIZE: usize = 1 + 4;
  constant GRPC_WEB (line 21) | pub(crate) const GRPC_WEB: &str = "application/grpc-web";
  constant GRPC_WEB_PROTO (line 22) | pub(crate) const GRPC_WEB_PROTO: &str = "application/grpc-web+proto";
  constant GRPC_WEB_TEXT (line 23) | pub(crate) const GRPC_WEB_TEXT: &str = "application/grpc-web-text";
  constant GRPC_WEB_TEXT_PROTO (line 24) | pub(crate) const GRPC_WEB_TEXT_PROTO: &str = "application/grpc-web-text+...
  function is_grpc_web (line 26) | pub(crate) fn is_grpc_web(headers: &HeaderMap) -> bool {
  function content_type (line 33) | fn content_type(headers: &HeaderMap) -> Option<&str> {
  constant BUFFER_SIZE (line 38) | const BUFFER_SIZE: usize = 8 * 1024;
  constant FRAME_HEADER_SIZE (line 40) | const FRAME_HEADER_SIZE: usize = 5;
  constant GRPC_WEB_TRAILERS_BIT (line 44) | const GRPC_WEB_TRAILERS_BIT: u8 = 0b10000000;
  type Direction (line 47) | enum Direction {
  type Encoding (line 54) | pub(crate) enum Encoding {
    method from_content_type (line 352) | pub(crate) fn from_content_type(headers: &HeaderMap) -> Encoding {
    method from_accept (line 356) | pub(crate) fn from_accept(headers: &HeaderMap) -> Encoding {
    method to_content_type (line 360) | pub(crate) fn to_content_type(self) -> &'static str {
    method from_header (line 367) | fn from_header(value: Option<&HeaderValue>) -> Encoding {
  type GrpcWebCall (line 62) | pub struct GrpcWebCall<B> {
  method default (line 74) | fn default() -> Self {
  function request (line 88) | pub(crate) fn request(inner: B, encoding: Encoding) -> Self {
  function response (line 92) | pub(crate) fn response(inner: B, encoding: Encoding) -> Self {
  function client_request (line 96) | pub(crate) fn client_request(inner: B) -> Self {
  function client_response (line 100) | pub(crate) fn client_response(inner: B) -> Self {
  function new_client (line 104) | fn new_client(inner: B, direction: Direction, encoding: Encoding) -> Self {
  function new (line 122) | fn new(inner: B, direction: Direction, encoding: Encoding) -> Self {
  function max_decodable (line 140) | fn max_decodable(&self) -> usize {
  function decode_chunk (line 144) | fn decode_chunk(mut self: Pin<&mut Self>) -> Result<Option<Bytes>, Statu...
  function poll_decode (line 170) | fn poll_decode(
  function poll_encode (line 216) | fn poll_encode(
  type Data (line 255) | type Data = Bytes;
  type Error (line 256) | type Error = Status;
  method poll_frame (line 258) | fn poll_frame(
  method is_end_stream (line 330) | fn is_end_stream(&self) -> bool {
  method size_hint (line 334) | fn size_hint(&self) -> SizeHint {
  type Item (line 344) | type Item = Result<Frame<Bytes>, Status>;
  method poll_next (line 346) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function internal_error (line 375) | fn internal_error(e: impl std::fmt::Display) -> Status {
  function encode_trailers (line 380) | fn encode_trailers(trailers: HeaderMap) -> Vec<u8> {
  function decode_trailers_frame (line 390) | fn decode_trailers_frame(mut buf: Bytes) -> Result<Option<HeaderMap>, St...
  function trim_ascii_start (line 443) | fn trim_ascii_start(bytes: &[u8]) -> &[u8] {
  function make_trailers_frame (line 451) | fn make_trailers_frame(trailers: HeaderMap) -> Bytes {
  function find_trailers (line 468) | fn find_trailers(buf: &[u8]) -> Result<FindTrailers, Status> {
  type FindTrailers (line 506) | enum FindTrailers {
  function encoding_constructors (line 519) | fn encoding_constructors() {
  function decode_trailers (line 540) | fn decode_trailers() {
  function find_trailers_non_buffered (line 556) | fn find_trailers_non_buffered() {
  function find_trailers_buffered (line 569) | fn find_trailers_buffered() {
  function find_trailers_buffered_incomplete_message (line 592) | fn find_trailers_buffered_incomplete_message() {
  function find_trailers_buffered_incomplete_buf_bug (line 629) | fn find_trailers_buffered_incomplete_buf_bug() {
  function decode_multiple_trailers (line 637) | fn decode_multiple_trailers() {
  function decode_trailers_with_space_after_colon (line 654) | fn decode_trailers_with_space_after_colon() {
  function decode_trailers_space_after_colon (line 669) | fn decode_trailers_space_after_colon() {
  function decode_trailers_value_with_colons (line 692) | fn decode_trailers_value_with_colons() {

FILE: tonic-web/src/client.rs
  type GrpcWebClientLayer (line 17) | pub struct GrpcWebClientLayer {
    method new (line 23) | pub fn new() -> GrpcWebClientLayer {
    type Service (line 29) | type Service = GrpcWebClientService<S>;
    method layer (line 31) | fn layer(&self, inner: S) -> Self::Service {
  type GrpcWebClientService (line 40) | pub struct GrpcWebClientService<S> {
  function new (line 46) | pub fn new(inner: S) -> Self {
  type Response (line 55) | type Response = Response<GrpcWebCall<B2>>;
  type Error (line 56) | type Error = S::Error;
  type Future (line 57) | type Future = ResponseFuture<S::Future>;
    type Output (line 93) | type Output = Result<Response<GrpcWebCall<B>>, E>;
    method poll (line 95) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 59) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 63) | fn call(&mut self, mut req: Request<B1>) -> Self::Future {
  type ResponseFuture (line 84) | pub struct ResponseFuture<F> {
  function fmt (line 103) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic-web/src/layer.rs
  type GrpcWebLayer (line 7) | pub struct GrpcWebLayer {
    method new (line 13) | pub fn new() -> GrpcWebLayer {
    type Service (line 19) | type Service = GrpcWebService<S>;
    method layer (line 21) | fn layer(&self, inner: S) -> Self::Service {

FILE: tonic-web/src/lib.rs
  type BoxError (line 83) | type BoxError = Box<dyn std::error::Error + Send + Sync>;
  constant STANDARD (line 95) | pub(crate) const STANDARD: GeneralPurpose = GeneralPurpose::new(

FILE: tonic-web/src/service.rs
  type GrpcWebService (line 18) | pub struct GrpcWebService<S> {
  type RequestKind (line 23) | enum RequestKind<'a> {
  function new (line 41) | pub(crate) fn new(inner: S) -> Self {
  type Response (line 54) | type Response = Response<Body>;
  type Error (line 55) | type Error = S::Error;
  type Future (line 56) | type Future = ResponseFuture<S::Future>;
    type Output (line 163) | type Output = Result<Response<Body>, E>;
    method poll (line 165) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 58) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 62) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
  type ResponseFuture (line 125) | pub struct ResponseFuture<F> {
  type Case (line 131) | enum Case<F> {
  function immediate (line 147) | fn immediate(status: StatusCode) -> Self {
  constant NAME (line 184) | const NAME: &'static str = S::NAME;
  function fmt (line 188) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function new (line 194) | fn new(headers: &'a HeaderMap, method: &'a Method, version: Version) -> ...
  function coerce_request (line 210) | fn coerce_request<B>(mut req: Request<B>, encoding: Encoding) -> Request...
  function coerce_response (line 231) | fn coerce_response<B>(res: Response<B>, encoding: Encoding) -> Response<...
  type BoxFuture (line 257) | type BoxFuture<T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + Send>>;
  type Svc (line 260) | struct Svc;
    type Response (line 263) | type Response = Response<Body>;
    type Error (line 264) | type Error = std::convert::Infallible;
    type Future (line 265) | type Future = BoxFuture<Self::Response, Self::Error>;
    method poll_ready (line 267) | fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self:...
    method call (line 271) | fn call(&mut self, _: Request<B>) -> Self::Future {
  constant NAME (line 277) | const NAME: &'static str = "test";
  function enable (line 280) | fn enable<S>(service: S) -> tower_http::cors::Cors<GrpcWebService<S>>
  function request (line 295) | fn request() -> Request<Body> {
  function default_cors_config (line 305) | async fn default_cors_config() {
  function web_layer (line 313) | async fn web_layer() {
  function web_layer_with_axum (line 321) | async fn web_layer_with_axum() {
  function without_origin (line 332) | async fn without_origin() {
  function only_post_and_options_allowed (line 344) | async fn only_post_and_options_allowed() {
  function grpc_web_content_types (line 368) | async fn grpc_web_content_types() {
  function request (line 386) | fn request() -> Request<Body> {
  function valid_grpc_web_preflight (line 397) | async fn valid_grpc_web_preflight() {
  function request (line 408) | fn request() -> Request<Body> {
  function h2_is_ok (line 417) | async fn h2_is_ok() {
  function h1_is_err (line 427) | async fn h1_is_err() {
  function content_type_variants (line 440) | async fn content_type_variants() {
  function request (line 460) | fn request() -> Request<Body> {
  function h1_is_err (line 468) | async fn h1_is_err() {
  function h2_is_ok (line 476) | async fn h2_is_ok() {

FILE: tonic-xds/examples/gen_test_proto.rs
  function main (line 7) | fn main() {

FILE: tonic-xds/src/client/channel.rs
  type XdsChannelConfig (line 23) | pub struct XdsChannelConfig {
    method with_target_uri (line 30) | pub fn with_target_uri(mut self, target_uri: XdsUri) -> Self {
  type XdsChannel (line 46) | pub struct XdsChannel<Req, Endpoint, S>
  method fmt (line 65) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 79) | fn clone(&self) -> Self {
  type Response (line 98) | type Response = S::Response;
  type Error (line 99) | type Error = BoxError;
  type Future (line 100) | type Future = BoxFuture<Result<Self::Response, Self::Error>>;
  function poll_ready (line 102) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 106) | fn call(&mut self, request: Request<B>) -> Self::Future {
  type XdsChannelTonicGrpc (line 112) | pub(crate) type XdsChannelTonicGrpc =
  type XdsChannelGrpc (line 117) | pub type XdsChannelGrpc =
  constant _ (line 121) | const _: fn() = || {
  type XdsChannelBuilder (line 129) | pub struct XdsChannelBuilder {
    method with_config (line 137) | pub fn with_config(config: XdsChannelConfig) -> Self {
    method build_channel (line 146) | pub fn build_channel<Req, Endpoint, S>(&self) -> XdsChannel<Req, Endpo...
    method build_tonic_grpc_channel (line 155) | pub(crate) fn build_tonic_grpc_channel(&self) -> XdsChannelTonicGrpc {
    method build_grpc_channel (line 161) | pub fn build_grpc_channel(&self) -> XdsChannelGrpc {
    method build_grpc_channel_from_xds_manager (line 170) | pub(crate) fn build_grpc_channel_from_xds_manager(
  function setup_grpc_servers (line 208) | async fn setup_grpc_servers(
  type MockXdsManager (line 230) | struct MockXdsManager {
    method from_test_servers (line 236) | fn from_test_servers(servers: &[TestServer]) -> Self {
    method discover_cluster (line 259) | fn discover_cluster(
  method route (line 249) | fn route(&self, _input: &RouteInput<'_>) -> BoxFuture<RouteDecision> {
  function send_grpc_requests (line 279) | async fn send_grpc_requests(
  function test_xds_channel_grpc_with_p2c_lb (line 324) | async fn test_xds_channel_grpc_with_p2c_lb() {

FILE: tonic-xds/src/client/cluster.rs
  type RespFut (line 15) | type RespFut<Resp> = BoxFuture<Result<Resp, BoxError>>;
  constant DEFAULT_BUFFER_CAPACITY (line 17) | const DEFAULT_BUFFER_CAPACITY: usize = 1024;
  type ClusterBalancer (line 22) | pub(crate) struct ClusterBalancer<D, Req>
  function new (line 38) | pub(crate) fn new(discover: D) -> Self {
  function len (line 47) | pub(crate) fn len(&self) -> usize {
  type Response (line 62) | type Response = <Balance<D, Req> as Service<Req>>::Response;
  type Error (line 63) | type Error = <Balance<D, Req> as Service<Req>>::Error;
  type Future (line 64) | type Future = RespFut<Self::Response>;
  function poll_ready (line 66) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 70) | fn call(&mut self, req: Req) -> Self::Future {
  type ClusterChannel (line 80) | pub(crate) struct ClusterChannel<Req, Resp>
  method clone (line 94) | fn clone(&self) -> Self {
  function from_balancer (line 107) | pub(crate) fn from_balancer<B>(balancer: B, buffer_cap: usize) -> Self
  type Response (line 121) | type Response = Resp;
  type Error (line 122) | type Error = BoxError;
  type Future (line 123) | type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::E...
  function poll_ready (line 125) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 129) | fn call(&mut self, request: Req) -> Self::Future {
  type ClusterClient (line 135) | pub(crate) struct ClusterClient<Req, Resp>
  method fmt (line 145) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function new (line 159) | pub(crate) fn new<D>(name: String, discover: D) -> Self
  function channel (line 175) | pub(crate) fn channel(&self) -> ClusterChannel<Req, Resp> {
  function name (line 181) | pub(crate) fn name(&self) -> &str {
  type ClusterClientRegistry (line 188) | pub(crate) struct ClusterClientRegistry<Req, Resp>
  function new (line 202) | pub(crate) fn new() -> Self {
  function get_cluster (line 208) | pub(crate) fn get_cluster<F, D>(
  method default (line 239) | fn default() -> Self {
  type ClusterClientRegistryGrpc (line 247) | pub(crate) type ClusterClientRegistryGrpc =

FILE: tonic-xds/src/client/endpoint.rs
  type EndpointHost (line 9) | enum EndpointHost {
    method from (line 16) | fn from(s: String) -> Self {
  type EndpointAddress (line 29) | pub(crate) struct EndpointAddress {
    method new (line 41) | pub(crate) fn new(host: impl Into<String>, port: u16) -> Self {
    method fmt (line 50) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from (line 60) | fn from(addr: SocketAddr) -> Self {
  type InFlightTracker (line 77) | struct InFlightTracker {
    method new (line 82) | fn new(in_flight: Arc<AtomicU64>) -> Self {
  method drop (line 89) | fn drop(&mut self) {
  type EndpointChannel (line 95) | pub(crate) struct EndpointChannel<S> {
  function new (line 104) | pub(crate) fn new(inner: S) -> Self {
  method clone (line 116) | fn clone(&self) -> Self {
  type Response (line 129) | type Response = S::Response;
  type Error (line 130) | type Error = S::Error;
  type Future (line 131) | type Future = BoxFuture<Result<S::Response, S::Error>>;
  function poll_ready (line 133) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 137) | fn call(&mut self, req: Req) -> Self::Future {
  type Metric (line 151) | type Metric = u64;
  method load (line 152) | fn load(&self) -> Self::Metric {

FILE: tonic-xds/src/client/lb.rs
  type LoadBalancingError (line 13) | pub(crate) enum LoadBalancingError {
  type XdsLbService (line 19) | pub(crate) struct XdsLbService<Req, Endpoint, S>
  function new (line 37) | pub(crate) fn new(
  method clone (line 54) | fn clone(&self) -> Self {
  type Response (line 73) | type Response = S::Response;
  type Error (line 74) | type Error = BoxError;
  type Future (line 75) | type Future = BoxFuture<Result<Self::Response, Self::Error>>;
  function poll_ready (line 77) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self:...
  function call (line 84) | fn call(&mut self, request: Request<B>) -> Self::Future {

FILE: tonic-xds/src/client/route.rs
  type RouteInput (line 10) | pub(crate) struct RouteInput<'a> {
  type RouteDecision (line 19) | pub(crate) struct RouteDecision {
  type XdsRoutingService (line 28) | pub(crate) struct XdsRoutingService<S> {
  type Response (line 41) | type Response = S::Response;
  type Error (line 42) | type Error = S::Error;
  type Future (line 43) | type Future = BoxFuture<Result<Self::Response, Self::Error>>;
  function poll_ready (line 45) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 49) | fn call(&mut self, mut request: Request<B>) -> Self::Future {
  type XdsRoutingLayer (line 69) | pub(crate) struct XdsRoutingLayer {
    method new (line 76) | pub(crate) fn new(xds_router: Arc<dyn XdsRouter>) -> Self {
    type Service (line 82) | type Service = XdsRoutingService<S>;
    method layer (line 84) | fn layer(&self, service: S) -> Self::Service {

FILE: tonic-xds/src/common/async_util.rs
  type BoxFuture (line 6) | pub(crate) type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send + '...

FILE: tonic-xds/src/testutil/grpc.rs
  type MyGreeter (line 16) | struct MyGreeter {
  method say_hello (line 22) | async fn say_hello(&self, req: Request<HelloRequest>) -> Result<Response...
  type TestServer (line 30) | pub(crate) struct TestServer {
  constant NAME (line 42) | const NAME: &'static str = "TestServer";
  function spawn_greeter_server (line 46) | pub(crate) async fn spawn_greeter_server(

FILE: tonic-xds/src/testutil/proto/helloworld.rs
  type HelloRequest (line 4) | pub struct HelloRequest {
  type HelloReply (line 10) | pub struct HelloReply {
  type GreeterClient (line 27) | pub struct GreeterClient<T> {
  function connect (line 32) | pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
  function new (line 48) | pub fn new(inner: T) -> Self {
  function with_origin (line 52) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function with_interceptor (line 56) | pub fn with_interceptor<F>(
  function send_compressed (line 79) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 85) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 93) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 101) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function say_hello (line 106) | pub async fn say_hello(
  type Greeter (line 134) | pub trait Greeter: std::marker::Send + std::marker::Sync + 'static {
    method say_hello (line 136) | async fn say_hello(
  type GreeterServer (line 143) | pub struct GreeterServer<T> {
  function new (line 151) | pub fn new(inner: T) -> Self {
  function from_arc (line 154) | pub fn from_arc(inner: Arc<T>) -> Self {
  function with_interceptor (line 163) | pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedServi...
  function accept_compressed (line 171) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 177) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 185) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 193) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  type Response (line 204) | type Response = http::Response<tonic::body::Body>;
  type Error (line 205) | type Error = std::convert::Infallible;
  type Future (line 206) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 207) | fn poll_ready(
  function call (line 213) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  method clone (line 270) | fn clone(&self) -> Self {
  constant SERVICE_NAME (line 282) | pub const SERVICE_NAME: &str = "helloworld.Greeter";
  constant NAME (line 284) | const NAME: &'static str = SERVICE_NAME;

FILE: tonic-xds/src/xds/bootstrap.rs
  constant ENV_BOOTSTRAP_FILE (line 12) | const ENV_BOOTSTRAP_FILE: &str = "GRPC_XDS_BOOTSTRAP";
  constant ENV_BOOTSTRAP_CONFIG (line 14) | const ENV_BOOTSTRAP_CONFIG: &str = "GRPC_XDS_BOOTSTRAP_CONFIG";
  type BootstrapConfig (line 19) | pub(crate) struct BootstrapConfig {
    method new (line 102) | pub(crate) fn new(
    method from_env (line 115) | pub(crate) fn from_env() -> Result<Self, BootstrapError> {
    method from_json (line 130) | pub(crate) fn from_json(json: &str) -> Result<Self, BootstrapError> {
    method validate (line 136) | fn validate(&self) -> Result<(), BootstrapError> {
    method server_uri (line 153) | pub(crate) fn server_uri(&self) -> &str {
    method selected_credential (line 164) | pub(crate) fn selected_credential(&self) -> Option<&ChannelCredentialT...
  type XdsServerConfig (line 29) | pub(crate) struct XdsServerConfig {
  type ChannelCredentialConfig (line 42) | pub(crate) struct ChannelCredentialConfig {
  type ChannelCredentialType (line 54) | pub(crate) enum ChannelCredentialType {
  type NodeConfig (line 63) | pub(crate) struct NodeConfig {
  type LocalityConfig (line 75) | pub(crate) struct LocalityConfig {
  type BootstrapError (line 86) | pub(crate) enum BootstrapError {
  method from (line 180) | fn from(config: NodeConfig) -> Self {
  function minimal_json (line 205) | fn minimal_json() -> &'static str {
  function full_json (line 212) | fn full_json() -> &'static str {
  function parse_minimal (line 236) | fn parse_minimal() {
  function parse_full (line 246) | fn parse_full() {
  function node_from_full_config (line 265) | fn node_from_full_config() {
  function node_from_minimal_config (line 279) | fn node_from_minimal_config() {
  function selected_credential_first_supported_wins (line 288) | fn selected_credential_first_supported_wins() {
  function selected_credential_insecure (line 298) | fn selected_credential_insecure() {
  function selected_credential_none_supported (line 314) | fn selected_credential_none_supported() {
  function selected_credential_empty_creds (line 327) | fn selected_credential_empty_creds() {
  function empty_xds_servers_fails (line 333) | fn empty_xds_servers_fails() {
  function empty_server_uri_fails (line 340) | fn empty_server_uri_fails() {
  function invalid_json_fails (line 347) | fn invalid_json_fails() {
  function missing_required_field_fails (line 353) | fn missing_required_field_fails() {
  function node_without_id (line 360) | fn node_without_id() {

FILE: tonic-xds/src/xds/resource/cluster.rs
  type ClusterResource (line 11) | pub(crate) struct ClusterResource {
    method eds_service_name (line 75) | pub(crate) fn eds_service_name(&self) -> &str {
  type LbPolicy (line 22) | pub(crate) enum LbPolicy {
  type Message (line 28) | type Message = Cluster;
  constant TYPE_URL (line 30) | const TYPE_URL: TypeUrl = TypeUrl::new("type.googleapis.com/envoy.config...
  constant ALL_RESOURCES_REQUIRED_IN_SOTW (line 32) | const ALL_RESOURCES_REQUIRED_IN_SOTW: bool = true;
  method deserialize (line 34) | fn deserialize(bytes: Bytes) -> xds_client::Result<Self::Message> {
  method name (line 38) | fn name(message: &Self::Message) -> &str {
  method validate (line 42) | fn validate(message: Self::Message) -> xds_client::Result<Self> {
  function make_cluster (line 85) | fn make_cluster(name: &str) -> Cluster {
  function test_validate_basic (line 94) | fn test_validate_basic() {
  function test_eds_service_name_defaults_to_cluster_name (line 103) | fn test_eds_service_name_defaults_to_cluster_name() {
  function test_eds_service_name (line 110) | fn test_eds_service_name() {
  function test_least_request_lb_policy (line 126) | fn test_least_request_lb_policy() {
  function test_unsupported_lb_policy_is_rejected (line 137) | fn test_unsupported_lb_policy_is_rejected() {
  function test_validate_empty_name (line 151) | fn test_validate_empty_name() {
  function test_all_resources_required (line 158) | fn test_all_resources_required() {
  function test_deserialize_roundtrip (line 163) | fn test_deserialize_roundtrip() {

FILE: tonic-xds/src/xds/resource/endpoints.rs
  type EndpointsResource (line 18) | pub(crate) struct EndpointsResource {
    method healthy_endpoints (line 175) | pub(crate) fn healthy_endpoints(&self) -> impl Iterator<Item = &Resolv...
  type LocalityEndpoints (line 25) | pub(crate) struct LocalityEndpoints {
  type Locality (line 34) | pub(crate) struct Locality {
  type ResolvedEndpoint (line 42) | pub(crate) struct ResolvedEndpoint {
  type HealthStatus (line 50) | pub(crate) enum HealthStatus {
    method from (line 58) | fn from(value: i32) -> Self {
  type Message (line 71) | type Message = ClusterLoadAssignment;
  constant TYPE_URL (line 73) | const TYPE_URL: TypeUrl =
  constant ALL_RESOURCES_REQUIRED_IN_SOTW (line 76) | const ALL_RESOURCES_REQUIRED_IN_SOTW: bool = false;
  method deserialize (line 78) | fn deserialize(bytes: Bytes) -> xds_client::Result<Self::Message> {
  method name (line 82) | fn name(message: &Self::Message) -> &str {
  method validate (line 86) | fn validate(message: Self::Message) -> xds_client::Result<Self> {
  function validate_lb_endpoint (line 129) | fn validate_lb_endpoint(lb_ep: LbEndpoint) -> xds_client::Result<Option<...
  function make_lb_endpoint (line 195) | fn make_lb_endpoint(ip: &str, port: u32, health: i32) -> LbEndpoint {
  function make_cla (line 213) | fn make_cla(cluster_name: &str) -> ClusterLoadAssignment {
  function test_validate_basic (line 231) | fn test_validate_basic() {
  function test_healthy_endpoints (line 240) | fn test_healthy_endpoints() {
  function test_validate_empty_cluster_name (line 249) | fn test_validate_empty_cluster_name() {
  function test_eds_allows_partial_responses_in_sotw (line 259) | fn test_eds_allows_partial_responses_in_sotw() {
  function test_deserialize_roundtrip (line 266) | fn test_deserialize_roundtrip() {
  function test_endpoint_with_weight (line 274) | fn test_endpoint_with_weight() {

FILE: tonic-xds/src/xds/resource/listener.rs
  type RouteSource (line 16) | pub(crate) enum RouteSource {
  type ListenerResource (line 28) | pub(crate) struct ListenerResource {
    method route_config_name (line 95) | pub(crate) fn route_config_name(&self) -> Option<&str> {
  type Message (line 34) | type Message = Listener;
  constant TYPE_URL (line 36) | const TYPE_URL: TypeUrl = TypeUrl::new("type.googleapis.com/envoy.config...
  constant ALL_RESOURCES_REQUIRED_IN_SOTW (line 38) | const ALL_RESOURCES_REQUIRED_IN_SOTW: bool = true;
  method deserialize (line 40) | fn deserialize(bytes: Bytes) -> xds_client::Result<Self::Message> {
  method name (line 44) | fn name(message: &Self::Message) -> &str {
  method validate (line 48) | fn validate(message: Self::Message) -> xds_client::Result<Self> {
  function make_rds_listener (line 110) | fn make_rds_listener(name: &str, route_config_name: &str) -> Listener {
  function test_validate_rds_listener (line 133) | fn test_validate_rds_listener() {
  function test_validate_missing_api_listener (line 144) | fn test_validate_missing_api_listener() {
  function test_validate_empty_rds_name (line 154) | fn test_validate_empty_rds_name() {
  function test_deserialize_valid (line 161) | fn test_deserialize_valid() {
  function test_deserialize_invalid_bytes (line 170) | fn test_deserialize_invalid_bytes() {
  function test_type_url (line 176) | fn test_type_url() {
  function test_all_resources_required (line 184) | fn test_all_resources_required() {
  function test_validate_inline_route_config (line 189) | fn test_validate_inline_route_config() {

FILE: tonic-xds/src/xds/resource/route_config.rs
  type RouteConfigResource (line 16) | pub(crate) struct RouteConfigResource {
    method cluster_names (line 292) | pub(crate) fn cluster_names(&self) -> HashSet<String> {
  type VirtualHostConfig (line 23) | pub(crate) struct VirtualHostConfig {
  type RouteConfig (line 31) | pub(crate) struct RouteConfig {
  type RouteConfigMatch (line 38) | pub(crate) struct RouteConfigMatch {
  type PathSpecifierConfig (line 46) | pub(crate) enum PathSpecifierConfig {
  type HeaderMatcherConfig (line 54) | pub(crate) struct HeaderMatcherConfig {
  type HeaderMatchSpecifierConfig (line 62) | pub(crate) enum HeaderMatchSpecifierConfig {
  type RouteConfigAction (line 74) | pub(crate) enum RouteConfigAction {
  type WeightedCluster (line 81) | pub(crate) struct WeightedCluster {
  type Message (line 87) | type Message = RouteConfiguration;
  constant TYPE_URL (line 89) | const TYPE_URL: TypeUrl =
  constant ALL_RESOURCES_REQUIRED_IN_SOTW (line 92) | const ALL_RESOURCES_REQUIRED_IN_SOTW: bool = false;
  method deserialize (line 94) | fn deserialize(bytes: Bytes) -> xds_client::Result<Self::Message> {
  method name (line 98) | fn name(message: &Self::Message) -> &str {
  method validate (line 102) | fn validate(message: Self::Message) -> xds_client::Result<Self> {
  function validate_route (line 141) | fn validate_route(
  function validate_route_match (line 175) | fn validate_route_match(rm: RouteMatch) -> xds_client::Result<RouteConfi...
  function validate_header_matcher (line 210) | fn validate_header_matcher(
  function validate_route_action (line 257) | fn validate_route_action(
  function make_route (line 319) | fn make_route(prefix: &str, cluster: &str) -> envoy_types::pb::envoy::co...
  function make_route_config (line 333) | fn make_route_config(name: &str) -> RouteConfiguration {
  function test_validate_basic (line 347) | fn test_validate_basic() {
  function test_cluster_names (line 356) | fn test_cluster_names() {
  function test_validate_empty_domains (line 365) | fn test_validate_empty_domains() {
  function test_validate_empty_cluster_name (line 381) | fn test_validate_empty_cluster_name() {
  function test_validate_exact_path (line 397) | fn test_validate_exact_path() {
  function test_cascade_weighted_clusters (line 431) | fn test_cascade_weighted_clusters() {
  function test_not_all_resources_required (line 482) | fn test_not_all_resources_required() {
  function test_deserialize_roundtrip (line 487) | fn test_deserialize_roundtrip() {
  function test_invalid_regex_fails_validation (line 495) | fn test_invalid_regex_fails_validation() {
  function test_empty_virtual_hosts_fails (line 530) | fn test_empty_virtual_hosts_fails() {

FILE: tonic-xds/src/xds/routing.rs
  type RoutingError (line 23) | pub(crate) enum RoutingError {
  method route (line 35) | pub(crate) fn route(
  constant WILDCARD (line 54) | const WILDCARD: &str = "*";
  function find_best_matching_virtual_host (line 57) | fn find_best_matching_virtual_host<'a>(
  type DomainMatchScore (line 81) | struct DomainMatchScore(DomainMatchType, Reverse<usize>);
  type DomainMatchType (line 85) | enum DomainMatchType {
  function match_domain (line 92) | fn match_domain(authority: &str, pattern: &str) -> Option<DomainMatchSco...
  function route_matches (line 130) | fn route_matches(route: &RouteConfig, path: &str, headers: &http::Header...
  function match_path (line 134) | fn match_path(criteria: &RouteConfigMatch, path: &str) -> bool {
  function match_headers (line 158) | fn match_headers(criteria: &RouteConfigMatch, headers: &http::HeaderMap)...
  function match_header (line 165) | fn match_header(hm: &HeaderMatcherConfig, headers: &http::HeaderMap) -> ...
  function simple_route (line 185) | fn simple_route(prefix: &str, cluster: &str) -> RouteConfig {
  function simple_rc (line 196) | fn simple_rc(virtual_hosts: Vec<VirtualHostConfig>) -> RouteConfigResour...
  function domain_exact (line 204) | fn domain_exact() {
  function domain_case_insensitive (line 214) | fn domain_case_insensitive() {
  function domain_suffix_wildcard (line 224) | fn domain_suffix_wildcard() {
  function domain_prefix_wildcard (line 236) | fn domain_prefix_wildcard() {
  function domain_universal (line 248) | fn domain_universal() {
  function domain_exact_beats_suffix (line 261) | fn domain_exact_beats_suffix() {
  function domain_suffix_beats_universal (line 281) | fn domain_suffix_beats_universal() {
  function domain_longer_suffix_wins (line 301) | fn domain_longer_suffix_wins() {
  function domain_no_match (line 321) | fn domain_no_match() {
  function basic_routing (line 331) | fn basic_routing() {
  function domain_selects_virtual_host (line 344) | fn domain_selects_virtual_host() {
  function no_matching_virtual_host (line 367) | fn no_matching_virtual_host() {
  function first_matching_route_wins (line 380) | fn first_matching_route_wins() {
  function no_matching_route (line 399) | fn no_matching_route() {
  function exact_path_match (line 412) | fn exact_path_match() {
  function regex_path_match (line 432) | fn regex_path_match() {
  function header_matcher_filters_routes (line 454) | fn header_matcher_filters_routes() {
  function weighted_clusters_passed_through (line 485) | fn weighted_clusters_passed_through() {

FILE: tonic-xds/src/xds/uri.rs
  type XdsUriError (line 6) | pub enum XdsUriError {
  type XdsUri (line 17) | pub struct XdsUri {
    method parse (line 45) | pub fn parse(uri: &str) -> Result<Self, XdsUriError> {
  constant XDS_SCHEME (line 22) | const XDS_SCHEME: &str = "xds";

FILE: tonic-xds/src/xds/xds_manager.rs
  type BoxDiscover (line 7) | pub(crate) type BoxDiscover<Endpoint, S> =
  type XdsRouter (line 11) | pub(crate) trait XdsRouter: Send + Sync + 'static {
    method route (line 12) | fn route(&self, input: &RouteInput<'_>) -> BoxFuture<RouteDecision>;
  type XdsClusterDiscovery (line 16) | pub(crate) trait XdsClusterDiscovery<Endpoint, S>: Send + Sync + 'static {
    method discover_cluster (line 17) | fn discover_cluster(&self, cluster_name: &str) -> BoxDiscover<Endpoint...
  type XdsManager (line 23) | pub(crate) trait XdsManager<Endpoint, S>:

FILE: tonic/benches-disabled/benchmarks/compiled_protos/diverse_types.rs
  type GoogleMessage1 (line 2) | pub struct GoogleMessage1 {
  type GoogleMessage1SubMessage (line 87) | pub struct GoogleMessage1SubMessage {

FILE: tonic/benches-disabled/benchmarks/compiled_protos/helloworld.rs
  type HelloRequest (line 3) | pub struct HelloRequest {
  type HelloReply (line 9) | pub struct HelloReply {
  type GreeterClient (line 18) | pub struct GreeterClient<T> {
  function connect (line 23) | pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
  function new (line 40) | pub fn new(inner: T) -> Self {
  function ready (line 45) | pub async fn ready(&mut self) -> Result<(), tonic::Status> {
  function say_hello (line 54) | pub async fn say_hello(
  method clone (line 65) | fn clone(&self) -> Self {
  type Greeter (line 78) | pub trait Greeter: Send + Sync + 'static {
    method say_hello (line 80) | async fn say_hello(
  type GreeterServer (line 89) | pub struct GreeterServer<T: Greeter> {
  type GreeterServerSvc (line 94) | pub struct GreeterServerSvc<T: Greeter> {
  function new (line 99) | pub fn new(inner: T) -> Self {
  function from_shared (line 103) | pub fn from_shared(inner: Arc<T>) -> Self {
  function new (line 108) | pub fn new(inner: Arc<T>) -> Self {
  type Response (line 113) | type Response = GreeterServerSvc<T>;
  type Error (line 114) | type Error = Never;
  type Future (line 115) | type Future = Ready<Result<Self::Response, Self::Error>>;
  function poll_ready (line 116) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self:...
  function call (line 119) | fn call(&mut self, _: R) -> Self::Future {
  type Response (line 124) | type Response = http::Response<tonic::body::BoxBody>;
  type Error (line 125) | type Error = Never;
  type Future (line 126) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 127) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self:...
  function call (line 130) | fn call(&mut self, req: http::Request<HyperBody>) -> Self::Future {

FILE: tonic/benches-disabled/benchmarks/request_response.rs
  function build_request (line 6) | fn build_request(_name: String) {
  function build_response (line 10) | fn build_response(_message: String) {
  function bench_throughput (line 14) | pub fn bench_throughput(c: &mut Criterion) {

FILE: tonic/benches-disabled/benchmarks/request_response_diverse_types.rs
  function build_request (line 6) | fn build_request(_name: String) {
  function bench_throughput (line 75) | pub fn bench_throughput(c: &mut Criterion) {

FILE: tonic/benches-disabled/benchmarks/utils.rs
  function generate_rnd_string (line 4) | pub fn generate_rnd_string(string_size: usize) -> Result<String, Box<dyn...

FILE: tonic/benches/decode.rs
  type MockBody (line 44) | struct MockBody {
    method new (line 50) | fn new(data: Bytes, chunk_size: usize) -> Self {
    method len (line 54) | fn len(&self) -> usize {
    method fmt (line 85) | fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
  type Data (line 60) | type Data = Bytes;
  type Error (line 61) | type Error = Status;
  method poll_frame (line 63) | fn poll_frame(
  method is_end_stream (line 75) | fn is_end_stream(&self) -> bool {
  method size_hint (line 79) | fn size_hint(&self) -> SizeHint {
  type MockDecoder (line 92) | struct MockDecoder {
    method new (line 97) | fn new(message_size: usize) -> Self {
  type Item (line 103) | type Item = Vec<u8>;
  type Error (line 104) | type Error = Status;
  method decode (line 106) | fn decode(&mut self, buf: &mut DecodeBuf<'_>) -> Result<Option<Self::Ite...
  function make_payload (line 113) | fn make_payload(message_length: usize, message_count: usize) -> Bytes {

FILE: tonic/src/body.rs
  type BoxBody (line 8) | type BoxBody = http_body_util::combinators::UnsyncBoxBody<bytes::Bytes, ...
  type Body (line 12) | pub struct Body {
    method from_kind (line 23) | fn from_kind(kind: Kind) -> Self {
    method empty (line 28) | pub const fn empty() -> Self {
    method new (line 33) | pub fn new<B>(body: B) -> Self
    type Data (line 68) | type Data = bytes::Bytes;
    type Error (line 69) | type Error = crate::Status;
    method poll_frame (line 71) | fn poll_frame(
    method size_hint (line 81) | fn size_hint(&self) -> http_body::SizeHint {
    method is_end_stream (line 88) | fn is_end_stream(&self) -> bool {
  type Kind (line 17) | enum Kind {
  method default (line 62) | fn default() -> Self {

FILE: tonic/src/client/grpc.rs
  type Grpc (line 32) | pub struct Grpc<T> {
  type GrpcConfig (line 37) | struct GrpcConfig {
    method prepare_request (line 372) | fn prepare_request(&self, request: Request<Body>, path: PathAndQuery) ...
  function new (line 51) | pub fn new(inner: T) -> Self {
  function with_origin (line 59) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function send_compressed (line 98) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 129) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 159) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 189) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function ready (line 199) | pub async fn ready(&mut self) -> Result<(), T::Error>
  function unary (line 207) | pub async fn unary<M1, M2, C>(
  function client_streaming (line 226) | pub async fn client_streaming<S, M1, M2, C>(
  function server_streaming (line 263) | pub async fn server_streaming<M1, M2, C>(
  function streaming (line 282) | pub async fn streaming<S, M1, M2, C>(
  function create_response (line 323) | fn create_response<M2>(
  method clone (line 430) | fn clone(&self) -> Self {
  function fmt (line 445) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic/src/client/service.rs
  type GrpcService (line 13) | pub trait GrpcService<ReqBody> {
    method poll_ready (line 24) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 29) | fn call(&mut self, request: http::Request<ReqBody>) -> Self::Future;
  type ResponseBody (line 39) | type ResponseBody = ResBody;
  type Error (line 40) | type Error = T::Error;
  type Future (line 41) | type Future = T::Future;
  method poll_ready (line 43) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  method call (line 47) | fn call(&mut self, request: http::Request<ReqBody>) -> Self::Future {

FILE: tonic/src/codec/buffer.rs
  type DecodeBuf (line 6) | pub struct DecodeBuf<'a> {
  type EncodeBuf (line 13) | pub struct EncodeBuf<'a> {
  function new (line 18) | pub(crate) fn new(buf: &'a mut BytesMut, len: usize) -> Self {
  method remaining (line 25) | fn remaining(&self) -> usize {
  method chunk (line 30) | fn chunk(&self) -> &[u8] {
  method advance (line 41) | fn advance(&mut self, cnt: usize) {
  method copy_to_bytes (line 48) | fn copy_to_bytes(&mut self, len: usize) -> Bytes {
  function new (line 56) | pub(crate) fn new(buf: &'a mut BytesMut) -> Self {
  function reserve (line 68) | pub fn reserve(&mut self, additional: usize) {
  method remaining_mut (line 75) | fn remaining_mut(&self) -> usize {
  method advance_mut (line 80) | unsafe fn advance_mut(&mut self, cnt: usize) {
  method chunk_mut (line 85) | fn chunk_mut(&mut self) -> &mut UninitSlice {
  method put (line 90) | fn put<T: Buf>(&mut self, src: T)
  method put_slice (line 98) | fn put_slice(&mut self, src: &[u8]) {
  method put_bytes (line 103) | fn put_bytes(&mut self, val: u8, cnt: usize) {
  function decode_buf (line 113) | fn decode_buf() {
  function encode_buf (line 135) | fn encode_buf() {

FILE: tonic/src/codec/compression.rs
  constant ENCODING_HEADER (line 11) | pub(crate) const ENCODING_HEADER: &str = "grpc-encoding";
  constant ACCEPT_ENCODING_HEADER (line 12) | pub(crate) const ACCEPT_ENCODING_HEADER: &str = "grpc-accept-encoding";
  type EnabledCompressionEncodings (line 18) | pub struct EnabledCompressionEncodings {
    method enable (line 26) | pub fn enable(&mut self, encoding: CompressionEncoding) {
    method pop (line 40) | pub fn pop(&mut self) -> Option<CompressionEncoding> {
    method into_accept_encoding_header_value (line 48) | pub(crate) fn into_accept_encoding_header_value(self) -> Option<http::...
    method is_enabled (line 64) | pub fn is_enabled(&self, encoding: CompressionEncoding) -> bool {
    method is_empty (line 69) | pub fn is_empty(&self) -> bool {
  type CompressionSettings (line 75) | pub(crate) struct CompressionSettings {
  type CompressionEncoding (line 85) | pub enum CompressionEncoding {
    constant ENCODINGS (line 98) | pub(crate) const ENCODINGS: &'static [CompressionEncoding] = &[
    method from_accept_encoding_header (line 108) | pub(crate) fn from_accept_encoding_header(
    method from_encoding_header (line 131) | pub(crate) fn from_encoding_header(
    method as_str (line 176) | pub(crate) fn as_str(self) -> &'static str {
    method into_header_value (line 188) | pub(crate) fn into_header_value(self) -> http::HeaderValue {
    method fmt (line 194) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function split_by_comma (line 199) | fn split_by_comma(s: &str) -> impl Iterator<Item = &str> {
  function compress (line 206) | pub(crate) fn compress(
  function decompress (line 256) | pub(crate) fn decompress(
  type SingleMessageCompressionOverride (line 299) | pub enum SingleMessageCompressionOverride {
  function convert_none_into_header_value (line 318) | fn convert_none_into_header_value() {
  function convert_gzip_into_header_value (line 326) | fn convert_gzip_into_header_value() {
  function convert_zstd_into_header_value (line 344) | fn convert_zstd_into_header_value() {
  function convert_compression_encodings_into_header_value (line 362) | fn convert_compression_encodings_into_header_value() {

FILE: tonic/src/codec/decode.rs
  type Streaming (line 22) | pub struct Streaming<T> {
  type StreamingInner (line 27) | struct StreamingInner {
    method decode_chunk (line 148) | fn decode_chunk(
    method poll_frame (line 257) | fn poll_frame(&mut self, cx: &mut Context<'_>) -> Poll<Result<Option<(...
    method response (line 296) | fn response(&mut self) -> Result<(), Status> {
  type State (line 41) | enum State {
  type Direction (line 51) | enum Direction {
  function new_response (line 60) | pub fn new_response<B, D>(
  function new_empty (line 82) | pub fn new_empty<B, D>(decoder: D, body: B) -> Self
  function new_request (line 93) | pub fn new_request<B, D>(
  function new (line 113) | fn new<B, D>(
  function message (line 338) | pub async fn message(&mut self) -> Result<Option<T>, Status> {
  function trailers (line 361) | pub async fn trailers(&mut self) -> Result<Option<MetadataMap>, Status> {
  function decode_chunk (line 381) | fn decode_chunk(&mut self) -> Result<Option<T>, Status> {
  type Item (line 399) | type Item = Result<T, Status>;
  method poll_next (line 401) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function fmt (line 425) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic/src/codec/encode.rs
  type EncodedBytes (line 23) | struct EncodedBytes<T, U> {
  function new (line 35) | fn new(
  type Item (line 75) | type Item = Result<Bytes, Status>;
  method poll_next (line 77) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function encode_item (line 133) | fn encode_item<T>(
  function finish_encoding (line 181) | fn finish_encoding(
  type Role (line 209) | enum Role {
  type EncodeBody (line 217) | pub struct EncodeBody<T, U> {
  type EncodeState (line 224) | struct EncodeState {
    method trailers (line 282) | fn trailers(&mut self) -> Option<Result<HeaderMap, Status>> {
  function new_client (line 233) | pub fn new_client(
  function new_server (line 257) | pub fn new_server(
  type Data (line 307) | type Data = Bytes;
  type Error (line 308) | type Error = Status;
  method is_end_stream (line 310) | fn is_end_stream(&self) -> bool {
  method poll_frame (line 314) | fn poll_frame(

FILE: tonic/src/codec/mod.rs
  constant DEFAULT_CODEC_BUFFER_SIZE (line 26) | const DEFAULT_CODEC_BUFFER_SIZE: usize = 8 * 1024;
  constant DEFAULT_YIELD_THRESHOLD (line 27) | const DEFAULT_YIELD_THRESHOLD: usize = 32 * 1024;
  type BufferSettings (line 67) | pub struct BufferSettings {
    method new (line 74) | pub fn new(buffer_size: usize, yield_threshold: usize) -> Self {
  method default (line 83) | fn default() -> Self {
  constant HEADER_SIZE (line 94) | pub const HEADER_SIZE: usize =
  constant DEFAULT_MAX_RECV_MESSAGE_SIZE (line 101) | const DEFAULT_MAX_RECV_MESSAGE_SIZE: usize = 4 * 1024 * 1024;
  constant DEFAULT_MAX_SEND_MESSAGE_SIZE (line 102) | const DEFAULT_MAX_SEND_MESSAGE_SIZE: usize = usize::MAX;
  type Codec (line 105) | pub trait Codec {
    method encoder (line 117) | fn encoder(&mut self) -> Self::Encoder;
    method decoder (line 119) | fn decoder(&mut self) -> Self::Decoder;
  type Encoder (line 123) | pub trait Encoder {
    method encode (line 133) | fn encode(&mut self, item: Self::Item, dst: &mut EncodeBuf<'_>) -> Res...
    method buffer_settings (line 136) | fn buffer_settings(&self) -> BufferSettings {
  type Decoder (line 142) | pub trait Decoder {
    method decode (line 154) | fn decode(&mut self, src: &mut DecodeBuf<'_>) -> Result<Option<Self::I...
    method buffer_settings (line 157) | fn buffer_settings(&self) -> BufferSettings {

FILE: tonic/src/codegen.rs
  type StdError (line 11) | pub type StdError = Box<dyn std::error::Error + Send + Sync + 'static>;
  type BoxFuture (line 19) | pub type BoxFuture<T, E> = self::Pin<Box<dyn self::Future<Output = Resul...
  type BoxStream (line 20) | pub type BoxStream<T> =

FILE: tonic/src/extensions.rs
  type GrpcMethod (line 3) | pub struct GrpcMethod<'a> {
  function new (line 11) | pub fn new(service: &'a str, method: &'a str) -> Self {
  function service (line 16) | pub fn service(&self) -> &str {
  function method (line 20) | pub fn method(&self) -> &str {

FILE: tonic/src/lib.rs
  type BoxError (line 131) | pub(crate) type BoxError = Box<dyn std::error::Error + Send + Sync>;
  type Result (line 139) | pub type Result<T, E = Status> = std::result::Result<T, E>;

FILE: tonic/src/metadata/encoding.rs
  type InvalidMetadataValue (line 11) | pub struct InvalidMetadataValue {
    method new (line 192) | pub(crate) fn new() -> Self {
    method fmt (line 198) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Sealed (line 21) | pub trait Sealed {
    method is_empty (line 23) | fn is_empty(value: &[u8]) -> bool;
    method from_bytes (line 26) | fn from_bytes(value: &[u8]) -> Result<HeaderValue, InvalidMetadataValu...
    method from_shared (line 29) | fn from_shared(value: Bytes) -> Result<HeaderValue, InvalidMetadataVal...
    method from_static (line 32) | fn from_static(value: &'static str) -> HeaderValue;
    method decode (line 35) | fn decode(value: &[u8]) -> Result<Bytes, InvalidMetadataValueBytes>;
    method equals (line 38) | fn equals(a: &HeaderValue, b: &[u8]) -> bool;
    method values_equal (line 41) | fn values_equal(a: &HeaderValue, b: &HeaderValue) -> bool;
    method fmt (line 44) | fn fmt(value: &HeaderValue, f: &mut fmt::Formatter<'_>) -> fmt::Result;
  type ValueEncoding (line 48) | pub trait ValueEncoding: Clone + Eq + PartialEq + Hash + self::value_enc...
    method is_valid_key (line 52) | fn is_valid_key(key: &str) -> bool;
    method is_valid_key (line 115) | fn is_valid_key(key: &str) -> bool {
    method is_valid_key (line 184) | fn is_valid_key(key: &str) -> bool {
  type Ascii (line 65) | pub enum Ascii {}
    method is_empty (line 81) | fn is_empty(value: &[u8]) -> bool {
    method from_bytes (line 85) | fn from_bytes(value: &[u8]) -> Result<HeaderValue, InvalidMetadataValu...
    method from_shared (line 89) | fn from_shared(value: Bytes) -> Result<HeaderValue, InvalidMetadataVal...
    method from_static (line 93) | fn from_static(value: &'static str) -> HeaderValue {
    method decode (line 97) | fn decode(value: &[u8]) -> Result<Bytes, InvalidMetadataValueBytes> {
    method equals (line 101) | fn equals(a: &HeaderValue, b: &[u8]) -> bool {
    method values_equal (line 105) | fn values_equal(a: &HeaderValue, b: &HeaderValue) -> bool {
    method fmt (line 109) | fn fmt(value: &HeaderValue, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Binary (line 76) | pub enum Binary {}
    method is_empty (line 121) | fn is_empty(value: &[u8]) -> bool {
    method from_bytes (line 130) | fn from_bytes(value: &[u8]) -> Result<HeaderValue, InvalidMetadataValu...
    method from_shared (line 136) | fn from_shared(value: Bytes) -> Result<HeaderValue, InvalidMetadataVal...
    method from_static (line 140) | fn from_static(value: &'static str) -> HeaderValue {
    method decode (line 151) | fn decode(value: &[u8]) -> Result<Bytes, InvalidMetadataValueBytes> {
    method equals (line 158) | fn equals(a: &HeaderValue, b: &[u8]) -> bool {
    method values_equal (line 166) | fn values_equal(a: &HeaderValue, b: &HeaderValue) -> bool {
    method fmt (line 174) | fn fmt(value: &HeaderValue, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type InvalidMetadataValueBytes (line 208) | pub struct InvalidMetadataValueBytes(InvalidMetadataValue);
    method new (line 213) | pub(crate) fn new() -> Self {
    method fmt (line 219) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic/src/metadata/key.rs
  type MetadataKey (line 19) | pub struct MetadataKey<VE: ValueEncoding> {
  type InvalidMetadataKey (line 28) | pub struct InvalidMetadataKey {
    method new (line 182) | pub fn new() -> InvalidMetadataKey {
    method fmt (line 273) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type AsciiMetadataKey (line 33) | pub type AsciiMetadataKey = MetadataKey<Ascii>;
  type BinaryMetadataKey (line 35) | pub type BinaryMetadataKey = MetadataKey<Binary>;
  function from_bytes (line 41) | pub fn from_bytes(src: &[u8]) -> Result<Self, InvalidMetadataKey> {
  function from_static (line 102) | pub fn from_static(src: &'static str) -> Self {
  function as_str (line 118) | pub fn as_str(&self) -> &str {
  function unchecked_from_header_name_ref (line 126) | pub(crate) fn unchecked_from_header_name_ref(header_name: &HeaderName) -...
  function unchecked_from_header_name (line 134) | pub(crate) fn unchecked_from_header_name(name: HeaderName) -> Self {
  type Err (line 143) | type Err = InvalidMetadataKey;
  method from_str (line 145) | fn from_str(s: &str) -> Result<Self, InvalidMetadataKey> {
  function as_ref (line 151) | fn as_ref(&self) -> &str {
  function as_ref (line 157) | fn as_ref(&self) -> &[u8] {
  function borrow (line 163) | fn borrow(&self) -> &str {
  function fmt (line 169) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 175) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 188) | fn from(src: &'a MetadataKey<VE>) -> MetadataKey<VE> {
  method from (line 195) | fn from(name: MetadataKey<VE>) -> Bytes {
  function eq (line 202) | fn eq(&self, other: &&'a MetadataKey<VE>) -> bool {
  function eq (line 209) | fn eq(&self, other: &MetadataKey<VE>) -> bool {
  function eq (line 229) | fn eq(&self, other: &str) -> bool {
  function eq (line 249) | fn eq(&self, other: &MetadataKey<VE>) -> bool {
  function eq (line 258) | fn eq(&self, other: &&'a str) -> bool {
  function eq (line 267) | fn eq(&self, other: &MetadataKey<VE>) -> bool {
  function test_from_bytes_binary (line 285) | fn test_from_bytes_binary() {
  function test_from_bytes_ascii (line 296) | fn test_from_bytes_ascii() {

FILE: tonic/src/metadata/map.rs
  type MetadataMap (line 37) | pub struct MetadataMap {
    method as_ref (line 42) | fn as_ref(&self) -> &http::HeaderMap {
    method as_mut (line 48) | fn as_mut(&mut self) -> &mut http::HeaderMap {
    constant GRPC_RESERVED_HEADERS (line 217) | pub(crate) const GRPC_RESERVED_HEADERS: [HeaderName; 5] = [
    method new (line 239) | pub fn new() -> Self {
    method from_headers (line 244) | pub fn from_headers(headers: http::HeaderMap) -> Self {
    method into_headers (line 261) | pub fn into_headers(self) -> http::HeaderMap {
    method into_sanitized_headers (line 265) | pub(crate) fn into_sanitized_headers(mut self) -> http::HeaderMap {
    method with_capacity (line 290) | pub fn with_capacity(capacity: usize) -> MetadataMap {
    method len (line 320) | pub fn len(&self) -> usize {
    method keys_len (line 346) | pub fn keys_len(&self) -> usize {
    method is_empty (line 364) | pub fn is_empty(&self) -> bool {
    method clear (line 382) | pub fn clear(&mut self) {
    method capacity (line 403) | pub fn capacity(&self) -> usize {
    method reserve (line 428) | pub fn reserve(&mut self, additional: usize) {
    method get (line 467) | pub fn get<K>(&self, key: K) -> Option<&MetadataValue<Ascii>>
    method get_bin (line 503) | pub fn get_bin<K>(&self, key: K) -> Option<&MetadataValue<Binary>>
    method get_mut (line 541) | pub fn get_mut<K>(&mut self, key: K) -> Option<&mut MetadataValue<Ascii>>
    method get_bin_mut (line 573) | pub fn get_bin_mut<K>(&mut self, key: K) -> Option<&mut MetadataValue<...
    method get_all (line 621) | pub fn get_all<K>(&self, key: K) -> GetAll<'_, Ascii>
    method get_all_bin (line 664) | pub fn get_all_bin<K>(&self, key: K) -> GetAll<'_, Binary>
    method contains_key (line 694) | pub fn contains_key<K>(&self, key: K) -> bool
    method iter (line 726) | pub fn iter(&self) -> Iter<'_> {
    method iter_mut (line 757) | pub fn iter_mut(&mut self) -> IterMut<'_> {
    method keys (line 789) | pub fn keys(&self) -> Keys<'_> {
    method values (line 820) | pub fn values(&self) -> Values<'_> {
    method values_mut (line 850) | pub fn values_mut(&mut self) -> ValuesMut<'_> {
    method entry (line 896) | pub fn entry<K>(&mut self, key: K) -> Result<Entry<'_, Ascii>, Invalid...
    method entry_bin (line 941) | pub fn entry_bin<K>(&mut self, key: K) -> Result<Entry<'_, Binary>, In...
    method generic_entry (line 948) | fn generic_entry<VE: ValueEncoding, K>(
    method insert (line 1014) | pub fn insert<K>(&mut self, key: K, val: MetadataValue<Ascii>) -> Opti...
    method insert_bin (line 1051) | pub fn insert_bin<K>(
    method append (line 1105) | pub fn append<K>(&mut self, key: K, value: MetadataValue<Ascii>) -> bool
    method append_bin (line 1146) | pub fn append_bin<K>(&mut self, key: K, value: MetadataValue<Binary>) ...
    method remove (line 1186) | pub fn remove<K>(&mut self, key: K) -> Option<MetadataValue<Ascii>>
    method remove_bin (line 1220) | pub fn remove_bin<K>(&mut self, key: K) -> Option<MetadataValue<Binary>>
    method merge (line 1227) | pub(crate) fn merge(&mut self, other: MetadataMap) {
  type Iter (line 58) | pub struct Iter<'a> {
  type KeyAndValueRef (line 65) | pub enum KeyAndValueRef<'a> {
  type KeyAndMutValueRef (line 75) | pub enum KeyAndMutValueRef<'a> {
  type IterMut (line 87) | pub struct IterMut<'a> {
  type ValueDrain (line 93) | pub struct ValueDrain<'a, VE: ValueEncoding> {
  type Keys (line 103) | pub struct Keys<'a> {
  type KeyRef (line 110) | pub enum KeyRef<'a> {
  type Values (line 122) | pub struct Values<'a> {
  type ValueRef (line 131) | pub enum ValueRef<'a> {
  type ValuesMut (line 142) | pub struct ValuesMut<'a> {
  type ValueRefMut (line 151) | pub enum ValueRefMut<'a> {
  type ValueIter (line 160) | pub struct ValueIter<'a, VE: ValueEncoding> {
  type ValueIterMut (line 167) | pub struct ValueIterMut<'a, VE: ValueEncoding> {
  type GetAll (line 177) | pub struct GetAll<'a, VE: ValueEncoding> {
  type Entry (line 185) | pub enum Entry<'a, VE: ValueEncoding> {
  type VacantEntry (line 197) | pub struct VacantEntry<'a, VE: ValueEncoding> {
  type OccupiedEntry (line 206) | pub struct OccupiedEntry<'a, VE: ValueEncoding> {
  constant GRPC_TIMEOUT_HEADER (line 211) | pub(crate) const GRPC_TIMEOUT_HEADER: &str = "grpc-timeout";
  type Item (line 1235) | type Item = KeyAndValueRef<'a>;
  method next (line 1237) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1254) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1262) | type Item = KeyAndMutValueRef<'a>;
  method next (line 1264) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1281) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1289) | type Item = MetadataValue<VE>;
  method next (line 1291) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1297) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1305) | type Item = KeyRef<'a>;
  method next (line 1307) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1317) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1327) | type Item = ValueRef<'a>;
  method next (line 1329) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1340) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1348) | type Item = ValueRefMut<'a>;
  method next (line 1350) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1361) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1372) | type Item = &'a MetadataValue<VE>;
  method next (line 1374) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1383) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 1395) | fn next_back(&mut self) -> Option<Self::Item> {
  type Item (line 1411) | type Item = &'a mut MetadataValue<VE>;
  method next (line 1413) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 1424) | fn next_back(&mut self) -> Option<Self::Item> {
  function or_insert (line 1461) | pub fn or_insert(self, default: MetadataValue<VE>) -> &'a mut MetadataVa...
  function or_insert_with (line 1504) | pub fn or_insert_with<F: FnOnce() -> MetadataValue<VE>>(
  function key (line 1526) | pub fn key(&self) -> &MetadataKey<VE> {
  function key (line 1549) | pub fn key(&self) -> &MetadataKey<VE> {
  function into_key (line 1565) | pub fn into_key(self) -> MetadataKey<VE> {
  function insert (line 1586) | pub fn insert(self, value: MetadataValue<VE>) -> &'a mut MetadataValue<V...
  function insert_entry (line 1608) | pub fn insert_entry(self, value: MetadataValue<VE>) -> OccupiedEntry<'a,...
  function key (line 1632) | pub fn key(&self) -> &MetadataKey<VE> {
  function get (line 1659) | pub fn get(&self) -> &MetadataValue<VE> {
  function get_mut (line 1684) | pub fn get_mut(&mut self) -> &mut MetadataValue<VE> {
  function into_mut (line 1711) | pub fn into_mut(self) -> &'a mut MetadataValue<VE> {
  function insert (line 1734) | pub fn insert(&mut self, value: MetadataValue<VE>) -> MetadataValue<VE> {
  function insert_mult (line 1761) | pub fn insert_mult(&mut self, value: MetadataValue<VE>) -> ValueDrain<'_...
  function append (line 1789) | pub fn append(&mut self, value: MetadataValue<VE>) {
  function remove (line 1812) | pub fn remove(self) -> MetadataValue<VE> {
  function remove_entry (line 1838) | pub fn remove_entry(self) -> (MetadataKey<VE>, MetadataValue<VE>) {
  function remove_entry_mult (line 1850) | pub fn remove_entry_mult(self) -> (MetadataKey<VE>, ValueDrain<'a, VE>) {
  function iter (line 1880) | pub fn iter(&self) -> ValueIter<'_, VE> {
  function iter_mut (line 1911) | pub fn iter_mut(&mut self) -> ValueIterMut<'_, VE> {
  type Item (line 1923) | type Item = &'a mut MetadataValue<VE>;
  type IntoIter (line 1924) | type IntoIter = ValueIterMut<'a, VE>;
  method into_iter (line 1926) | fn into_iter(self) -> ValueIterMut<'a, VE> {
  type Item (line 1935) | type Item = &'a MetadataValue<VE>;
  type IntoIter (line 1936) | type IntoIter = ValueIter<'a, VE>;
  method into_iter (line 1938) | fn into_iter(self) -> ValueIter<'a, VE> {
  type Item (line 1944) | type Item = &'a mut MetadataValue<VE>;
  type IntoIter (line 1945) | type IntoIter = ValueIterMut<'a, VE>;
  method into_iter (line 1947) | fn into_iter(self) -> ValueIterMut<'a, VE> {
  function iter (line 1973) | pub fn iter(&self) -> ValueIter<'a, VE> {
  method eq (line 1982) | fn eq(&self, other: &Self) -> bool {
  type Item (line 1991) | type Item = &'a MetadataValue<VE>;
  type IntoIter (line 1992) | type IntoIter = ValueIter<'a, VE>;
  method into_iter (line 1994) | fn into_iter(self) -> ValueIter<'a, VE> {
  type Item (line 2003) | type Item = &'a MetadataValue<VE>;
  type IntoIter (line 2004) | type IntoIter = ValueIter<'a, VE>;
  method into_iter (line 2006) | fn into_iter(self) -> ValueIter<'a, VE> {
  type IntoMetadataKey (line 2022) | pub trait IntoMetadataKey<VE: ValueEncoding>: Sealed<VE> {}
  type Sealed (line 2032) | pub trait Sealed<VE: ValueEncoding> {
    method insert (line 2034) | fn insert(self, map: &mut MetadataMap, val: MetadataValue<VE>)
    method append (line 2038) | fn append(self, map: &mut MetadataMap, val: MetadataValue<VE>) -> bool;
    method get (line 2133) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>>;
    method get_mut (line 2136) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<V...
    method get_all (line 2139) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>>;
    method entry (line 2142) | fn entry(self, map: &mut MetadataMap)
    method remove (line 2146) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>>;
    method contains_key (line 2441) | fn contains_key(&self, map: &MetadataMap) -> bool;
    method contains_key (line 2449) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2459) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2469) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2479) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2489) | fn contains_key(&self, map: &MetadataMap) -> bool {
  function insert (line 2046) | fn insert(
  function append (line 2058) | fn append(self, map: &mut MetadataMap, val: MetadataValue<VE>) -> bool {
  function insert (line 2068) | fn insert(
  function append (line 2079) | fn append(self, map: &mut MetadataMap, val: MetadataValue<VE>) -> bool {
  function insert (line 2089) | fn insert(
  function append (line 2103) | fn append(self, map: &mut MetadataMap, val: MetadataValue<VE>) -> bool {
  type AsMetadataKey (line 2121) | pub trait AsMetadataKey<VE: ValueEncoding>: Sealed<VE> {}
  type Sealed (line 2131) | pub trait Sealed<VE: ValueEncoding> {
    method insert (line 2034) | fn insert(self, map: &mut MetadataMap, val: MetadataValue<VE>)
    method append (line 2038) | fn append(self, map: &mut MetadataMap, val: MetadataValue<VE>) -> bool;
    method get (line 2133) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>>;
    method get_mut (line 2136) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<V...
    method get_all (line 2139) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>>;
    method entry (line 2142) | fn entry(self, map: &mut MetadataMap)
    method remove (line 2146) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>>;
    method contains_key (line 2441) | fn contains_key(&self, map: &MetadataMap) -> bool;
    method contains_key (line 2449) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2459) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2469) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2479) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2489) | fn contains_key(&self, map: &MetadataMap) -> bool {
  function get (line 2154) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>> {
  function get_mut (line 2162) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<VE>> {
  function get_all (line 2170) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>> {
  function entry (line 2176) | fn entry(
  function remove (line 2185) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>> {
  function get (line 2197) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>> {
  function get_mut (line 2205) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<VE>> {
  function get_all (line 2213) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>> {
  function entry (line 2219) | fn entry(
  function remove (line 2228) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>> {
  function get (line 2240) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>> {
  function get_mut (line 2251) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<VE>> {
  function get_all (line 2262) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>> {
  function entry (line 2271) | fn entry(
  function remove (line 2287) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>> {
  method get (line 2302) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>> {
  method get_mut (line 2313) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<VE>> {
  method get_all (line 2324) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>> {
  method entry (line 2333) | fn entry(
  method remove (line 2348) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>> {
  function get (line 2363) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>> {
  function get_mut (line 2374) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<VE>> {
  function get_all (line 2385) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>> {
  function entry (line 2394) | fn entry(
  function remove (line 2409) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>> {
  type AsEncodingAgnosticMetadataKey (line 2428) | pub trait AsEncodingAgnosticMetadataKey: Sealed {}
  type Sealed (line 2439) | pub trait Sealed {
    method insert (line 2034) | fn insert(self, map: &mut MetadataMap, val: MetadataValue<VE>)
    method append (line 2038) | fn append(self, map: &mut MetadataMap, val: MetadataValue<VE>) -> bool;
    method get (line 2133) | fn get(self, map: &MetadataMap) -> Option<&MetadataValue<VE>>;
    method get_mut (line 2136) | fn get_mut(self, map: &mut MetadataMap) -> Option<&mut MetadataValue<V...
    method get_all (line 2139) | fn get_all(self, map: &MetadataMap) -> Option<GetAll<'_, HeaderValue>>;
    method entry (line 2142) | fn entry(self, map: &mut MetadataMap)
    method remove (line 2146) | fn remove(self, map: &mut MetadataMap) -> Option<MetadataValue<VE>>;
    method contains_key (line 2441) | fn contains_key(&self, map: &MetadataMap) -> bool;
    method contains_key (line 2449) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2459) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2469) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2479) | fn contains_key(&self, map: &MetadataMap) -> bool {
    method contains_key (line 2489) | fn contains_key(&self, map: &MetadataMap) -> bool {
  function test_from_headers_takes_http_headers (line 2502) | fn test_from_headers_takes_http_headers() {
  function test_to_headers_encoding (line 2512) | fn test_to_headers_encoding() {
  function test_iter_categorizes_ascii_entries (line 2537) | fn test_iter_categorizes_ascii_entries() {
  function test_iter_categorizes_binary_entries (line 2558) | fn test_iter_categorizes_binary_entries() {
  function test_iter_mut_categorizes_ascii_entries (line 2578) | fn test_iter_mut_categorizes_ascii_entries() {
  function test_iter_mut_categorizes_binary_entries (line 2599) | fn test_iter_mut_categorizes_binary_entries() {
  function test_keys_categorizes_ascii_entries (line 2619) | fn test_keys_categorizes_ascii_entries() {
  function test_keys_categorizes_binary_entries (line 2640) | fn test_keys_categorizes_binary_entries() {
  function test_values_categorizes_ascii_entries (line 2660) | fn test_values_categorizes_ascii_entries() {
  function test_values_categorizes_binary_entries (line 2681) | fn test_values_categorizes_binary_entries() {
  function test_values_mut_categorizes_ascii_entries (line 2698) | fn test_values_mut_categorizes_ascii_entries() {
  function test_values_mut_categorizes_binary_entries (line 2716) | fn test_values_mut_categorizes_binary_entries() {
  function value_drain_is_send_sync (line 2733) | fn value_drain_is_send_sync() {

FILE: tonic/src/metadata/mod.rs
  constant GRPC_CONTENT_TYPE (line 38) | pub const GRPC_CONTENT_TYPE: HeaderValue = HeaderValue::from_static("app...

FILE: tonic/src/metadata/value.rs
  type MetadataValue (line 22) | pub struct MetadataValue<VE: ValueEncoding> {
  type ToStrError (line 34) | pub struct ToStrError {
    method new (line 601) | pub(crate) fn new() -> Self {
    method fmt (line 607) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type AsciiMetadataValue (line 39) | pub type AsciiMetadataValue = MetadataValue<Ascii>;
  type BinaryMetadataValue (line 41) | pub type BinaryMetadataValue = MetadataValue<Binary>;
  function from_static (line 71) | pub fn from_static(src: &'static str) -> Self {
  function from_shared_unchecked (line 87) | pub unsafe fn from_shared_unchecked(src: Bytes) -> Self {
  function is_empty (line 109) | pub fn is_empty(&self) -> bool {
  function to_bytes (line 131) | pub fn to_bytes(&self) -> Result<Bytes, InvalidMetadataValueBytes> {
  function set_sensitive (line 150) | pub fn set_sensitive(&mut self, val: bool) {
  function is_sensitive (line 176) | pub fn is_sensitive(&self) -> bool {
  function as_encoded_bytes (line 197) | pub fn as_encoded_bytes(&self) -> &[u8] {
  function unchecked_from_header_value (line 205) | pub(crate) fn unchecked_from_header_value(value: HeaderValue) -> Self {
  function unchecked_from_header_value_ref (line 216) | pub(crate) fn unchecked_from_header_value_ref(header_value: &HeaderValue...
  function unchecked_from_mut_header_value_ref (line 224) | pub(crate) fn unchecked_from_mut_header_value_ref(header_value: &mut Hea...
  type Error (line 254) | type Error = InvalidMetadataValueBytes;
  function try_from (line 257) | fn try_from(src: &[u8]) -> Result<Self, Self::Error> {
  type Error (line 290) | type Error = InvalidMetadataValueBytes;
  function try_from (line 293) | fn try_from(src: &[u8; N]) -> Result<Self, Self::Error> {
  type Error (line 309) | type Error = InvalidMetadataValueBytes;
  function try_from (line 312) | fn try_from(src: Bytes) -> Result<Self, Self::Error> {
  type Error (line 331) | type Error = InvalidMetadataValueBytes;
  function try_from (line 334) | fn try_from(src: Vec<u8>) -> Result<Self, Self::Error> {
  type Error (line 346) | type Error = InvalidMetadataValue;
  function try_from (line 349) | fn try_from(s: &'a str) -> Result<Self, Self::Error> {
  type Error (line 361) | type Error = InvalidMetadataValue;
  function try_from (line 364) | fn try_from(s: &'a String) -> Result<Self, Self::Error> {
  type Error (line 376) | type Error = InvalidMetadataValue;
  function try_from (line 379) | fn try_from(s: String) -> Result<Self, Self::Error> {
  function from_key (line 398) | pub fn from_key<KeyVE: ValueEncoding>(key: MetadataKey<KeyVE>) -> Self {
  function len (line 417) | pub fn len(&self) -> usize {
  function to_str (line 434) | pub fn to_str(&self) -> Result<&str, ToStrError> {
  function as_bytes (line 449) | pub fn as_bytes(&self) -> &[u8] {
  function from_bytes (line 465) | pub fn from_bytes(src: &[u8]) -> Self {
  function as_ref (line 473) | fn as_ref(&self) -> &[u8] {
  function fmt (line 479) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 486) | fn from(h: MetadataKey<KeyVE>) -> MetadataValue<Ascii> {
  function it_can_insert_metadata_key_as_metadata_value (line 554) | fn it_can_insert_metadata_key_as_metadata_value() {
  type Err (line 571) | type Err = InvalidMetadataValue;
  method from_str (line 574) | fn from_str(s: &str) -> Result<MetadataValue<Ascii>, Self::Err> {
  method from (line 586) | fn from(value: MetadataValue<VE>) -> Bytes {
  function from (line 593) | fn from(t: &'a MetadataValue<VE>) -> Self {
  method hash (line 615) | fn hash<H: Hasher>(&self, state: &mut H) {
  method hash (line 621) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 633) | fn eq(&self, other: &MetadataValue<VE>) -> bool {
  method partial_cmp (line 646) | fn partial_cmp(&self, other: &MetadataValue<VE>) -> Option<cmp::Ordering> {
  method cmp (line 653) | fn cmp(&self, other: &Self) -> cmp::Ordering {
  function eq (line 660) | fn eq(&self, other: &str) -> bool {
  function eq (line 667) | fn eq(&self, other: &[u8]) -> bool {
  function partial_cmp (line 674) | fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
  function partial_cmp (line 681) | fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
  function eq (line 688) | fn eq(&self, other: &MetadataValue<VE>) -> bool {
  function eq (line 695) | fn eq(&self, other: &MetadataValue<VE>) -> bool {
  function partial_cmp (line 702) | fn partial_cmp(&self, other: &MetadataValue<VE>) -> Option<cmp::Ordering> {
  function partial_cmp (line 709) | fn partial_cmp(&self, other: &MetadataValue<VE>) -> Option<cmp::Ordering> {
  function eq (line 716) | fn eq(&self, other: &String) -> bool {
  function partial_cmp (line 723) | fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
  method eq (line 730) | fn eq(&self, other: &MetadataValue<VE>) -> bool {
  method partial_cmp (line 737) | fn partial_cmp(&self, other: &MetadataValue<VE>) -> Option<cmp::Ordering> {
  function eq (line 744) | fn eq(&self, other: &MetadataValue<VE>) -> bool {
  function partial_cmp (line 751) | fn partial_cmp(&self, other: &MetadataValue<VE>) -> Option<cmp::Ordering> {
  function eq (line 761) | fn eq(&self, other: &&'a T) -> bool {
  function partial_cmp (line 771) | fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
  function eq (line 778) | fn eq(&self, other: &MetadataValue<VE>) -> bool {
  function partial_cmp (line 785) | fn partial_cmp(&self, other: &MetadataValue<VE>) -> Option<cmp::Ordering> {
  function test_debug (line 791) | fn test_debug() {
  function test_is_empty (line 810) | fn test_is_empty() {
  function test_from_shared_base64_encodes (line 828) | fn test_from_shared_base64_encodes() {
  function test_value_eq_value (line 834) | fn test_value_eq_value() {
  function test_value_eq_str (line 859) | fn test_value_eq_str() {
  function test_value_eq_bytes (line 879) | fn test_value_eq_bytes() {
  function test_ascii_value_hash (line 897) | fn test_ascii_value_hash() {
  function test_valid_binary_value_hash (line 920) | fn test_valid_binary_value_hash() {
  function test_invalid_binary_value_hash (line 942) | fn test_invalid_binary_value_hash() {

FILE: tonic/src/request.rs
  type Request (line 18) | pub struct Request<T> {
  type IntoRequest (line 53) | pub trait IntoRequest<T>: sealed::Sealed {
    method into_request (line 55) | fn into_request(self) -> Request<T>;
  type IntoStreamingRequest (line 90) | pub trait IntoStreamingRequest: sealed::Sealed {
    method into_streaming_request (line 98) | fn into_streaming_request(self) -> Request<Self::Stream>;
    type Stream (line 371) | type Stream = T;
    type Message (line 372) | type Message = T::Item;
    method into_streaming_request (line 374) | fn into_streaming_request(self) -> Request<Self> {
    type Stream (line 383) | type Stream = T;
    type Message (line 384) | type Message = T::Item;
    method into_streaming_request (line 386) | fn into_streaming_request(self) -> Self {
  function new (line 113) | pub fn new(message: T) -> Self {
  function get_ref (line 122) | pub fn get_ref(&self) -> &T {
  function get_mut (line 127) | pub fn get_mut(&mut self) -> &mut T {
  function metadata (line 132) | pub fn metadata(&self) -> &MetadataMap {
  function metadata_mut (line 137) | pub fn metadata_mut(&mut self) -> &mut MetadataMap {
  function into_inner (line 142) | pub fn into_inner(self) -> T {
  function into_parts (line 147) | pub fn into_parts(self) -> (MetadataMap, Extensions, T) {
  function from_parts (line 152) | pub fn from_parts(metadata: MetadataMap, extensions: Extensions, message...
  function from_http_parts (line 160) | pub(crate) fn from_http_parts(parts: http::request::Parts, message: T) -...
  function from_http (line 169) | pub fn from_http(http: http::Request<T>) -> Self {
  function into_http (line 174) | pub(crate) fn into_http(
  function map (line 196) | pub fn map<F, U>(self, f: F) -> Request<U>
  function local_addr (line 215) | pub fn local_addr(&self) -> Option<SocketAddr> {
  function remote_addr (line 237) | pub fn remote_addr(&self) -> Option<SocketAddr> {
  function peer_certs (line 260) | pub fn peer_certs(&self) -> Option<Arc<Vec<CertificateDer<'static>>>> {
  function set_timeout (line 293) | pub fn set_timeout(&mut self, deadline: Duration) {
  function extensions (line 300) | pub fn extensions(&self) -> &Extensions {
  function extensions_mut (line 350) | pub fn extensions_mut(&mut self) -> &mut Extensions {
  method into_request (line 356) | fn into_request(self) -> Request<Self> {
  function into_request (line 362) | fn into_request(self) -> Request<T> {
  type Sealed (line 394) | pub trait Sealed {}
  function duration_to_grpc_timeout (line 397) | fn duration_to_grpc_timeout(duration: Duration) -> String {
  type SanitizeHeaders (line 433) | pub(crate) enum SanitizeHeaders {
  function reserved_headers_are_excluded (line 446) | fn reserved_headers_are_excluded() {
  function preserves_user_agent (line 466) | fn preserves_user_agent() {
  function duration_to_grpc_timeout_less_than_second (line 485) | fn duration_to_grpc_timeout_less_than_second() {
  function duration_to_grpc_timeout_more_than_second (line 492) | fn duration_to_grpc_timeout_more_than_second() {
  function duration_to_grpc_timeout_a_very_long_time (line 499) | fn duration_to_grpc_timeout_a_very_long_time() {

FILE: tonic/src/response.rs
  type Response (line 7) | pub struct Response<T> {
  function new (line 26) | pub fn new(message: T) -> Self {
  function get_ref (line 35) | pub fn get_ref(&self) -> &T {
  function get_mut (line 40) | pub fn get_mut(&mut self) -> &mut T {
  function metadata (line 45) | pub fn metadata(&self) -> &MetadataMap {
  function metadata_mut (line 50) | pub fn metadata_mut(&mut self) -> &mut MetadataMap {
  function into_inner (line 55) | pub fn into_inner(self) -> T {
  function into_parts (line 60) | pub fn into_parts(self) -> (MetadataMap, T, Extensions) {
  function from_parts (line 65) | pub fn from_parts(metadata: MetadataMap, message: T, extensions: Extensi...
  function from_http (line 73) | pub(crate) fn from_http(res: http::Response<T>) -> Self {
  function into_http (line 82) | pub(crate) fn into_http(self) -> http::Response<T> {
  function map (line 93) | pub fn map<F, U>(self, f: F) -> Response<U>
  function extensions (line 106) | pub fn extensions(&self) -> &Extensions {
  function extensions_mut (line 111) | pub fn extensions_mut(&mut self) -> &mut Extensions {
  function disable_compression (line 124) | pub fn disable_compression(&mut self) {
  function from (line 131) | fn from(inner: T) -> Self {
  function reserved_headers_are_excluded (line 142) | fn reserved_headers_are_excluded() {

FILE: tonic/src/server/grpc.rs
  type Grpc (line 34) | pub struct Grpc<T> {
  function new (line 51) | pub fn new(codec: T) -> Self {
  function accept_compressed (line 88) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 119) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 149) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 179) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function apply_compression_config (line 185) | pub fn apply_compression_config(
  function apply_max_message_size_config (line 203) | pub fn apply_max_message_size_config(
  function unary (line 219) | pub async fn unary<S, B>(
  function server_streaming (line 262) | pub async fn server_streaming<S, B>(
  function client_streaming (line 303) | pub async fn client_streaming<S, B>(
  function streaming (line 336) | pub async fn streaming<S, B>(
  function map_request_unary (line 364) | async fn map_request_unary<B>(
  function map_request_streaming (line 397) | fn map_request_streaming<B>(
  function map_response (line 419) | fn map_response<B>(
  function request_encoding_if_supported (line 458) | fn request_encoding_if_supported<B>(
  function fmt (line 470) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function compression_override_from_response (line 485) | fn compression_override_from_response<B, E>(

FILE: tonic/src/server/mod.rs
  type NamedService (line 21) | pub trait NamedService {
    constant NAME (line 25) | const NAME: &'static str;

FILE: tonic/src/server/service.rs
  type UnaryService (line 10) | pub trait UnaryService<R> {
    method call (line 18) | fn call(&mut self, request: Request<R>) -> Self::Future;
  type Response (line 25) | type Response = M2;
  type Future (line 26) | type Future = T::Future;
  method call (line 28) | fn call(&mut self, request: Request<M1>) -> Self::Future {
  type ServerStreamingService (line 37) | pub trait ServerStreamingService<R> {
    method call (line 48) | fn call(&mut self, request: Request<R>) -> Self::Future;
  type Response (line 56) | type Response = M2;
  type ResponseStream (line 57) | type ResponseStream = S;
  type Future (line 58) | type Future = T::Future;
  method call (line 60) | fn call(&mut self, request: Request<M1>) -> Self::Future {
  type ClientStreamingService (line 69) | pub trait ClientStreamingService<R> {
    method call (line 77) | fn call(&mut self, request: Request<Streaming<R>>) -> Self::Future;
  type Response (line 84) | type Response = M2;
  type Future (line 85) | type Future = T::Future;
  method call (line 87) | fn call(&mut self, request: Request<Streaming<M1>>) -> Self::Future {
  type StreamingService (line 96) | pub trait StreamingService<R> {
    method call (line 107) | fn call(&mut self, request: Request<Streaming<R>>) -> Self::Future;
  type Response (line 115) | type Response = M2;
  type ResponseStream (line 116) | type ResponseStream = S;
  type Future (line 117) | type Future = T::Future;
  method call (line 119) | fn call(&mut self, request: Request<Streaming<M1>>) -> Self::Future {

FILE: tonic/src/service/interceptor.rs
  type Interceptor (line 41) | pub trait Interceptor {
    method call (line 43) | fn call(&mut self, request: crate::Request<()>) -> Result<crate::Reque...
    method call (line 50) | fn call(&mut self, request: crate::Request<()>) -> Result<crate::Reque...
  type InterceptorLayer (line 59) | pub struct InterceptorLayer<I> {
  function new (line 67) | pub fn new(interceptor: I) -> Self {
  type Service (line 76) | type Service = InterceptedService<S, I>;
  function layer (line 78) | fn layer(&self, service: S) -> Self::Service {
  type InterceptedService (line 87) | pub struct InterceptedService<S, I> {
  function new (line 95) | pub fn new(service: S, interceptor: I) -> Self {
  function fmt (line 107) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Response (line 120) | type Response = http::Response<ResponseBody<ResBody>>;
  type Error (line 121) | type Error = S::Error;
  type Future (line 122) | type Future = ResponseFuture<S::Future>;
    type Output (line 197) | type Output = Result<http::Response<ResponseBody<B>>, E>;
    method poll (line 199) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 125) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 129) | fn call(&mut self, req: http::Request<ReqBody>) -> Self::Future {
  constant NAME (line 161) | const NAME: &'static str = S::NAME;
  type ResponseFuture (line 167) | pub struct ResponseFuture<F> {
  function future (line 173) | fn future(future: F) -> Self {
  function status (line 179) | fn status(status: Status) -> Self {
  type Kind (line 188) | enum Kind<F> {
  type ResponseBody (line 214) | pub struct ResponseBody<B> {
  type ResponseBodyKind (line 221) | enum ResponseBodyKind<B> {
  function new (line 227) | fn new(kind: ResponseBodyKind<B>) -> Self {
  function empty (line 231) | fn empty() -> Self {
  function wrap (line 235) | fn wrap(body: B) -> Self {
  type Data (line 241) | type Data = B::Data;
  type Error (line 242) | type Error = B::Error;
  function poll_frame (line 244) | fn poll_frame(
  function size_hint (line 254) | fn size_hint(&self) -> http_body::SizeHint {
  function is_end_stream (line 261) | fn is_end_stream(&self) -> bool {
  function doesnt_remove_headers_from_requests (line 275) | async fn doesnt_remove_headers_from_requests() {
  function handles_intercepted_status_as_response (line 309) | async fn handles_intercepted_status_as_response() {
  function doesnt_change_http_method (line 330) | async fn doesnt_change_http_method() {

FILE: tonic/src/service/layered.rs
  type Layered (line 13) | pub struct Layered<S, T> {
  constant NAME (line 19) | const NAME: &'static str = T::NAME;
  type Response (line 26) | type Response = S::Response;
  type Error (line 27) | type Error = S::Error;
  type Future (line 28) | type Future = S::Future;
  function poll_ready (line 30) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 34) | fn call(&mut self, req: Req) -> Self::Future {
  type LayerExt (line 40) | pub trait LayerExt<L>: sealed::Sealed {
    method named_layer (line 42) | fn named_layer<S>(&self, service: S) -> Layered<L::Service, S>
  method named_layer (line 48) | fn named_layer<S>(&self, service: S) -> Layered<<L>::Service, S>
  type Sealed (line 60) | pub trait Sealed {}
  type TestService (line 69) | struct TestService {}
  constant TEST_SERVICE_NAME (line 71) | const TEST_SERVICE_NAME: &str = "test-service-name";
  constant NAME (line 74) | const NAME: &'static str = TEST_SERVICE_NAME;
  function get_name_of_named_service (line 78) | fn get_name_of_named_service<S: NamedService>(_s: &S) -> &'static str {
  function named_service_is_propagated_to_layered (line 83) | fn named_service_is_propagated_to_layered() {

FILE: tonic/src/service/recover_error.rs
  type RecoverErrorLayer (line 19) | pub struct RecoverErrorLayer {
    method new (line 25) | pub fn new() -> Self {
    type Service (line 31) | type Service = RecoverError<S>;
    method layer (line 33) | fn layer(&self, inner: S) -> Self::Service {
  type RecoverError (line 41) | pub struct RecoverError<S> {
  function new (line 47) | pub fn new(inner: S) -> Self {
  type Response (line 57) | type Response = Response<ResponseBody<ResBody>>;
  type Error (line 58) | type Error = crate::BoxError;
  type Future (line 59) | type Future = ResponseFuture<S::Future>;
    type Output (line 90) | type Output = Result<Response<ResponseBody<ResBody>>, crate::BoxError>;
    method poll (line 92) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 61) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 65) | fn call(&mut self, req: Req) -> Self::Future {
  type ResponseFuture (line 74) | pub struct ResponseFuture<F> {
  function fmt (line 80) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ResponseBody (line 112) | pub struct ResponseBody<B> {
  function fmt (line 118) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function full (line 124) | fn full(inner: B) -> Self {
  function empty (line 128) | const fn empty() -> Self {
  type Data (line 137) | type Data = B::Data;
  type Error (line 138) | type Error = B::Error;
  function poll_frame (line 140) | fn poll_frame(
  function is_end_stream (line 150) | fn is_end_stream(&self) -> bool {
  function size_hint (line 157) | fn size_hint(&self) -> http_body::SizeHint {

FILE: tonic/src/service/router.rs
  type Routes (line 14) | pub struct Routes {
    method new (line 58) | pub fn new<S>(svc: S) -> Self
    method builder (line 73) | pub fn builder() -> RoutesBuilder {
    method add_service (line 78) | pub fn add_service<S>(mut self, svc: S) -> Self
    method prepare (line 99) | pub fn prepare(self) -> Self {
    method into_axum_router (line 106) | pub fn into_axum_router(self) -> axum::Router {
    method axum_router_mut (line 111) | pub fn axum_router_mut(&mut self) -> &mut axum::Router {
    method from (line 133) | fn from(router: axum::Router) -> Self {
    type Response (line 148) | type Response = Response<Body>;
    type Error (line 149) | type Error = Infallible;
    type Future (line 150) | type Future = RoutesFuture;
    method poll_ready (line 153) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 157) | fn call(&mut self, req: Request<B>) -> Self::Future {
  type RoutesBuilder (line 20) | pub struct RoutesBuilder {
    method add_service (line 26) | pub fn add_service<S>(&mut self, svc: S) -> &mut Self
    method routes (line 43) | pub fn routes(self) -> Routes {
    method from (line 117) | fn from(routes: Routes) -> Self {
    method from (line 125) | fn from(router: axum::Router) -> Self {
  method default (line 49) | fn default() -> Self {
  function unimplemented (line 138) | async fn unimplemented() -> Response<Body> {
  type RoutesFuture (line 162) | pub struct RoutesFuture(axum::routing::future::RouteFuture<Infallible>);
    method fmt (line 165) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 171) | type Output = Result<Response<Body>, Infallible>;
  method poll (line 173) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: tonic/src/status.rs
  constant ENCODING_SET (line 13) | const ENCODING_SET: &AsciiSet = &CONTROLS
  type Status (line 38) | pub struct Status(Box<StatusInner>);
    method new (line 172) | pub fn new(code: Code, message: impl Into<String>) -> Status {
    method ok (line 184) | pub fn ok(message: impl Into<String>) -> Status {
    method cancelled (line 189) | pub fn cancelled(message: impl Into<String>) -> Status {
    method unknown (line 197) | pub fn unknown(message: impl Into<String>) -> Status {
    method invalid_argument (line 205) | pub fn invalid_argument(message: impl Into<String>) -> Status {
    method deadline_exceeded (line 214) | pub fn deadline_exceeded(message: impl Into<String>) -> Status {
    method not_found (line 219) | pub fn not_found(message: impl Into<String>) -> Status {
    method already_exists (line 225) | pub fn already_exists(message: impl Into<String>) -> Status {
    method permission_denied (line 234) | pub fn permission_denied(message: impl Into<String>) -> Status {
    method resource_exhausted (line 240) | pub fn resource_exhausted(message: impl Into<String>) -> Status {
    method failed_precondition (line 258) | pub fn failed_precondition(message: impl Into<String>) -> Status {
    method aborted (line 267) | pub fn aborted(message: impl Into<String>) -> Status {
    method out_of_range (line 284) | pub fn out_of_range(message: impl Into<String>) -> Status {
    method unimplemented (line 289) | pub fn unimplemented(message: impl Into<String>) -> Status {
    method internal (line 295) | pub fn internal(message: impl Into<String>) -> Status {
    method unavailable (line 304) | pub fn unavailable(message: impl Into<String>) -> Status {
    method data_loss (line 309) | pub fn data_loss(message: impl Into<String>) -> Status {
    method unauthenticated (line 315) | pub fn unauthenticated(message: impl Into<String>) -> Status {
    method from_error_generic (line 319) | pub(crate) fn from_error_generic(
    method from_error (line 329) | pub fn from_error(err: Box<dyn Error + Send + Sync + 'static>) -> Stat...
    method try_from_error (line 344) | pub fn try_from_error(
    method from_h2_error (line 384) | fn from_h2_error(err: Box<h2::Error>) -> Status {
    method code_from_h2 (line 393) | fn code_from_h2(err: &h2::Error) -> Code {
    method to_h2_error (line 413) | fn to_h2_error(&self) -> h2::Error {
    method from_hyper_error (line 429) | fn from_hyper_error(err: &hyper::Error) -> Option<Status> {
    method map_error (line 455) | pub(crate) fn map_error<E>(err: E) -> Status
    method from_header_map (line 464) | pub fn from_header_map(header_map: &HeaderMap) -> Option<Status> {
    method code (line 512) | pub fn code(&self) -> Code {
    method message (line 517) | pub fn message(&self) -> &str {
    method details (line 522) | pub fn details(&self) -> &[u8] {
    method metadata (line 527) | pub fn metadata(&self) -> &MetadataMap {
    method metadata_mut (line 532) | pub fn metadata_mut(&mut self) -> &mut MetadataMap {
    method to_header_map (line 536) | pub(crate) fn to_header_map(&self) -> Result<HeaderMap, Self> {
    method add_header (line 543) | pub fn add_header(&self, header_map: &mut HeaderMap) -> Result<(), Sel...
    method with_details (line 572) | pub fn with_details(code: Code, message: impl Into<String>, details: B...
    method with_metadata (line 577) | pub fn with_metadata(code: Code, message: impl Into<String>, metadata:...
    method with_details_and_metadata (line 582) | pub fn with_details_and_metadata(
    method set_source (line 599) | pub fn set_source(&mut self, source: Arc<dyn Error + Send + Sync + 'st...
    method into_http (line 605) | pub fn into_http<B: Default>(self) -> http::Response<B> {
    constant GRPC_STATUS (line 616) | pub const GRPC_STATUS: HeaderName = HeaderName::from_static("grpc-stat...
    constant GRPC_MESSAGE (line 618) | pub const GRPC_MESSAGE: HeaderName = HeaderName::from_static("grpc-mes...
    constant GRPC_STATUS_DETAILS (line 620) | pub const GRPC_STATUS_DETAILS: HeaderName = HeaderName::from_static("g...
    method fmt (line 670) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 710) | fn from(err: h2::Error) -> Self {
    method from (line 723) | fn from(err: std::io::Error) -> Self {
    method fmt (line 750) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type StatusInner (line 42) | struct StatusInner {
    method into_status (line 58) | fn into_status(self) -> Status {
    method fmt (line 676) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Code (line 69) | pub enum Code {
    method description (line 135) | pub fn description(&self) -> &'static str {
    method fmt (line 163) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from_i32 (line 823) | pub const fn from_i32(i: i32) -> Code {
    method from_bytes (line 850) | pub fn from_bytes(bytes: &[u8]) -> Code {
    method to_header_value (line 879) | fn to_header_value(self) -> HeaderValue {
    method parse_err (line 901) | fn parse_err() -> Code {
    method from (line 908) | fn from(i: i32) -> Self {
  function find_status_in_source_chain (line 623) | fn find_status_in_source_chain(err: &(dyn Error + 'static)) -> Option<St...
  function invalid_header_value_byte (line 700) | fn invalid_header_value_byte<Error: fmt::Display>(err: Error) -> Status {
  function from (line 717) | fn from(status: Status) -> Self {
  method source (line 767) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  function infer_grpc_status (line 775) | pub(crate) fn infer_grpc_status(
  function from (line 915) | fn from(code: Code) -> i32 {
  type Nested (line 926) | struct Nested(BoxError);
    method fmt (line 929) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 935) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  function from_error_status (line 941) | fn from_error_status() {
  function from_error_unknown (line 950) | fn from_error_unknown() {
  function from_error_nested (line 959) | fn from_error_nested() {
  function from_error_h2 (line 969) | fn from_error_h2() {
  function to_h2_error (line 986) | fn to_h2_error() {
  function code_from_i32 (line 994) | fn code_from_i32() {
  function constructors (line 1010) | fn constructors() {
  function details (line 1037) | fn details() {
  type TimeoutExpired (line 1065) | pub struct TimeoutExpired(pub ());
    method fmt (line 1068) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ConnectError (line 1079) | pub struct ConnectError(pub Box<dyn std::error::Error + Send + Sync>);
    method fmt (line 1082) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 1088) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {

FILE: tonic/src/transport/channel/endpoint.rs
  type EndpointType (line 19) | pub(crate) enum EndpointType {
  type Endpoint (line 28) | pub struct Endpoint {
    method new (line 59) | pub fn new<D>(dst: D) -> Result<Self, Error>
    method new_uri (line 74) | fn new_uri(uri: Uri) -> Self {
    method new_uds (line 103) | fn new_uds(uds_filepath: &str) -> Self {
    method from_static (line 142) | pub fn from_static(s: &'static str) -> Self {
    method from_shared (line 161) | pub fn from_shared(s: impl Into<Bytes>) -> Result<Self, Error> {
    method user_agent (line 188) | pub fn user_agent<T>(self, user_agent: T) -> Result<Self, Error>
    method origin (line 213) | pub fn origin(self, origin: Uri) -> Self {
    method timeout (line 236) | pub fn timeout(self, dur: Duration) -> Self {
    method connect_timeout (line 253) | pub fn connect_timeout(self, dur: Duration) -> Self {
    method tcp_keepalive (line 267) | pub fn tcp_keepalive(self, tcp_keepalive: Option<Duration>) -> Self {
    method tcp_keepalive_interval (line 280) | pub fn tcp_keepalive_interval(self, tcp_keepalive_interval: Option<Dur...
    method tcp_keepalive_retries (line 292) | pub fn tcp_keepalive_retries(self, tcp_keepalive_retries: Option<u32>)...
    method concurrency_limit (line 306) | pub fn concurrency_limit(self, limit: usize) -> Self {
    method rate_limit (line 321) | pub fn rate_limit(self, limit: u64, duration: Duration) -> Self {
    method initial_stream_window_size (line 334) | pub fn initial_stream_window_size(self, sz: impl Into<Option<u32>>) ->...
    method initial_connection_window_size (line 344) | pub fn initial_connection_window_size(self, sz: impl Into<Option<u32>>...
    method buffer_size (line 354) | pub fn buffer_size(self, sz: impl Into<Option<usize>>) -> Self {
    method tls_config (line 363) | pub fn tls_config(self, tls_config: ClientTlsConfig) -> Result<Self, E...
    method tcp_nodelay (line 378) | pub fn tcp_nodelay(self, enabled: bool) -> Self {
    method http2_keep_alive_interval (line 386) | pub fn http2_keep_alive_interval(self, interval: Duration) -> Self {
    method keep_alive_timeout (line 394) | pub fn keep_alive_timeout(self, duration: Duration) -> Self {
    method keep_alive_while_idle (line 402) | pub fn keep_alive_while_idle(self, enabled: bool) -> Self {
    method http2_adaptive_window (line 410) | pub fn http2_adaptive_window(self, enabled: bool) -> Self {
    method http2_max_header_list_size (line 420) | pub fn http2_max_header_list_size(self, size: u32) -> Self {
    method executor (line 430) | pub fn executor<E>(mut self, executor: E) -> Self
    method connector (line 438) | pub(crate) fn connector<C>(&self, c: C) -> service::Connector<C> {
    method local_address (line 449) | pub fn local_address(self, addr: Option<IpAddr>) -> Self {
    method http_connector (line 456) | pub(crate) fn http_connector(&self) -> service::Connector<HttpConnecto...
    method uds_connector (line 468) | pub(crate) fn uds_connector(&self, uds_filepath: &str) -> service::Con...
    method connect (line 473) | pub async fn connect(&self) -> Result<Channel, Error> {
    method connect_lazy (line 486) | pub fn connect_lazy(&self) -> Channel {
    method connect_with_connector (line 502) | pub async fn connect_with_connector<C>(&self, connector: C) -> Result<...
    method connect_with_connector_lazy (line 527) | pub fn connect_with_connector_lazy<C>(&self, connector: C) -> Channel
    method uri (line 553) | pub fn uri(&self) -> &Uri {
    method get_tcp_nodelay (line 561) | pub fn get_tcp_nodelay(&self) -> bool {
    method get_connect_timeout (line 566) | pub fn get_connect_timeout(&self) -> Option<Duration> {
    method get_tcp_keepalive (line 575) | pub fn get_tcp_keepalive(&self) -> Option<Duration> {
    method get_tcp_keepalive_interval (line 580) | pub fn get_tcp_keepalive_interval(&self) -> Option<Duration> {
    method get_tcp_keepalive_retries (line 585) | pub fn get_tcp_keepalive_retries(&self) -> Option<u32> {
    method from (line 591) | fn from(uri: Uri) -> Self {
    type Error (line 597) | type Error = Error;
    method try_from (line 599) | fn try_from(t: Bytes) -> Result<Self, Self::Error> {
    type Error (line 605) | type Error = Error;
    method try_from (line 607) | fn try_from(t: String) -> Result<Self, Self::Error> {
    type Error (line 613) | type Error = Error;
    method try_from (line 615) | fn try_from(t: &'static str) -> Result<Self, Self::Error> {
    method fmt (line 621) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 627) | type Err = Error;
  method from_str (line 629) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: tonic/src/transport/channel/mod.rs
  type BoxFuture (line 39) | type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
  constant DEFAULT_BUFFER_SIZE (line 41) | const DEFAULT_BUFFER_SIZE: usize = 1024;
  type Channel (line 67) | pub struct Channel {
    method builder (line 80) | pub fn builder(uri: Uri) -> Endpoint {
    method from_static (line 90) | pub fn from_static(s: &'static str) -> Endpoint {
    method from_shared (line 101) | pub fn from_shared(s: impl Into<Bytes>) -> Result<Endpoint, InvalidUri> {
    method balance_list (line 110) | pub fn balance_list(list: impl Iterator<Item = Endpoint>) -> Self {
    method balance_channel (line 123) | pub fn balance_channel<K>(capacity: usize) -> (Self, Sender<Change<K, ...
    method balance_channel_with_executor (line 135) | pub fn balance_channel_with_executor<K, E>(
    method new (line 151) | pub fn new<C>(connector: C, endpoint: Endpoint) -> Self
    method connect (line 172) | pub async fn connect<C>(connector: C, endpoint: Endpoint) -> Result<Se...
    method balance (line 191) | pub(crate) fn balance<D, E>(discover: D, buffer_size: usize, executor:...
    type Response (line 209) | type Response = http::Response<Body>;
    type Error (line 210) | type Error = super::Error;
    type Future (line 211) | type Future = ResponseFuture;
    method poll_ready (line 213) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 217) | fn call(&mut self, request: http::Request<Body>) -> Self::Future {
    method fmt (line 235) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ResponseFuture (line 74) | pub struct ResponseFuture {
    method fmt (line 241) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 225) | type Output = Result<Response<Body>, super::Error>;
  method poll (line 227) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: tonic/src/transport/channel/service/add_origin.rs
  type AddOrigin (line 9) | pub(crate) struct AddOrigin<T> {
  function new (line 16) | pub(crate) fn new(inner: T, origin: Uri) -> Self {
  type Response (line 35) | type Response = T::Response;
  type Error (line 36) | type Error = crate::BoxError;
  type Future (line 37) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
  function poll_ready (line 39) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 43) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future {

FILE: tonic/src/transport/channel/service/connection.rs
  type Connection (line 23) | pub(crate) struct Connection {
    method new (line 28) | fn new<C>(connector: C, endpoint: Endpoint, is_lazy: bool) -> Self
    method connect (line 80) | pub(crate) async fn connect<C>(
    method lazy (line 93) | pub(crate) fn lazy<C>(connector: C, endpoint: Endpoint) -> Self
    type Response (line 105) | type Response = Response<Body>;
    type Error (line 106) | type Error = crate::BoxError;
    type Future (line 107) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
    method poll_ready (line 109) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 113) | fn call(&mut self, req: Request<Body>) -> Self::Future {
    method fmt (line 127) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Metric (line 119) | type Metric = usize;
  method load (line 121) | fn load(&self) -> Self::Metric {
  type SendRequest (line 132) | struct SendRequest {
    method from (line 137) | fn from(inner: hyper::client::conn::http2::SendRequest<Body>) -> Self {
    type Response (line 143) | type Response = Response<Body>;
    type Error (line 144) | type Error = crate::BoxError;
    type Future (line 145) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
    method poll_ready (line 147) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 151) | fn call(&mut self, req: Request<Body>) -> Self::Future {
  type MakeSendRequestService (line 158) | struct MakeSendRequestService<C> {
  function new (line 165) | fn new(connector: C, executor: SharedExec, settings: Builder<SharedExec>...
  type Response (line 181) | type Response = SendRequest;
  type Error (line 182) | type Error = crate::BoxError;
  type Future (line 183) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
  function poll_ready (line 185) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 189) | fn call(&mut self, req: Uri) -> Self::Future {

FILE: tonic/src/transport/channel/service/connector.rs
  type Connector (line 17) | pub(crate) struct Connector<C> {
  function new (line 24) | pub(crate) fn new(inner: C, #[cfg(feature = "_tls-any")] tls: Option<Tls...
  type Response (line 40) | type Response = BoxedIo;
  type Error (line 41) | type Error = ConnectError;
  type Future (line 42) | type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
  function poll_ready (line 44) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 50) | fn call(&mut self, uri: Uri) -> Self::Future {
  type HttpsUriWithoutTlsSupport (line 83) | pub(crate) struct HttpsUriWithoutTlsSupport(());
    method fmt (line 87) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic/src/transport/channel/service/discover.rs
  type Change (line 14) | pub enum Change<K, V> {
  type DynamicServiceStream (line 21) | pub(crate) struct DynamicServiceStream<K: Hash + Eq + Clone> {
  function new (line 26) | pub(crate) fn new(changes: Receiver<Change<K, Endpoint>>) -> Self {
  type Item (line 32) | type Item = Result<TowerChange<K, Connection>, crate::BoxError>;
  method poll_next (line 34) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: tonic/src/transport/channel/service/executor.rs
  type SharedExec (line 8) | pub(crate) struct SharedExec {
    method new (line 13) | pub(crate) fn new<E>(exec: E) -> Self
    method tokio (line 22) | pub(crate) fn tokio() -> Self {
    method execute (line 31) | fn execute(&self, fut: F) {

FILE: tonic/src/transport/channel/service/io.rs
  type Io (line 8) | pub(in crate::transport) trait Io:
  type BoxedIo (line 15) | pub(crate) struct BoxedIo(Pin<Box<dyn Io>>);
    method new (line 18) | pub(in crate::transport) fn new<I: Io>(io: I) -> Self {
    method poll_read (line 30) | fn poll_read(
    method poll_write (line 40) | fn poll_write(
    method poll_flush (line 48) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
    method poll_shutdown (line 52) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Po...
    method poll_write_vectored (line 56) | fn poll_write_vectored(
    method is_write_vectored (line 64) | fn is_write_vectored(&self) -> bool {
  method connected (line 24) | fn connected(&self) -> HyperConnected {

FILE: tonic/src/transport/channel/service/reconnect.rs
  type Reconnect (line 12) | pub(crate) struct Reconnect<M, Target>
  type State (line 26) | enum State<F, S> {
  function new (line 37) | pub(crate) fn new(mk_service: M, target: Target, is_lazy: bool) -> Self {
  type Response (line 58) | type Response = S::Response;
  type Error (line 59) | type Error = crate::BoxError;
  type Future (line 60) | type Future = ResponseFuture<S::Future>;
    type Output (line 207) | type Output = Result<T, crate::BoxError>;
    method poll (line 209) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 62) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 140) | fn call(&mut self, request: Request) -> Self::Future {
  function fmt (line 164) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ResponseFuture (line 176) | pub(crate) struct ResponseFuture<F> {
  type Inner (line 183) | enum Inner<F> {
  function new (line 189) | pub(crate) fn new(inner: F) -> Self {
  function error (line 195) | pub(crate) fn error(error: crate::BoxError) -> Self {

FILE: tonic/src/transport/channel/service/tls.rs
  type TlsConnector (line 22) | pub(crate) struct TlsConnector {
    method new (line 31) | pub(crate) fn new(
    method connect (line 107) | pub(crate) async fn connect<I>(&self, io: I) -> Result<BoxedIo, crate:...
    method fmt (line 132) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic/src/transport/channel/service/user_agent.rs
  constant TONIC_USER_AGENT (line 5) | const TONIC_USER_AGENT: &str = concat!("tonic/", env!("CARGO_PKG_VERSION...
  type UserAgent (line 8) | pub(crate) struct UserAgent<T> {
  function new (line 14) | pub(crate) fn new(inner: T, user_agent: Option<HeaderValue>) -> Self {
  type Response (line 33) | type Response = T::Response;
  type Error (line 34) | type Error = T::Error;
  type Future (line 35) | type Future = T::Future;
  function poll_ready (line 37) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 41) | fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
  type Svc (line 66) | struct Svc;
  function sets_default_if_no_custom_user_agent (line 69) | fn sets_default_if_no_custom_user_agent() {
  function prepends_custom_user_agent_to_default (line 77) | fn prepends_custom_user_agent_to_default() {
  type TestSvc (line 84) | struct TestSvc {
    type Response (line 89) | type Response = ();
    type Error (line 90) | type Error = ();
    type Future (line 91) | type Future = std::future::Ready<Result<(), ()>>;
    method poll_ready (line 93) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 97) | fn call(&mut self, req: Request<()>) -> Self::Future {
  function sets_default_user_agent_if_none_present (line 105) | async fn sets_default_user_agent_if_none_present() {
  function sets_custom_user_agent_if_none_present (line 117) | async fn sets_custom_user_agent_if_none_present() {
  function appends_default_user_agent_to_request_user_agent (line 129) | async fn appends_default_user_agent_to_request_user_agent() {
  function appends_custom_user_agent_to_request_user_agent (line 145) | async fn appends_custom_user_agent_to_request_user_agent() {

FILE: tonic/src/transport/channel/tls.rs
  type ClientTlsConfig (line 12) | pub struct ClientTlsConfig {
    method new (line 28) | pub fn new() -> Self {
    method domain_name (line 33) | pub fn domain_name(self, domain_name: impl Into<String>) -> Self {
    method ca_certificate (line 41) | pub fn ca_certificate(self, ca_certificate: Certificate) -> Self {
    method ca_certificates (line 48) | pub fn ca_certificates(self, ca_certificates: impl IntoIterator<Item =...
    method trust_anchor (line 55) | pub fn trust_anchor(self, trust_anchor: TrustAnchor<'static>) -> Self {
    method trust_anchors (line 65) | pub fn trust_anchors(
    method identity (line 74) | pub fn identity(self, identity: Identity) -> Self {
    method assume_http2 (line 83) | pub fn assume_http2(self, assume_http2: bool) -> Self {
    method use_key_log (line 91) | pub fn use_key_log(self) -> Self {
    method with_native_roots (line 100) | pub fn with_native_roots(self) -> Self {
    method with_webpki_roots (line 109) | pub fn with_webpki_roots(self) -> Self {
    method with_enabled_roots (line 117) | pub fn with_enabled_roots(self) -> Self {
    method timeout (line 129) | pub fn timeout(self, timeout: Duration) -> Self {
    method into_tls_connector (line 136) | pub(crate) fn into_tls_connector(self, uri: &Uri) -> Result<TlsConnect...

FILE: tonic/src/transport/channel/uds_connector.rs
  function connect_uds (line 16) | async fn connect_uds(uds_path: String) -> Result<UnixStream, ConnectErro...
  type UnixStream (line 26) | type UnixStream = tokio::io::DuplexStream;
  function connect_uds (line 29) | async fn connect_uds(_uds_path: String) -> Result<UnixStream, ConnectErr...
  type UdsConnector (line 35) | pub(crate) struct UdsConnector {
    method new (line 40) | pub(crate) fn new(uds_filepath: &str) -> Self {
    type Response (line 48) | type Response = TokioIo<UnixStream>;
    type Error (line 49) | type Error = ConnectError;
    type Future (line 50) | type Future = UdsConnecting;
    method poll_ready (line 52) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 56) | fn call(&mut self, _: Uri) -> Self::Future {
  type ConnectResult (line 68) | type ConnectResult = Result<TokioIo<UnixStream>, ConnectError>;
  type UdsConnecting (line 70) | pub(crate) struct UdsConnecting {
  type Output (line 75) | type Output = ConnectResult;
  method poll (line 77) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: tonic/src/transport/error.rs
  type Source (line 3) | type Source = Box<dyn StdError + Send + Sync + 'static>;
  type Error (line 6) | pub struct Error {
    method new (line 27) | pub(crate) fn new(kind: Kind) -> Self {
    method with (line 33) | pub(crate) fn with(mut self, source: impl Into<Source>) -> Self {
    method from_source (line 38) | pub(crate) fn from_source(source: impl Into<crate::BoxError>) -> Self {
    method new_invalid_uri (line 43) | pub(crate) fn new_invalid_uri() -> Self {
    method new_invalid_user_agent (line 48) | pub(crate) fn new_invalid_user_agent() -> Self {
    method description (line 52) | fn description(&self) -> &str {
    method fmt (line 66) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 80) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ErrorImpl (line 10) | struct ErrorImpl {
  type Kind (line 16) | pub(crate) enum Kind {
  method source (line 86) | fn source(&self) -> Option<&(dyn StdError + 'static)> {

FILE: tonic/src/transport/server/conn.rs
  type Connected (line 51) | pub trait Connected {
    method connect_info (line 57) | fn connect_info(&self) -> Self::ConnectInfo;
    type ConnectInfo (line 89) | type ConnectInfo = TcpConnectInfo;
    method connect_info (line 91) | fn connect_info(&self) -> Self::ConnectInfo {
    type ConnectInfo (line 100) | type ConnectInfo = ();
    method connect_info (line 102) | fn connect_info(&self) -> Self::ConnectInfo {}
    type ConnectInfo (line 110) | type ConnectInfo = TlsConnectInfo<T::ConnectInfo>;
    method connect_info (line 112) | fn connect_info(&self) -> Self::ConnectInfo {
  type TcpConnectInfo (line 69) | pub struct TcpConnectInfo {
    method local_addr (line 78) | pub fn local_addr(&self) -> Option<SocketAddr> {
    method remote_addr (line 83) | pub fn remote_addr(&self) -> Option<SocketAddr> {
  type TlsConnectInfo (line 133) | pub struct TlsConnectInfo<T> {
  function get_ref (line 141) | pub fn get_ref(&self) -> &T {
  function get_mut (line 146) | pub fn get_mut(&mut self) -> &mut T {
  function peer_certs (line 151) | pub fn peer_certs(&self) -> Option<Arc<Vec<CertificateDer<'static>>>> {

FILE: tonic/src/transport/server/display_error_stack.rs
  type DisplayErrorStack (line 5) | pub(crate) struct DisplayErrorStack<'a>(pub(crate) &'a (dyn Error + 'sta...
  method fmt (line 8) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function test_display_error_stack (line 28) | fn test_display_error_stack() {

FILE: tonic/src/transport/server/incoming.rs
  type TcpIncoming (line 18) | pub struct TcpIncoming {
    method bind (line 59) | pub fn bind(addr: SocketAddr) -> std::io::Result<Self> {
    method with_nodelay (line 67) | pub fn with_nodelay(self, nodelay: Option<bool>) -> Self {
    method with_keepalive (line 72) | pub fn with_keepalive(self, keepalive_time: Option<Duration>) -> Self {
    method with_keepalive_interval (line 85) | pub fn with_keepalive_interval(self, keepalive_interval: Option<Durati...
    method with_keepalive_retries (line 98) | pub fn with_keepalive_retries(self, keepalive_retries: Option<u32>) ->...
    method local_addr (line 111) | pub fn local_addr(&self) -> std::io::Result<SocketAddr> {
    method from (line 117) | fn from(listener: TcpListener) -> Self {
  type Item (line 130) | type Item = std::io::Result<TcpStream>;
  method poll_next (line 132) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function set_accepted_socket_options (line 144) | fn set_accepted_socket_options(
  function make_keepalive (line 163) | fn make_keepalive(
  function one_tcpincoming_at_a_time (line 231) | async fn one_tcpincoming_at_a_time() {

FILE: tonic/src/transport/server/io_stream.rs
  type State (line 25) | struct State<IO>(TlsAcceptor, JoinSet<Result<ServerIo<IO>, crate::BoxErr...
  type ServerIoStream (line 28) | pub(crate) struct ServerIoStream<S, IO, IE>
  function new (line 42) | pub(crate) fn new(incoming: S, #[cfg(feature = "_tls-any")] tls: Option<...
  function poll_next_without_tls (line 50) | fn poll_next_without_tls(
  type Item (line 77) | type Item = Result<ServerIo<IO>, crate::BoxError>;
  method poll_next (line 80) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method poll_next (line 85) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function handle_tcp_accept_error (line 126) | fn handle_tcp_accept_error(e: impl Into<crate::BoxError>) -> ControlFlow...
  function select (line 147) | async fn select<IO: 'static, IE>(
  type SelectOutput (line 179) | enum SelectOutput<A> {

FILE: tonic/src/transport/server/mod.rs
  type BoxService (line 76) | type BoxService = tower::util::BoxCloneService<Request<Body>, Response<B...
  type TraceInterceptor (line 77) | type TraceInterceptor = Arc<dyn Fn(&http::Request<()>) -> tracing::Span ...
  constant DEFAULT_HTTP2_KEEPALIVE_TIMEOUT (line 79) | const DEFAULT_HTTP2_KEEPALIVE_TIMEOUT: Duration = Duration::from_secs(20);
  type Server (line 90) | pub struct Server<L = Identity> {
    method builder (line 158) | pub fn builder() -> Self {
  method default (line 118) | fn default() -> Self {
  type Router (line 151) | pub struct Router<L = Identity> {
  function tls_config (line 166) | pub fn tls_config(self, tls_config: ServerTlsConfig) -> Result<Self, Err...
  function concurrency_limit_per_connection (line 184) | pub fn concurrency_limit_per_connection(self, limit: usize) -> Self {
  function load_shed (line 208) | pub fn load_shed(self, load_shed: bool) -> Self {
  function timeout (line 224) | pub fn timeout(self, timeout: Duration) -> Self {
  function initial_stream_window_size (line 238) | pub fn initial_stream_window_size(self, sz: impl Into<Option<u32>>) -> S...
  function initial_connection_window_size (line 249) | pub fn initial_connection_window_size(self, sz: impl Into<Option<u32>>) ...
  function max_concurrent_streams (line 263) | pub fn max_concurrent_streams(self, max: impl Into<Option<u32>>) -> Self {
  function max_connection_age (line 284) | pub fn max_connection_age(self, max_connection_age: Duration) -> Self {
  function max_connection_age_grace (line 314) | pub fn max_connection_age_grace(self, max_connection_age_grace: Duration...
  function http2_keepalive_interval (line 331) | pub fn http2_keepalive_interval(self, http2_keepalive_interval: Option<D...
  function http2_keepalive_timeout (line 346) | pub fn http2_keepalive_timeout(mut self, http2_keepalive_timeout: Option...
  function http2_adaptive_window (line 357) | pub fn http2_adaptive_window(self, enabled: Option<bool>) -> Self {
  function http2_max_pending_accept_reset_streams (line 370) | pub fn http2_max_pending_accept_reset_streams(self, max: Option<usize>) ...
  function http2_max_local_error_reset_streams (line 381) | pub fn http2_max_local_error_reset_streams(self, max: Option<usize>) -> ...
  function tcp_keepalive (line 399) | pub fn tcp_keepalive(self, tcp_keepalive: Option<Duration>) -> Self {
  function tcp_keepalive_interval (line 417) | pub fn tcp_keepalive_interval(self, tcp_keepalive_interval: Option<Durat...
  function tcp_keepalive_retries (line 436) | pub fn tcp_keepalive_retries(self, tcp_keepalive_retries: Option<u32>) -...
  function tcp_nodelay (line 447) | pub fn tcp_nodelay(self, enabled: bool) -> Self {
  function http2_max_header_list_size (line 458) | pub fn http2_max_header_list_size(self, max: impl Into<Option<u32>>) -> ...
  function max_frame_size (line 471) | pub fn max_frame_size(self, frame_size: impl Into<Option<u32>>) -> Self {
  function accept_http1 (line 487) | pub fn accept_http1(self, accept_http1: bool) -> Self {
  function trace_fn (line 496) | pub fn trace_fn<F>(self, f: F) -> Self
  function add_service (line 511) | pub fn add_service<S>(&mut self, svc: S) -> Router<L>
  function add_optional_service (line 535) | pub fn add_optional_service<S>(&mut self, svc: Option<S>) -> Router<L>
  function add_routes (line 556) | pub fn add_routes(&mut self, routes: Routes) -> Router<L>
  function layer (line 624) | pub fn layer<NewLayer>(self, new_layer: NewLayer) -> Server<Stack<NewLay...
  function bind_incoming (line 653) | fn bind_incoming(&self, addr: SocketAddr) -> Result<TcpIncoming, super::...
  function serve (line 663) | pub async fn serve<S, ResBody>(self, addr: SocketAddr, svc: S) -> Result...
  function serve_with_shutdown (line 678) | pub async fn serve_with_shutdown<S, F, ResBody>(
  function serve_with_incoming (line 702) | pub async fn serve_with_incoming<S, I, IO, IE, ResBody>(
  function serve_with_incoming_shutdown (line 724) | pub async fn serve_with_incoming_shutdown<S, I, F, IO, IE, ResBody>(
  function serve_internal (line 746) | async fn serve_internal<S, I, F, IO, IE, ResBody>(
  type TimeoutAction (line 883) | enum TimeoutAction {
  function connection_timeout_future (line 888) | async fn connection_timeout_future(
  function serve_connection (line 908) | fn serve_connection<B, IO, S, E>(
  function new (line 971) | pub(crate) fn new(server: Server<L>, routes: Routes) -> Self {
  function add_service (line 979) | pub fn add_service<S>(mut self, svc: S) -> Self
  function add_optional_service (line 999) | pub fn add_optional_service<S>(mut self, svc: Option<S>) -> Self
  function serve (line 1021) | pub async fn serve<ResBody>(self, addr: SocketAddr) -> Result<(), super:...
  function serve_with_shutdown (line 1040) | pub async fn serve_with_shutdown<F: Future<Output = ()>, ResBody>(
  function serve_with_incoming (line 1065) | pub async fn serve_with_incoming<I, IO, IE, ResBody>(
  function serve_with_incoming_shutdown (line 1094) | pub async fn serve_with_incoming_shutdown<I, IO, IE, F, ResBody>(
  function fmt (line 1119) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Svc (line 1125) | struct Svc<S> {
  type Response (line 1137) | type Response = Response<Body>;
  type Error (line 1138) | type Error = crate::BoxError;
  type Future (line 1139) | type Future = SvcFuture<S::Future>;
    type Output (line 1181) | type Output = Result<Response<Body>, crate::BoxError>;
    method poll (line 1183) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 1266) | type Output = F::Output;
    method poll (line 1268) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function poll_ready (line 1141) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 1145) | fn call(&mut self, mut req: Request<Body>) -> Self::Future {
  type SvcFuture (line 1168) | struct SvcFuture<F> {
  function fmt (line 1194) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type MakeSvc (line 1200) | struct MakeSvc<S, IO> {
  type Response (line 1218) | type Response = BoxService;
  type Error (line 1219) | type Error = crate::BoxError;
  type Future (line 1220) | type Future = future::Ready<Result<Self::Response, Self::Error>>;
    type Output (line 1181) | type Output = Result<Response<Body>, crate::BoxError>;
    method poll (line 1183) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
    type Output (line 1266) | type Output = F::Output;
    method poll (line 1268) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
  function poll_ready (line 1222) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self:...
  function call (line 1226) | fn call(&mut self, io: &ServerIo<IO>) -> Self::Future {
  type Fuse (line 1257) | struct Fuse<F> {
  function test_connection_timeout_no_max_age (line 1286) | async fn test_connection_timeout_no_max_age() {
  function test_connection_timeout_with_max_connection_age (line 1299) | async fn test_connection_timeout_with_max_connection_age() {
  function test_connection_timeout_with_max_connection_age_grace (line 1307) | async fn test_connection_timeout_with_max_connection_age_grace() {
  function server_tcp_defaults (line 1332) | fn server_tcp_defaults() {

FILE: tonic/src/transport/server/service/io.rs
  type ConnectInfoLayer (line 13) | pub(crate) struct ConnectInfoLayer<T> {
  function new (line 18) | pub(crate) fn new(connect_info: T) -> Self {
  type Service (line 27) | type Service = ConnectInfo<S, T>;
  function layer (line 29) | fn layer(&self, inner: S) -> Self::Service {
  type ConnectInfo (line 35) | pub(crate) struct ConnectInfo<S, T> {
  function new (line 41) | fn new(inner: S, connect_info: T) -> Self {
  type Response (line 54) | type Response = S::Response;
  type Error (line 55) | type Error = S::Error;
  type Future (line 56) | type Future = S::Future;
  function poll_ready (line 58) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 62) | fn call(&mut self, mut req: http::Request<ReqBody>) -> Self::Future {
  type ServerIo (line 77) | pub(crate) enum ServerIo<IO> {
  type ServerIoConnectInfo (line 83) | pub(crate) enum ServerIoConnectInfo<IO: Connected> {
  method clone (line 90) | fn clone(&self) -> Self {
  function new_io (line 100) | pub(in crate::transport) fn new_io(io: IO) -> Self {
  function new_tls_io (line 105) | pub(in crate::transport) fn new_tls_io(io: TlsStream<IO>) -> Self {
  function connect_info (line 109) | pub(in crate::transport) fn connect_info(&self) -> ServerIoConnectInfo<IO>
  method poll_read (line 125) | fn poll_read(
  method poll_write (line 142) | fn poll_write(
  method poll_flush (line 154) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 162) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_write_vectored (line 170) | fn poll_write_vectored(
  method is_write_vectored (line 182) | fn is_write_vectored(&self) -> bool {

FILE: tonic/src/transport/server/service/tls.rs
  type TlsAcceptor (line 19) | pub(crate) struct TlsAcceptor {
    method new (line 25) | pub(crate) fn new(
    method accept (line 65) | pub(crate) async fn accept<IO>(&self, io: IO) -> Result<TlsStream<IO>,...
    method fmt (line 82) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tonic/src/transport/server/tls.rs
  type ServerTlsConfig (line 8) | pub struct ServerTlsConfig {
    method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 25) | pub fn new() -> Self {
    method identity (line 30) | pub fn identity(self, identity: Identity) -> Self {
    method client_ca_root (line 38) | pub fn client_ca_root(self, cert: Certificate) -> Self {
    method client_auth_optional (line 51) | pub fn client_auth_optional(self, optional: bool) -> Self {
    method ignore_client_order (line 62) | pub fn ignore_client_order(self, ignore_client_order: bool) -> Self {
    method use_key_log (line 70) | pub fn use_key_log(self) -> Self {
    method timeout (line 78) | pub fn timeout(self, timeout: Duration) -> Self {
    method tls_acceptor (line 85) | pub(crate) fn tls_acceptor(&self) -> Result<TlsAcceptor, crate::BoxErr...

FILE: tonic/src/transport/server/unix.rs
  type UdsConnectInfo (line 13) | pub struct UdsConnectInfo {
  type ConnectInfo (line 21) | type ConnectInfo = UdsConnectInfo;
  method connect_info (line 23) | fn connect_info(&self) -> Self::ConnectInfo {

FILE: tonic/src/transport/service/grpc_timeout.rs
  type GrpcTimeout (line 14) | pub(crate) struct GrpcTimeout<S> {
  function new (line 20) | pub(crate) fn new(inner: S, server_timeout: Option<Duration>) -> Self {
  type Response (line 33) | type Response = S::Response;
  type Error (line 34) | type Error = crate::BoxError;
  type Future (line 35) | type Future = ResponseFuture<S::Future>;
    type Output (line 78) | type Output = Result<Res, crate::BoxError>;
    method poll (line 80) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 37) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 41) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
  type ResponseFuture (line 66) | pub(crate) struct ResponseFuture<F> {
  constant SECONDS_IN_HOUR (line 96) | const SECONDS_IN_HOUR: u64 = 60 * 60;
  constant SECONDS_IN_MINUTE (line 97) | const SECONDS_IN_MINUTE: u64 = 60;
  function try_parse_grpc_timeout (line 103) | fn try_parse_grpc_timeout(
  function setup_map_try_parse (line 155) | fn setup_map_try_parse(val: Option<&str>) -> Result<Option<Duration>, He...
  function test_hours (line 166) | fn test_hours() {
  function test_minutes (line 172) | fn test_minutes() {
  function test_seconds (line 178) | fn test_seconds() {
  function test_milliseconds (line 184) | fn test_milliseconds() {
  function test_microseconds (line 190) | fn test_microseconds() {
  function test_nanoseconds (line 196) | fn test_nanoseconds() {
  function test_header_not_present (line 202) | fn test_header_not_present() {
  function test_invalid_unit (line 209) | fn test_invalid_unit() {
  function test_too_many_digits (line 216) | fn test_too_many_digits() {
  function test_invalid_digits (line 223) | fn test_invalid_digits() {
  function fuzz (line 229) | fn fuzz(header_value: HeaderValueGen) -> bool {
  type HeaderValueGen (line 240) | struct HeaderValueGen(String);
  method arbitrary (line 243) | fn arbitrary(g: &mut Gen) -> Self {
  function gen_string (line 250) | fn gen_string(g: &mut Gen, min: usize, max: usize) -> String {

FILE: tonic/src/transport/service/tls.rs
  constant ALPN_H2 (line 8) | pub(crate) const ALPN_H2: &[u8] = b"h2";
  type TlsError (line 11) | pub(crate) enum TlsError {
    method fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function convert_certificate_to_pki_types (line 40) | pub(crate) fn convert_certificate_to_pki_types(
  function convert_identity_to_pki_types (line 48) | pub(crate) fn convert_identity_to_pki_types(

FILE: tonic/src/transport/tls.rs
  type Certificate (line 3) | pub struct Certificate {
    method from_pem (line 18) | pub fn from_pem(pem: impl AsRef<[u8]>) -> Self {
    method get_ref (line 24) | pub fn get_ref(&self) -> &[u8] {
    method get_mut (line 29) | pub fn get_mut(&mut self) -> &mut [u8] {
    method into_inner (line 34) | pub fn into_inner(self) -> Vec<u8> {
    method as_ref (line 40) | fn as_ref(&self) -> &[u8] {
    method as_mut (line 46) | fn as_mut(&mut self) -> &mut [u8] {
  type Identity (line 9) | pub struct Identity {
    method from_pem (line 55) | pub fn from_pem(cert: impl AsRef<[u8]>, key: impl AsRef<[u8]>) -> Self {

FILE: tonic/src/util.rs
  constant STANDARD (line 15) | pub(crate) const STANDARD: GeneralPurpose = GeneralPurpose::new(
  constant STANDARD_NO_PAD (line 22) | pub(crate) const STANDARD_NO_PAD: GeneralPurpose = GeneralPurpose::new(

FILE: xds-client/examples/basic.rs
  type Args (line 50) | struct Args {
  function parse_args (line 58) | fn parse_args() -> Args {
  type Listener (line 97) | pub struct Listener {
  type TlsTransportBuilder (line 109) | struct TlsTransportBuilder {
  type Transport (line 114) | type Transport = TonicTransport;
  method build (line 116) | async fn build(&self, server: &ServerConfig) -> XdsResult<Self::Transpor...
  type Message (line 130) | type Message = ListenerProto;
  constant TYPE_URL (line 132) | const TYPE_URL: TypeUrl = TypeUrl::new("type.googleapis.com/envoy.config...
  method deserialize (line 134) | fn deserialize(bytes: Bytes) -> xds_client::Result<Self::Message> {
  method name (line 138) | fn name(message: &Self::Message) -> &str {
  method validate (line 142) | fn validate(message: Self::Message) -> xds_client::Result<Self> {
  function main (line 161) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: xds-client/src/client/config.rs
  type ServerConfig (line 11) | pub struct ServerConfig {
    method new (line 21) | pub fn new(uri: impl Into<String>) -> Self {
    method uri (line 26) | pub fn uri(&self) -> &str {
  constant DEFAULT_RESOURCE_INITIAL_TIMEOUT (line 32) | pub const DEFAULT_RESOURCE_INITIAL_TIMEOUT: Duration = Duration::from_se...
  type ClientConfig (line 37) | pub struct ClientConfig {
    method new (line 81) | pub fn new(node: Node, server_uri: impl Into<String>) -> Self {
    method with_servers (line 105) | pub fn with_servers(node: Node, servers: Vec<ServerConfig>) -> Self {
    method with_retry_policy (line 130) | pub fn with_retry_policy(mut self, policy: RetryPolicy) -> Self {
    method with_resource_initial_timeout (line 158) | pub fn with_resource_initial_timeout(mut self, timeout: Option<Duratio...

FILE: xds-client/src/client/mod.rs
  type XdsClientBuilder (line 20) | pub struct XdsClientBuilder<TB, C, R> {
  function new (line 34) | pub fn new(config: ClientConfig, transport_builder: TB, codec: C, runtim...
  function build (line 47) | pub fn build(self) -> XdsClient {
  type XdsClient (line 74) | pub struct XdsClient {
    method builder (line 93) | pub fn builder<TB, C, R>(
    method watch (line 136) | pub async fn watch<T: Resource>(&self, name: impl Into<String>) -> Res...
  constant COMMAND_CHANNEL_BUFFER_SIZE (line 84) | const COMMAND_CHANNEL_BUFFER_SIZE: usize = 64;
  constant WATCHER_CHANNEL_BUFFER_SIZE (line 89) | const WATCHER_CHANNEL_BUFFER_SIZE: usize = 16;

FILE: xds-client/src/client/retry.rs
  type RetryPolicy (line 24) | pub struct RetryPolicy {
    method new (line 77) | pub fn new(
    method with_initial_backoff (line 113) | pub fn with_initial_backoff(mut self, duration: Duration) -> Result<Se...
    method with_max_backoff (line 134) | pub fn with_max_backoff(mut self, duration: Duration) -> Result<Self> {
    method with_backoff_multiplier (line 150) | pub fn with_backoff_multiplier(mut self, multiplier: f64) -> Result<Se...
    method with_max_attempts (line 163) | pub fn with_max_attempts(mut self, max_attempts: Option<usize>) -> Self {
    method backoff_duration (line 187) | pub fn backoff_duration(&self, attempt: usize) -> Option<Duration> {
  method default (line 213) | fn default() -> Self {
  type Backoff (line 247) | pub struct Backoff {
    method new (line 254) | pub fn new(policy: RetryPolicy) -> Self {
    method next_backoff (line 261) | pub fn next_backoff(&mut self) -> Option<Duration> {
    method reset (line 271) | pub fn reset(&mut self) {

FILE: xds-client/src/client/watch.rs
  type ProcessingDone (line 44) | pub struct ProcessingDone(Option<oneshot::Sender<()>>);
    method channel (line 51) | pub(crate) fn channel() -> (Self, oneshot::Receiver<()>) {
  method drop (line 58) | fn drop(&mut self) {
  type ResourceEvent (line 72) | pub enum ResourceEvent<T> {
  type ResourceWatcher (line 114) | pub struct ResourceWatcher<T: Resource> {
  function new (line 127) | pub(crate) fn new(
  function next (line 165) | pub async fn next(&mut self) -> Option<ResourceEvent<T>> {
  method drop (line 194) | fn drop(&mut self) {

FILE: xds-client/src/client/worker.rs
  type WatcherId (line 32) | pub struct WatcherId(u64);
    method new (line 36) | pub fn new() -> Self {
  method default (line 42) | fn default() -> Self {
  type WorkerCommand (line 48) | pub(crate) enum WorkerCommand {
  type SubscriptionMode (line 84) | enum SubscriptionMode {
    method resource_names_for_request (line 96) | fn resource_names_for_request(&self) -> Vec<String> {
  type ResourceState (line 106) | enum ResourceState {
  type CachedResource (line 119) | struct CachedResource {
    method requested (line 129) | fn requested() -> Self {
    method received (line 137) | fn received(resource: Arc<DecodedResource>) -> Self {
    method does_not_exist (line 145) | fn does_not_exist() -> Self {
    method nacked (line 153) | fn nacked(error: String) -> Self {
    method is_requested (line 161) | fn is_requested(&self) -> bool {
    method to_event (line 167) | fn to_event(&self) -> Option<ResourceEvent<DecodedResource>> {
  type TypeState (line 192) | struct TypeState {
    method fmt (line 210) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 227) | fn new(decoder: DecoderFn, all_resources_required_in_sotw: bool) -> Se...
    method recalculate_subscriptions (line 240) | fn recalculate_subscriptions(&mut self) {
    method resource_names_for_request (line 262) | fn resource_names_for_request(&self) -> Vec<String> {
    method matching_watchers (line 267) | fn matching_watchers(&self, name: &str) -> Vec<mpsc::Sender<ResourceEv...
  type WatcherSubscription (line 278) | enum WatcherSubscription {
    method from_name (line 288) | fn from_name(name: String) -> Self {
    method matches (line 297) | fn matches(&self, resource_name: &str) -> bool {
    method is_wildcard (line 305) | fn is_wildcard(&self) -> bool {
  type WatcherEntry (line 312) | struct WatcherEntry {
  type AdsWorker (line 320) | pub(crate) struct AdsWorker<TB, C, R> {
  function new (line 354) | pub(crate) fn new(
  function run (line 381) | pub(crate) async fn run(mut self) {
  function build_initial_requests (line 451) | fn build_initial_requests(&self) -> Vec<Bytes> {
  function run_connected (line 482) | async fn run_connected<S: TransportStream>(&mut self, mut stream: S) -> ...
  function handle_command (line 512) | async fn handle_command<S: TransportStream>(
  function add_watcher (line 556) | fn add_watcher(
  function remove_watcher (line 619) | fn remove_watcher(&mut self, watcher_id: WatcherId) -> Option<(String, b...
  function send_request (line 645) | async fn send_request<S: TransportStream>(&self, stream: &mut S, type_ur...
  function handle_response (line 673) | async fn handle_response<S: TransportStream>(
  function dispatch_resources (line 776) | async fn dispatch_resources(
  function notify_resource_error (line 832) | async fn notify_resource_error(&mut self, type_url: &str, resource_name:...
  function detect_deleted_resources (line 862) | async fn detect_deleted_resources(
  function send_ack (line 907) | async fn send_ack<S: TransportStream>(
  function send_nack (line 932) | async fn send_nack<S: TransportStream>(
  function start_resource_timer (line 967) | fn start_resource_timer(&mut self, type_url: &str, name: String, timeout...
  function handle_resource_timeout (line 999) | async fn handle_resource_timeout(&mut self, type_url: &str, name: &str) {

FILE: xds-client/src/codec/mod.rs
  type XdsCodec (line 19) | pub trait XdsCodec: Send + Sync + 'static {
    method encode_request (line 21) | fn encode_request(&self, request: &DiscoveryRequest<'_>) -> Result<Byt...
    method decode_response (line 24) | fn decode_response(&self, bytes: Bytes) -> Result<DiscoveryResponse>;

FILE: xds-client/src/codec/prost.rs
  type ProstCodec (line 11) | pub struct ProstCodec;
  method encode_request (line 14) | fn encode_request(&self, request: &DiscoveryRequest<'_>) -> Result<Bytes> {
  method decode_response (line 49) | fn decode_response(&self, bytes: Bytes) -> Result<DiscoveryResponse> {
  function test_encode_request_minimal (line 76) | fn test_encode_request_minimal() {
  function test_encode_request_with_node (line 100) | fn test_encode_request_with_node() {
  function test_decode_response (line 143) | fn test_decode_response() {
  function test_roundtrip (line 178) | fn test_roundtrip() {

FILE: xds-client/src/error.rs
  type Error (line 7) | pub enum Error {
  type Result (line 38) | pub type Result<T> = std::result::Result<T, Error>;

FILE: xds-client/src/message.rs
  type DiscoveryRequest (line 14) | pub struct DiscoveryRequest<'a> {
  type DiscoveryResponse (line 33) | pub struct DiscoveryResponse {
  type ResourceAny (line 46) | pub struct ResourceAny {
  type Node (line 55) | pub struct Node {
    method new (line 72) | pub fn new(user_agent_name: impl Into<String>, user_agent_version: imp...
    method with_id (line 83) | pub fn with_id(mut self, id: impl Into<String>) -> Self {
    method with_cluster (line 89) | pub fn with_cluster(mut self, cluster: impl Into<String>) -> Self {
    method with_locality (line 95) | pub fn with_locality(mut self, locality: Locality) -> Self {
  type Locality (line 103) | pub struct Locality {
  type ErrorDetail (line 114) | pub struct ErrorDetail {

FILE: xds-client/src/resource/mod.rs
  type TypeUrl (line 16) | pub struct TypeUrl(&'static str);
    method new (line 20) | pub const fn new(url: &'static str) -> Self {
    method as_str (line 25) | pub const fn as_str(&self) -> &'static str {
  type DecodeResult (line 41) | pub enum DecodeResult<T> {
  type Resource (line 126) | pub trait Resource: Sized + Send + Sync + 'static {
    constant TYPE_URL (line 131) | const TYPE_URL: TypeUrl;
    constant ALL_RESOURCES_REQUIRED_IN_SOTW (line 144) | const ALL_RESOURCES_REQUIRED_IN_SOTW: bool = true;
    method deserialize (line 150) | fn deserialize(bytes: Bytes) -> Result<Self::Message, Error>;
    method name (line 153) | fn name(message: &Self::Message) -> &str;
    method validate (line 160) | fn validate(message: Self::Message) -> Result<Self, Error>;
  function decode (line 170) | pub(crate) fn decode<T: Resource>(bytes: Bytes) -> DecodeResult<T> {
  type DecodedResource (line 192) | pub struct DecodedResource {
    method new (line 200) | pub fn new<T: Resource>(name: String, resource: T) -> Self {
    method type_url (line 209) | pub fn type_url(&self) -> &'static str {
    method name (line 214) | pub fn name(&self) -> &str {
    method downcast (line 228) | pub fn downcast<T: Resource>(&self) -> Option<Arc<T>> {
    method downcast_ref (line 235) | pub fn downcast_ref<T: Resource>(&self) -> Option<&T> {
  type DecoderFn (line 246) | pub type DecoderFn = Box<dyn Fn(Bytes) -> DecodeResult<DecodedResource> ...

FILE: xds-client/src/runtime/mod.rs
  type Runtime (line 13) | pub trait Runtime: Send + Sync + Clone + 'static {
    method spawn (line 15) | fn spawn<F>(&self, future: F)
    method sleep (line 20) | fn sleep(&self, duration: Duration) -> impl Future<Output = ()> + Send;

FILE: xds-client/src/runtime/tokio.rs
  type TokioRuntime (line 9) | pub struct TokioRuntime;
  method spawn (line 12) | fn spawn<F>(&self, future: F)
  method sleep (line 19) | async fn sleep(&self, duration: Duration) {

FILE: xds-client/src/transport/mod.rs
  type Sealed (line 12) | pub trait Sealed {}
  type Transport (line 22) | pub trait Transport: Send + Sync + 'static {
    method new_stream (line 35) | fn new_stream(
  type TransportStream (line 46) | pub trait TransportStream: sealed::Sealed + Send + 'static {
    method send (line 48) | fn send(&mut self, request: Bytes) -> impl Future<Output = Result<()>>...
    method recv (line 56) | fn recv(&mut self) -> impl Future<Output = Result<Option<Bytes>>> + Send;
  type TransportBuilder (line 87) | pub trait TransportBuilder: Send + Sync + 'static {
    method build (line 95) | fn build(&self, server: &ServerConfig) -> impl Future<Output = Result<...

FILE: xds-client/src/transport/tonic.rs
  constant ADS_PATH (line 20) | const ADS_PATH: &str =
  constant ADS_CHANNEL_BUFFER_SIZE (line 23) | const ADS_CHANNEL_BUFFER_SIZE: usize = 16;
  type BytesCodec (line 30) | struct BytesCodec;
  type Encode (line 33) | type Encode = Bytes;
  type Decode (line 34) | type Decode = Bytes;
  type Encoder (line 35) | type Encoder = BytesEncoder;
  type Decoder (line 36) | type Decoder = BytesDecoder;
  method encoder (line 38) | fn encoder(&mut self) -> Self::Encoder {
  method decoder (line 42) | fn decoder(&mut self) -> Self::Decoder {
  type BytesEncoder (line 48) | struct BytesEncoder;
  type Item (line 51) | type Item = Bytes;
  type Error (line 52) | type Error = Status;
  method encode (line 54) | fn encode(
  type BytesDecoder (line 65) | struct BytesDecoder;
  type Item (line 68) | type Item = Bytes;
  type Error (line 69) | type Error = Status;
  method decode (line 71) | fn decode(
  type TonicTransport (line 81) | pub struct TonicTransport {
    method from_channel (line 106) | pub fn from_channel(channel: Channel) -> Self {
    method connect (line 113) | pub async fn connect(uri: impl Into<String>) -> Result<Self> {
  type TonicTransportBuilder (line 142) | pub struct TonicTransportBuilder {
    method new (line 153) | pub fn new() -> Self {
  type Transport (line 159) | type Transport = TonicTransport;
  method build (line 161) | async fn build(&self, server: &ServerConfig) -> Result<Self::Transport> {
  type Stream (line 173) | type Stream = TonicAdsStream;
  method new_stream (line 175) | async fn new_stream(&self, initial_requests: Vec<Bytes>) -> Result<Self:...
  type TonicAdsStream (line 208) | pub struct TonicAdsStream {
  method send (line 214) | async fn send(&mut self, request: Bytes) -> Result<()> {
  method recv (line 222) | async fn recv(&mut self) -> Result<Option<Bytes>> {
  type MockAdsServer (line 248) | struct MockAdsServer;
  type StreamAggregatedResourcesStream (line 252) | type StreamAggregatedResourcesStream =
  method stream_aggregated_resources (line 255) | async fn stream_aggregated_resources(
  type DeltaAggregatedResourcesStream (line 278) | type DeltaAggregatedResourcesStream =
  method delta_aggregated_resources (line 281) | async fn delta_aggregated_resources(
  function start_mock_server (line 289) | async fn start_mock_server() -> SocketAddr {
  function test_tonic_transport_connect_and_stream (line 307) | async fn test_tonic_transport_connect_and_stream() {