Full Code of hyperium/tonic for AI

gitextract_d8h12mxx/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── workflows/
│       └── CI.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── README.md
├── SECURITY.md
├── codegen/
│   ├── Cargo.toml
│   └── src/
│       └── main.rs
├── examples/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   ├── data/
│   │   ├── gcp/
│   │   │   └── roots.pem
│   │   ├── route_guide_db.json
│   │   └── tls/
│   │       ├── ca.key
│   │       ├── ca.pem
│   │       ├── client1.key
│   │       ├── client1.pem
│   │       ├── client2.key
│   │       ├── client2.pem
│   │       ├── client_ca.key
│   │       ├── client_ca.pem
│   │       ├── create.sh
│   │       ├── openssl.cnf
│   │       ├── server.key
│   │       ├── server.pem
│   │       ├── server2.key
│   │       └── server2.pem
│   ├── helloworld-tutorial.md
│   ├── proto/
│   │   ├── attrs/
│   │   │   └── attrs.proto
│   │   ├── echo/
│   │   │   └── echo.proto
│   │   ├── googleapis/
│   │   │   └── google/
│   │   │       ├── api/
│   │   │       │   ├── annotations.proto
│   │   │       │   ├── client.proto
│   │   │       │   ├── field_behavior.proto
│   │   │       │   ├── http.proto
│   │   │       │   └── resource.proto
│   │   │       └── pubsub/
│   │   │           └── v1/
│   │   │               ├── pubsub.proto
│   │   │               └── schema.proto
│   │   ├── helloworld/
│   │   │   └── helloworld.proto
│   │   ├── routeguide/
│   │   │   └── route_guide.proto
│   │   └── unaryecho/
│   │       └── echo.proto
│   ├── routeguide-tutorial.md
│   └── src/
│       ├── authentication/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── autoreload/
│       │   └── server.rs
│       ├── blocking/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── cancellation/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── codec_buffers/
│       │   ├── client.rs
│       │   ├── common.rs
│       │   └── server.rs
│       ├── compression/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── dynamic/
│       │   └── server.rs
│       ├── dynamic_load_balance/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── gcp/
│       │   ├── README.md
│       │   └── client.rs
│       ├── grpc-web/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── h2c/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── health/
│       │   ├── README.md
│       │   └── server.rs
│       ├── helloworld/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── interceptor/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── json-codec/
│       │   ├── client.rs
│       │   ├── common.rs
│       │   └── server.rs
│       ├── load_balance/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── mock/
│       │   └── mock.rs
│       ├── multiplex/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── reflection/
│       │   └── server.rs
│       ├── richer-error/
│       │   ├── client.rs
│       │   ├── client_vec.rs
│       │   ├── server.rs
│       │   └── server_vec.rs
│       ├── routeguide/
│       │   ├── client.rs
│       │   ├── data.rs
│       │   └── server.rs
│       ├── streaming/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── tls/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── tls_client_auth/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── tls_rustls/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── tower/
│       │   ├── client.rs
│       │   └── server.rs
│       ├── tracing/
│       │   ├── client.rs
│       │   └── server.rs
│       └── uds/
│           ├── client_standard.rs
│           ├── client_with_connector.rs
│           └── server.rs
├── flake.nix
├── grpc/
│   ├── Cargo.toml
│   ├── examples/
│   │   └── inmemory.rs
│   ├── proto/
│   │   └── echo/
│   │       └── echo.proto
│   └── src/
│       ├── attributes/
│       │   ├── linked_list.rs
│       │   └── mod.rs
│       ├── byte_str.rs
│       ├── client/
│       │   ├── channel.rs
│       │   ├── interceptor.rs
│       │   ├── load_balancing/
│       │   │   ├── child_manager.rs
│       │   │   ├── graceful_switch.rs
│       │   │   ├── mod.rs
│       │   │   ├── pick_first.rs
│       │   │   ├── registry.rs
│       │   │   ├── round_robin.rs
│       │   │   └── test_utils.rs
│       │   ├── mod.rs
│       │   ├── name_resolution/
│       │   │   ├── backoff.rs
│       │   │   ├── dns/
│       │   │   │   ├── mod.rs
│       │   │   │   └── test.rs
│       │   │   ├── mod.rs
│       │   │   └── registry.rs
│       │   ├── service_config.rs
│       │   ├── stream_util.rs
│       │   ├── subchannel.rs
│       │   └── transport/
│       │       ├── mod.rs
│       │       ├── registry.rs
│       │       └── tonic/
│       │           ├── mod.rs
│       │           └── test.rs
│       ├── core/
│       │   └── mod.rs
│       ├── credentials/
│       │   ├── call.rs
│       │   ├── client.rs
│       │   ├── dyn_wrapper.rs
│       │   ├── insecure.rs
│       │   ├── local.rs
│       │   ├── mod.rs
│       │   ├── rustls/
│       │   │   ├── client/
│       │   │   │   ├── mod.rs
│       │   │   │   └── test.rs
│       │   │   ├── key_log.rs
│       │   │   ├── mod.rs
│       │   │   ├── server/
│       │   │   │   ├── mod.rs
│       │   │   │   └── test.rs
│       │   │   └── tls_stream.rs
│       │   └── server.rs
│       ├── generated/
│       │   ├── echo_fds.rs
│       │   └── grpc_examples_echo.rs
│       ├── inmemory/
│       │   └── mod.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── rt/
│       │   ├── hyper_wrapper.rs
│       │   ├── mod.rs
│       │   └── tokio/
│       │       ├── hickory_resolver.rs
│       │       └── mod.rs
│       ├── send_future.rs
│       ├── server/
│       │   └── mod.rs
│       ├── status/
│       │   ├── server_status.rs
│       │   └── status_code.rs
│       └── status.rs
├── interop/
│   ├── Cargo.toml
│   ├── bin/
│   │   ├── client_darwin_amd64
│   │   ├── client_linux_amd64
│   │   ├── server_darwin_amd64
│   │   └── server_linux_amd64
│   ├── build.rs
│   ├── data/
│   │   ├── README.md
│   │   ├── ca.pem
│   │   ├── cert-generator/
│   │   │   ├── .gitignore
│   │   │   ├── ca.tf
│   │   │   └── server_certs.tf
│   │   ├── server1.key
│   │   └── server1.pem
│   ├── proto/
│   │   └── grpc/
│   │       └── testing/
│   │           ├── empty.proto
│   │           ├── messages.proto
│   │           └── test.proto
│   ├── src/
│   │   ├── bin/
│   │   │   ├── client.rs
│   │   │   └── server.rs
│   │   ├── client.rs
│   │   ├── client_prost.rs
│   │   ├── client_protobuf.rs
│   │   ├── lib.rs
│   │   ├── server_prost.rs
│   │   └── server_protobuf.rs
│   ├── test.sh
│   └── update_binaries.sh
├── prepare-release.sh
├── protoc-gen-rust-grpc/
│   ├── .bazelrc
│   ├── .gitignore
│   ├── CMakeLists.txt
│   ├── README.md
│   ├── cmake/
│   │   └── FetchProtobuf.cmake
│   └── src/
│       ├── BUILD
│       ├── grpc_rust_generator.cc
│       ├── grpc_rust_generator.h
│       └── grpc_rust_plugin.cc
├── publish-release.sh
├── tests/
│   ├── compile/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   ├── ambiguous_methods.proto
│   │   │   ├── includee.proto
│   │   │   ├── includer.proto
│   │   │   ├── result.proto
│   │   │   ├── root_crate_path.proto
│   │   │   ├── same_name.proto
│   │   │   ├── service.proto
│   │   │   ├── skip_debug.proto
│   │   │   ├── stream.proto
│   │   │   └── use_arc_self.proto
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       ├── ui/
│   │       │   ├── ambiguous_methods.rs
│   │       │   ├── includer.rs
│   │       │   ├── result.rs
│   │       │   ├── root_file_path.rs
│   │       │   ├── same_name.rs
│   │       │   ├── service.rs
│   │       │   ├── skip_debug.rs
│   │       │   ├── stream.rs
│   │       │   └── use_arc_self.rs
│   │       └── ui.rs
│   ├── compression/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   └── test.proto
│   │   └── src/
│   │       ├── bidirectional_stream.rs
│   │       ├── client_stream.rs
│   │       ├── compressing_request.rs
│   │       ├── compressing_response.rs
│   │       ├── lib.rs
│   │       ├── server_stream.rs
│   │       └── util.rs
│   ├── default_stubs/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   ├── test.proto
│   │   │   └── test_default.proto
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       └── default.rs
│   ├── deprecated_methods/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   └── test.proto
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       └── deprecated_methods.rs
│   ├── disable_comments/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   └── test.proto
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       └── disable_comments.rs
│   ├── extern_path/
│   │   ├── my_application/
│   │   │   ├── Cargo.toml
│   │   │   ├── build.rs
│   │   │   └── src/
│   │   │       └── main.rs
│   │   ├── proto/
│   │   │   ├── my_application/
│   │   │   │   └── service.proto
│   │   │   └── uuid/
│   │   │       └── uuid.proto
│   │   └── uuid/
│   │       ├── Cargo.toml
│   │       ├── build.rs
│   │       └── src/
│   │           └── lib.rs
│   ├── integration_tests/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   ├── stream.proto
│   │   │   └── test.proto
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       ├── client_layer.rs
│   │       ├── complex_tower_middleware.rs
│   │       ├── connect_info.rs
│   │       ├── connection.rs
│   │       ├── extensions.rs
│   │       ├── http2_keep_alive.rs
│   │       ├── http2_max_header_list_size.rs
│   │       ├── interceptor.rs
│   │       ├── load_shed.rs
│   │       ├── max_message_size.rs
│   │       ├── origin.rs
│   │       ├── routes_builder.rs
│   │       ├── status.rs
│   │       ├── streams.rs
│   │       ├── timeout.rs
│   │       └── user_agent.rs
│   ├── web/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   └── test.proto
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       ├── grpc.rs
│   │       └── grpc_web.rs
│   ├── wellknown/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── proto/
│   │   │   └── wellknown.proto
│   │   └── src/
│   │       └── lib.rs
│   └── wellknown-compiled/
│       ├── Cargo.toml
│       ├── build.rs
│       ├── proto/
│       │   ├── google.proto
│       │   └── test.proto
│       └── src/
│           └── lib.rs
├── tonic/
│   ├── Cargo.toml
│   ├── benches/
│   │   └── decode.rs
│   ├── benches-disabled/
│   │   ├── README.md
│   │   ├── bench_main.rs
│   │   ├── benchmarks/
│   │   │   ├── compiled_protos/
│   │   │   │   ├── diverse_types.rs
│   │   │   │   ├── helloworld.rs
│   │   │   │   └── mod.rs
│   │   │   ├── mod.rs
│   │   │   ├── request_response.rs
│   │   │   ├── request_response_diverse_types.rs
│   │   │   └── utils.rs
│   │   └── proto/
│   │       ├── diverse_types/
│   │       │   └── diverse_types.proto
│   │       └── helloworld/
│   │           └── helloworld.proto
│   └── src/
│       ├── body.rs
│       ├── client/
│       │   ├── grpc.rs
│       │   ├── mod.rs
│       │   └── service.rs
│       ├── codec/
│       │   ├── buffer.rs
│       │   ├── compression.rs
│       │   ├── decode.rs
│       │   ├── encode.rs
│       │   └── mod.rs
│       ├── codegen.rs
│       ├── extensions.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── metadata/
│       │   ├── encoding.rs
│       │   ├── key.rs
│       │   ├── map.rs
│       │   ├── mod.rs
│       │   └── value.rs
│       ├── request.rs
│       ├── response.rs
│       ├── server/
│       │   ├── grpc.rs
│       │   ├── mod.rs
│       │   └── service.rs
│       ├── service/
│       │   ├── interceptor.rs
│       │   ├── layered.rs
│       │   ├── mod.rs
│       │   ├── recover_error.rs
│       │   └── router.rs
│       ├── status.rs
│       ├── transport/
│       │   ├── channel/
│       │   │   ├── endpoint.rs
│       │   │   ├── mod.rs
│       │   │   ├── service/
│       │   │   │   ├── add_origin.rs
│       │   │   │   ├── connection.rs
│       │   │   │   ├── connector.rs
│       │   │   │   ├── discover.rs
│       │   │   │   ├── executor.rs
│       │   │   │   ├── io.rs
│       │   │   │   ├── mod.rs
│       │   │   │   ├── reconnect.rs
│       │   │   │   ├── tls.rs
│       │   │   │   └── user_agent.rs
│       │   │   ├── tls.rs
│       │   │   └── uds_connector.rs
│       │   ├── error.rs
│       │   ├── mod.rs
│       │   ├── server/
│       │   │   ├── conn.rs
│       │   │   ├── display_error_stack.rs
│       │   │   ├── incoming.rs
│       │   │   ├── io_stream.rs
│       │   │   ├── mod.rs
│       │   │   ├── service/
│       │   │   │   ├── io.rs
│       │   │   │   ├── mod.rs
│       │   │   │   └── tls.rs
│       │   │   ├── tls.rs
│       │   │   └── unix.rs
│       │   ├── service/
│       │   │   ├── grpc_timeout.rs
│       │   │   ├── mod.rs
│       │   │   └── tls.rs
│       │   └── tls.rs
│       └── util.rs
├── tonic-build/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── client.rs
│       ├── code_gen.rs
│       ├── lib.rs
│       ├── manual.rs
│       └── server.rs
├── tonic-health/
│   ├── Cargo.toml
│   ├── README.md
│   ├── proto/
│   │   └── health.proto
│   └── src/
│       ├── generated/
│       │   ├── grpc_health_v1.rs
│       │   └── grpc_health_v1_fds.rs
│       ├── lib.rs
│       └── server.rs
├── tonic-prost/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── codec.rs
│       └── lib.rs
├── tonic-prost-build/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── lib.rs
│       └── tests.rs
├── tonic-protobuf/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── tonic-protobuf-build/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   └── src/
│       └── lib.rs
├── tonic-reflection/
│   ├── Cargo.toml
│   ├── README.md
│   ├── proto/
│   │   ├── reflection_v1.proto
│   │   └── reflection_v1alpha.proto
│   ├── src/
│   │   ├── generated/
│   │   │   ├── grpc_reflection_v1.rs
│   │   │   ├── grpc_reflection_v1alpha.rs
│   │   │   ├── reflection_v1_fds.rs
│   │   │   └── reflection_v1alpha1_fds.rs
│   │   ├── lib.rs
│   │   └── server/
│   │       ├── mod.rs
│   │       ├── v1.rs
│   │       └── v1alpha.rs
│   └── tests/
│       ├── server.rs
│       └── versions.rs
├── tonic-types/
│   ├── Cargo.toml
│   ├── README.md
│   ├── proto/
│   │   ├── error_details.proto
│   │   └── status.proto
│   └── src/
│       ├── generated/
│       │   ├── google_rpc.rs
│       │   └── types_fds.rs
│       ├── lib.rs
│       └── richer_error/
│           ├── error_details/
│           │   ├── mod.rs
│           │   └── vec.rs
│           ├── mod.rs
│           └── std_messages/
│               ├── bad_request.rs
│               ├── debug_info.rs
│               ├── error_info.rs
│               ├── help.rs
│               ├── loc_message.rs
│               ├── mod.rs
│               ├── prec_failure.rs
│               ├── quota_failure.rs
│               ├── request_info.rs
│               ├── resource_info.rs
│               └── retry_info.rs
├── tonic-web/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── call.rs
│       ├── client.rs
│       ├── layer.rs
│       ├── lib.rs
│       └── service.rs
├── tonic-xds/
│   ├── Cargo.toml
│   ├── examples/
│   │   └── gen_test_proto.rs
│   ├── proto/
│   │   └── test/
│   │       └── helloworld.proto
│   └── src/
│       ├── client/
│       │   ├── channel.rs
│       │   ├── cluster.rs
│       │   ├── endpoint.rs
│       │   ├── lb.rs
│       │   ├── mod.rs
│       │   └── route.rs
│       ├── common/
│       │   ├── async_util.rs
│       │   └── mod.rs
│       ├── lib.rs
│       ├── testutil/
│       │   ├── grpc.rs
│       │   ├── mod.rs
│       │   └── proto/
│       │       ├── helloworld.rs
│       │       └── mod.rs
│       └── xds/
│           ├── bootstrap.rs
│           ├── mod.rs
│           ├── resource/
│           │   ├── cluster.rs
│           │   ├── endpoints.rs
│           │   ├── listener.rs
│           │   ├── mod.rs
│           │   └── route_config.rs
│           ├── routing.rs
│           ├── uri.rs
│           └── xds_manager.rs
└── xds-client/
    ├── Cargo.toml
    ├── examples/
    │   └── basic.rs
    └── src/
        ├── client/
        │   ├── config.rs
        │   ├── mod.rs
        │   ├── retry.rs
        │   ├── watch.rs
        │   └── worker.rs
        ├── codec/
        │   ├── mod.rs
        │   └── prost.rs
        ├── error.rs
        ├── lib.rs
        ├── message.rs
        ├── resource/
        │   ├── mod.rs
        │   └── prost.rs
        ├── runtime/
        │   ├── mod.rs
        │   └── tokio.rs
        └── transport/
            ├── mod.rs
            └── tonic.rs

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 {

[
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 937,
    "preview": "---\nname: 🐛 Bug Report\nabout: If something isn't working as expected 🤔.\n\n---\n\n## Bug Report\n<!--\nThank you for reporting"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 653,
    "preview": "---\nname: 💡 Feature Request\nabout: I have a suggestion (and may want to implement it 🙂)!\n\n---\n\n## Feature Request\n\n### C"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 726,
    "preview": "<!--\nThank you for your Pull Request. Please provide a description above and review\nthe requirements below.\n\nIf this cha"
  },
  {
    "path": ".github/workflows/CI.yml",
    "chars": 16990,
    "preview": "name: CI\n\non:\n  push:\n  pull_request: {}\n  merge_group:\n    branches: [ \"master\" ]\n\nconcurrency:\n  group: ${{ github.wor"
  },
  {
    "path": ".gitignore",
    "chars": 35,
    "preview": "target/\n**/*.rs.bk\nCargo.lock\ntags\n"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 61546,
    "preview": "# NOTE: ths changelog is no longer used and from version `v0.13.0` onward we will be using github releases and the chang"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 17928,
    "preview": "# Contributing to Tonic\n\n:balloon: Thanks for your help improving the project! We are so happy to have\nyou!\n\nThere are o"
  },
  {
    "path": "Cargo.toml",
    "chars": 889,
    "preview": "[workspace]\nmembers = [\n  \"tonic\",\n  \"tonic-build\",\n  \"tonic-health\",\n  \"tonic-protobuf\",\n  \"tonic-protobuf-build\",\n  \"t"
  },
  {
    "path": "LICENSE",
    "chars": 1056,
    "preview": "Copyright (c) 2025 Lucio Franco\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this so"
  },
  {
    "path": "README.md",
    "chars": 4931,
    "preview": "![](https://github.com/hyperium/tonic/raw/master/.github/assets/tonic-banner.svg?sanitize=true)\n\n\nA rust implementation "
  },
  {
    "path": "SECURITY.md",
    "chars": 370,
    "preview": "# Security Policy\n\ntonic (and related projects in hyperium) uses the same security policy as the [Tokio project][tokio-s"
  },
  {
    "path": "codegen/Cargo.toml",
    "chars": 353,
    "preview": "[package]\nname = \"codegen\"\nauthors = [\"Lucio Franco <luciofranco14@gmail.com>\"]\nlicense = \"MIT\"\nedition = \"2024\"\nrust-ve"
  },
  {
    "path": "codegen/src/main.rs",
    "chars": 4959,
    "preview": "use std::{\n    fs::File,\n    io::{BufWriter, Write as _},\n    path::{Path, PathBuf},\n    time::Instant,\n};\n\nuse protox::"
  },
  {
    "path": "examples/Cargo.toml",
    "chars": 7997,
    "preview": "[package]\nauthors = [\"Lucio Franco <luciofranco14@gmail.com>\"]\nedition = \"2024\"\nlicense = \"MIT\"\nname = \"examples\"\n\n[[bin"
  },
  {
    "path": "examples/README.md",
    "chars": 2829,
    "preview": "# Examples\n\nSet of examples that show off the features provided by `tonic`.\n\nIn order to build these examples, you must "
  },
  {
    "path": "examples/build.rs",
    "chars": 2652,
    "preview": "use std::{env, path::PathBuf};\n\nfn main() {\n    tonic_prost_build::configure()\n        .compile_protos(&[\"proto/routegui"
  },
  {
    "path": "examples/data/gcp/roots.pem",
    "chars": 74996,
    "preview": "# Operating CA: Comodo Group\n# Issuer: CN=AAA Certificate Services O=Comodo CA Limited\n# Subject: CN=AAA Certificate Ser"
  },
  {
    "path": "examples/data/route_guide_db.json",
    "chars": 16570,
    "preview": "[\n    {\n        \"location\": {\n            \"latitude\": 407838351,\n            \"longitude\": -746143763\n        },\n        "
  },
  {
    "path": "examples/data/tls/ca.key",
    "chars": 3272,
    "preview": "-----BEGIN PRIVATE KEY-----\nMIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQC6XFF7KXhQGBXf\n0OAcPt7sg8xlsHlYzW2A9N7FzhS"
  },
  {
    "path": "examples/data/tls/ca.pem",
    "chars": 1980,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIFijCCA3KgAwIBAgIUao+2CjQxejCTMhfk0SNhJJ9gZK4wDQYJKoZIhvcNAQEL\nBQAwKTEOMAwGA1UECgwFVG9uaWM"
  },
  {
    "path": "examples/data/tls/client1.key",
    "chars": 3272,
    "preview": "-----BEGIN PRIVATE KEY-----\nMIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQC3dUytzpnqjxW6\nDh2Ci0b4fB0iA8D251L0fVLIZE9"
  },
  {
    "path": "examples/data/tls/client1.pem",
    "chars": 1887,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIFRDCCAyygAwIBAgICA+gwDQYJKoZIhvcNAQELBQAwKTEOMAwGA1UECgwFVG9u\naWMxFzAVBgNVBAMMDnRlc3QtY2x"
  },
  {
    "path": "examples/data/tls/client2.key",
    "chars": 3272,
    "preview": "-----BEGIN PRIVATE KEY-----\nMIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQCS5QyVoX2R4cXC\nUU93PnibomqTYDHwPBTcBUaSQ3C"
  },
  {
    "path": "examples/data/tls/client2.pem",
    "chars": 1887,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIFRDCCAyygAwIBAgICA+gwDQYJKoZIhvcNAQELBQAwKTEOMAwGA1UECgwFVG9u\naWMxFzAVBgNVBAMMDnRlc3QtY2x"
  },
  {
    "path": "examples/data/tls/client_ca.key",
    "chars": 3272,
    "preview": "-----BEGIN PRIVATE KEY-----\nMIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQC0Yc8MUU0XaWXh\nI5IpE5BD7JYWmhDGZnZY/YdCgkw"
  },
  {
    "path": "examples/data/tls/client_ca.pem",
    "chars": 1980,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIFijCCA3KgAwIBAgIUP0tYMykcdcDwKamtdfqbDg//4O0wDQYJKoZIhvcNAQEL\nBQAwKTEOMAwGA1UECgwFVG9uaWM"
  },
  {
    "path": "examples/data/tls/create.sh",
    "chars": 2372,
    "preview": "#!/bin/bash\n\n# Create the server CA certs.\nopenssl req -x509 \\\n  -newkey rsa:4096 \\\n  -nodes \\\n  -days 3650 \\\n  -keyout "
  },
  {
    "path": "examples/data/tls/openssl.cnf",
    "chars": 1141,
    "preview": "[req]\ndistinguished_name = req_distinguished_name\nattributes = req_attributes\n\n[req_distinguished_name]\n\n[req_attributes"
  },
  {
    "path": "examples/data/tls/server.key",
    "chars": 3268,
    "preview": "-----BEGIN PRIVATE KEY-----\nMIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQCckNy1wG9TFgHM\n2LlY2YnuaiqqYAyvNtzOH7Dsbgo"
  },
  {
    "path": "examples/data/tls/server.pem",
    "chars": 1976,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIFhTCCA22gAwIBAgICA+gwDQYJKoZIhvcNAQELBQAwKTEOMAwGA1UECgwFVG9u\naWMxFzAVBgNVBAMMDnRlc3Qtc2V"
  },
  {
    "path": "examples/data/tls/server2.key",
    "chars": 3272,
    "preview": "-----BEGIN PRIVATE KEY-----\nMIIJQwIBADANBgkqhkiG9w0BAQEFAASCCS0wggkpAgEAAoICAQDDX6SRgoa4jTxv\njbsx8+EXOXe0J5gdbdp1nsDH6tq"
  },
  {
    "path": "examples/data/tls/server2.pem",
    "chars": 1883,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIFQjCCAyqgAwIBAgICA+gwDQYJKoZIhvcNAQELBQAwKTEOMAwGA1UECgwFVG9u\naWMxFzAVBgNVBAMMDnRlc3Qtc2V"
  },
  {
    "path": "examples/helloworld-tutorial.md",
    "chars": 11000,
    "preview": "# Getting Started\n\nThis tutorial is meant to be an introduction to Tonic and assumes that you have basic [Rust] experien"
  },
  {
    "path": "examples/proto/attrs/attrs.proto",
    "chars": 344,
    "preview": "syntax = \"proto3\";\n\npackage attrs;\n\n// EchoRequest is the request for echo.\nmessage EchoRequest {\n  string message = 1;\n"
  },
  {
    "path": "examples/proto/echo/echo.proto",
    "chars": 1365,
    "preview": "/*\n *\n * Copyright 2018 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may n"
  },
  {
    "path": "examples/proto/googleapis/google/api/annotations.proto",
    "chars": 1051,
    "preview": "// Copyright (c) 2015, Google Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not "
  },
  {
    "path": "examples/proto/googleapis/google/api/client.proto",
    "chars": 3392,
    "preview": "// Copyright 2020 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
  },
  {
    "path": "examples/proto/googleapis/google/api/field_behavior.proto",
    "chars": 3318,
    "preview": "// Copyright 2020 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
  },
  {
    "path": "examples/proto/googleapis/google/api/http.proto",
    "chars": 15140,
    "preview": "// Copyright 2020 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
  },
  {
    "path": "examples/proto/googleapis/google/api/resource.proto",
    "chars": 11347,
    "preview": "// Copyright 2020 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
  },
  {
    "path": "examples/proto/googleapis/google/pubsub/v1/pubsub.proto",
    "chars": 56473,
    "preview": "// Copyright 2020 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
  },
  {
    "path": "examples/proto/googleapis/google/pubsub/v1/schema.proto",
    "chars": 8861,
    "preview": "// Copyright 2020 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use th"
  },
  {
    "path": "examples/proto/helloworld/helloworld.proto",
    "chars": 1093,
    "preview": "// Copyright 2015 gRPC authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use"
  },
  {
    "path": "examples/proto/routeguide/route_guide.proto",
    "chars": 3455,
    "preview": "// Copyright 2015 gRPC authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use"
  },
  {
    "path": "examples/proto/unaryecho/echo.proto",
    "chars": 981,
    "preview": "/*\n *\n * Copyright 2018 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may n"
  },
  {
    "path": "examples/routeguide-tutorial.md",
    "chars": 27001,
    "preview": "# gRPC Basics: Tonic\n\nThis tutorial, adapted from [grpc-go], provides a basic introduction to working with gRPC\nand Toni"
  },
  {
    "path": "examples/src/authentication/client.rs",
    "chars": 794,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, echo_client::EchoClient};\nus"
  },
  {
    "path": "examples/src/authentication/server.rs",
    "chars": 1187,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, EchoResponse};\nuse tonic::{R"
  },
  {
    "path": "examples/src/autoreload/server.rs",
    "chars": 1429,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\nuse hello_world::greeter_server::{Greeter, GreeterServer};\nu"
  },
  {
    "path": "examples/src/blocking/client.rs",
    "chars": 1569,
    "preview": "use tokio::runtime::{Builder, Runtime};\n\npub mod hello_world {\n    tonic::include_proto!(\"helloworld\");\n}\n\nuse hello_wor"
  },
  {
    "path": "examples/src/blocking/server.rs",
    "chars": 1104,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\nuse hello_world::greeter_server::{Greeter, GreeterServer};\nu"
  },
  {
    "path": "examples/src/cancellation/client.rs",
    "chars": 800,
    "preview": "use hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\n\nuse tokio::time::{Duration, timeout};\n\np"
  },
  {
    "path": "examples/src/cancellation/server.rs",
    "chars": 2784,
    "preview": "use std::future::Future;\n\nuse tokio_util::sync::CancellationToken;\nuse tonic::{Request, Response, Status, transport::Ser"
  },
  {
    "path": "examples/src/codec_buffers/client.rs",
    "chars": 965,
    "preview": "//! A HelloWorld example that uses a custom codec instead of the default Prost codec.\n//!\n//! Generated code is the outp"
  },
  {
    "path": "examples/src/codec_buffers/common.rs",
    "chars": 1448,
    "preview": "//! This module defines a common encoder with small buffers. This is useful\n//! when you have many concurrent RPC's, and"
  },
  {
    "path": "examples/src/codec_buffers/server.rs",
    "chars": 1475,
    "preview": "//! A HelloWorld example that uses a custom codec instead of the default Prost codec.\n//!\n//! Generated code is the outp"
  },
  {
    "path": "examples/src/compression/client.rs",
    "chars": 756,
    "preview": "use hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\nuse tonic::codec::CompressionEncoding;\nus"
  },
  {
    "path": "examples/src/compression/server.rs",
    "chars": 1176,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\nuse hello_world::greeter_server::{Greeter, GreeterServer};\nu"
  },
  {
    "path": "examples/src/dynamic/server.rs",
    "chars": 2405,
    "preview": "use std::env;\nuse tonic::{Request, Response, Status, service::RoutesBuilder, transport::Server};\n\nuse hello_world::greet"
  },
  {
    "path": "examples/src/dynamic_load_balance/client.rs",
    "chars": 2732,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, echo_client::EchoClient};\nus"
  },
  {
    "path": "examples/src/dynamic_load_balance/server.rs",
    "chars": 1303,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse std::net::SocketAddr;\nuse tokio::sync::mpsc;\nu"
  },
  {
    "path": "examples/src/gcp/README.md",
    "chars": 915,
    "preview": "# Google Cloud Pubsub example\n\nThis example will attempt to fetch a list of topics using the google\ngRPC protobuf specif"
  },
  {
    "path": "examples/src/gcp/client.rs",
    "chars": 1715,
    "preview": "pub mod api {\n    tonic::include_proto!(\"google.pubsub.v1\");\n}\n\nuse api::{ListTopicsRequest, publisher_client::Publisher"
  },
  {
    "path": "examples/src/grpc-web/client.rs",
    "chars": 811,
    "preview": "use hello_world::{HelloRequest, greeter_client::GreeterClient};\nuse hyper_util::rt::TokioExecutor;\nuse tonic_web::GrpcWe"
  },
  {
    "path": "examples/src/grpc-web/server.rs",
    "chars": 1377,
    "preview": "use tonic::{Request, Response, Status, service::LayerExt as _, transport::Server};\n\nuse hello_world::greeter_server::{Gr"
  },
  {
    "path": "examples/src/h2c/client.rs",
    "chars": 2687,
    "preview": "use hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\nuse http::Uri;\nuse hyper_util::client::le"
  },
  {
    "path": "examples/src/h2c/server.rs",
    "chars": 3932,
    "preview": "use std::net::SocketAddr;\n\nuse hyper_util::rt::{TokioExecutor, TokioIo};\nuse hyper_util::server::conn::auto::Builder;\nus"
  },
  {
    "path": "examples/src/health/README.md",
    "chars": 742,
    "preview": "# Health checks\n\ngRPC has a [health checking protocol](https://github.com/grpc/grpc/blob/master/doc/health-checking.md) "
  },
  {
    "path": "examples/src/health/server.rs",
    "chars": 1950,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\nuse hello_world::greeter_server::{Greeter, GreeterServer};\nu"
  },
  {
    "path": "examples/src/helloworld/client.rs",
    "chars": 495,
    "preview": "use hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\n\npub mod hello_world {\n    tonic::include"
  },
  {
    "path": "examples/src/helloworld/server.rs",
    "chars": 1030,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\nuse hello_world::greeter_server::{Greeter, GreeterServer};\nu"
  },
  {
    "path": "examples/src/interceptor/client.rs",
    "chars": 2257,
    "preview": "use hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\nuse tonic::{\n    Request, Status,\n    cod"
  },
  {
    "path": "examples/src/interceptor/server.rs",
    "chars": 1822,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\nuse hello_world::greeter_server::{Greeter, GreeterServer};\nu"
  },
  {
    "path": "examples/src/json-codec/client.rs",
    "chars": 923,
    "preview": "//! A HelloWorld example that uses JSON instead of protobuf as the message serialization format.\n//!\n//! Generated code "
  },
  {
    "path": "examples/src/json-codec/common.rs",
    "chars": 2185,
    "preview": "//! This module defines common request/response types as well as the JsonCodec that is used by the\n//! json.helloworld.G"
  },
  {
    "path": "examples/src/json-codec/server.rs",
    "chars": 1454,
    "preview": "//! A HelloWorld example that uses JSON instead of protobuf as the message serialization format.\n//!\n//! Generated code "
  },
  {
    "path": "examples/src/load_balance/client.rs",
    "chars": 705,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, echo_client::EchoClient};\nus"
  },
  {
    "path": "examples/src/load_balance/server.rs",
    "chars": 1303,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse std::net::SocketAddr;\nuse tokio::sync::mpsc;\nu"
  },
  {
    "path": "examples/src/mock/mock.rs",
    "chars": 2029,
    "preview": "use hyper_util::rt::TokioIo;\nuse tonic::{\n    Request, Response, Status,\n    transport::{Endpoint, Server, Uri},\n};\nuse "
  },
  {
    "path": "examples/src/multiplex/client.rs",
    "chars": 992,
    "preview": "pub mod hello_world {\n    tonic::include_proto!(\"helloworld\");\n}\n\npub mod echo {\n    tonic::include_proto!(\"grpc.example"
  },
  {
    "path": "examples/src/multiplex/server.rs",
    "chars": 1466,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\npub mod hello_world {\n    tonic::include_proto!(\"helloworld\""
  },
  {
    "path": "examples/src/reflection/server.rs",
    "chars": 1258,
    "preview": "use tonic::transport::Server;\nuse tonic::{Request, Response, Status};\n\nmod proto {\n    tonic::include_proto!(\"helloworld"
  },
  {
    "path": "examples/src/richer-error/client.rs",
    "chars": 1508,
    "preview": "use tonic_types::StatusExt;\n\nuse hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\n\npub mod hel"
  },
  {
    "path": "examples/src/richer-error/client_vec.rs",
    "chars": 1793,
    "preview": "use tonic_types::{ErrorDetail, StatusExt};\n\nuse hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClien"
  },
  {
    "path": "examples/src/richer-error/server.rs",
    "chars": 2081,
    "preview": "use tonic::{Code, Request, Response, Status, transport::Server};\nuse tonic_types::{ErrorDetails, StatusExt};\n\nuse hello_"
  },
  {
    "path": "examples/src/richer-error/server_vec.rs",
    "chars": 2122,
    "preview": "use tonic::{Code, Request, Response, Status, transport::Server};\nuse tonic_types::{BadRequest, Help, LocalizedMessage, S"
  },
  {
    "path": "examples/src/routeguide/client.rs",
    "chars": 3343,
    "preview": "use std::error::Error;\nuse std::time::Duration;\n\nuse rand::Rng;\nuse rand::rngs::ThreadRng;\nuse tokio::time;\nuse tonic::R"
  },
  {
    "path": "examples/src/routeguide/data.rs",
    "chars": 932,
    "preview": "use serde::Deserialize;\nuse std::fs::File;\n\n#[derive(Debug, Deserialize)]\nstruct Feature {\n    location: Location,\n    n"
  },
  {
    "path": "examples/src/routeguide/server.rs",
    "chars": 5611,
    "preview": "use std::collections::HashMap;\nuse std::pin::Pin;\nuse std::sync::Arc;\nuse std::time::Instant;\n\nuse tokio::sync::mpsc;\nus"
  },
  {
    "path": "examples/src/streaming/client.rs",
    "chars": 2797,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.echo\");\n}\n\nuse std::time::Duration;\nuse tokio_stream::{Stream, Str"
  },
  {
    "path": "examples/src/streaming/server.rs",
    "chars": 5343,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.echo\");\n}\n\nuse std::{error::Error, io::ErrorKind, net::ToSocketAdd"
  },
  {
    "path": "examples/src/tls/client.rs",
    "chars": 939,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"/grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, echo_client::EchoClient};\nu"
  },
  {
    "path": "examples/src/tls/server.rs",
    "chars": 1571,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"/grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, EchoResponse};\nuse tonic::{"
  },
  {
    "path": "examples/src/tls_client_auth/client.rs",
    "chars": 1282,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, echo_client::EchoClient};\nus"
  },
  {
    "path": "examples/src/tls_client_auth/server.rs",
    "chars": 1641,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"grpc.examples.unaryecho\");\n}\n\nuse pb::{EchoRequest, EchoResponse};\nuse tonic::tr"
  },
  {
    "path": "examples/src/tls_rustls/client.rs",
    "chars": 2533,
    "preview": "//! This examples shows how you can combine `hyper-rustls` and `tonic` to\n//! provide a custom `ClientConfig` for the tl"
  },
  {
    "path": "examples/src/tls_rustls/server.rs",
    "chars": 3580,
    "preview": "pub mod pb {\n    tonic::include_proto!(\"/grpc.examples.unaryecho\");\n}\n\nuse hyper::server::conn::http2::Builder;\nuse hype"
  },
  {
    "path": "examples/src/tower/client.rs",
    "chars": 2351,
    "preview": "use hello_world::HelloRequest;\nuse hello_world::greeter_client::GreeterClient;\nuse service::AuthSvc;\nuse tower::ServiceB"
  },
  {
    "path": "examples/src/tower/server.rs",
    "chars": 3016,
    "preview": "use std::{\n    pin::Pin,\n    task::{Context, Poll},\n};\nuse tonic::{Request, Response, Status, transport::Server};\nuse to"
  },
  {
    "path": "examples/src/tracing/client.rs",
    "chars": 890,
    "preview": "pub mod hello_world {\n    tonic::include_proto!(\"helloworld\");\n}\n\nuse hello_world::{HelloRequest, greeter_client::Greete"
  },
  {
    "path": "examples/src/tracing/server.rs",
    "chars": 1246,
    "preview": "use tonic::{Request, Response, Status, transport::Server};\n\npub mod hello_world {\n    tonic::include_proto!(\"helloworld\""
  },
  {
    "path": "examples/src/uds/client_standard.rs",
    "chars": 930,
    "preview": "#![cfg_attr(not(unix), allow(unused_imports))]\n\npub mod hello_world {\n    tonic::include_proto!(\"helloworld\");\n}\n\nuse he"
  },
  {
    "path": "examples/src/uds/client_with_connector.rs",
    "chars": 1231,
    "preview": "#![cfg_attr(not(unix), allow(unused_imports))]\n\npub mod hello_world {\n    tonic::include_proto!(\"helloworld\");\n}\n\nuse he"
  },
  {
    "path": "examples/src/uds/server.rs",
    "chars": 1615,
    "preview": "#![cfg_attr(not(unix), allow(unused_imports))]\n\nuse std::path::Path;\n#[cfg(unix)]\nuse tokio::net::UnixListener;\n#[cfg(un"
  },
  {
    "path": "flake.nix",
    "chars": 4214,
    "preview": "{\n  description = \"Description for the project\";\n\n  inputs = {\n    flake-parts.url = \"github:hercules-ci/flake-parts\";\n "
  },
  {
    "path": "grpc/Cargo.toml",
    "chars": 2788,
    "preview": "[package]\nname = \"grpc\"\nversion = \"0.9.0-alpha.1\"\nedition = \"2024\"\nauthors = [\"gRPC Authors\"]\nlicense = \"MIT\"\nrust-versi"
  },
  {
    "path": "grpc/examples/inmemory.rs",
    "chars": 6854,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/proto/echo/echo.proto",
    "chars": 1344,
    "preview": "/*\n *\n * Copyright 2018 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may n"
  },
  {
    "path": "grpc/src/attributes/linked_list.rs",
    "chars": 5763,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/attributes/mod.rs",
    "chars": 7533,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/byte_str.rs",
    "chars": 1906,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/channel.rs",
    "chars": 22870,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/interceptor.rs",
    "chars": 31145,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/child_manager.rs",
    "chars": 37392,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/graceful_switch.rs",
    "chars": 39893,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/mod.rs",
    "chars": 20498,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/pick_first.rs",
    "chars": 4969,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/registry.rs",
    "chars": 2401,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/round_robin.rs",
    "chars": 53051,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/load_balancing/test_utils.rs",
    "chars": 9385,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/mod.rs",
    "chars": 8765,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/name_resolution/backoff.rs",
    "chars": 8457,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/name_resolution/dns/mod.rs",
    "chars": 14645,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/name_resolution/dns/test.rs",
    "chars": 18862,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/name_resolution/mod.rs",
    "chars": 15260,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/name_resolution/registry.rs",
    "chars": 3540,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/service_config.rs",
    "chars": 2164,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/stream_util.rs",
    "chars": 16615,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/subchannel.rs",
    "chars": 16117,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/transport/mod.rs",
    "chars": 3452,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/transport/registry.rs",
    "chars": 2911,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/transport/tonic/mod.rs",
    "chars": 15714,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/client/transport/tonic/test.rs",
    "chars": 10504,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/core/mod.rs",
    "chars": 8083,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/call.rs",
    "chars": 7722,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/client.rs",
    "chars": 12067,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/dyn_wrapper.rs",
    "chars": 7620,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/insecure.rs",
    "chars": 8750,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/local.rs",
    "chars": 10315,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/mod.rs",
    "chars": 3437,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/rustls/client/mod.rs",
    "chars": 9642,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/rustls/client/test.rs",
    "chars": 21101,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/rustls/key_log.rs",
    "chars": 3430,
    "preview": "// Copyright (c) 2016 Joseph Birr-Pixton <jpixton@gmail.com>\n//\n// Licensed under the Apache License, Version 2.0 (the \""
  },
  {
    "path": "grpc/src/credentials/rustls/mod.rs",
    "chars": 6462,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/rustls/server/mod.rs",
    "chars": 13065,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/rustls/server/test.rs",
    "chars": 25860,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/rustls/tls_stream.rs",
    "chars": 3933,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/credentials/server.rs",
    "chars": 3004,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/generated/echo_fds.rs",
    "chars": 4210,
    "preview": "// This file is @generated by codegen.\n// \n// \n//  Copyright 2018 gRPC authors.\n// \n//  Licensed under the Apache Licens"
  },
  {
    "path": "grpc/src/generated/grpc_examples_echo.rs",
    "chars": 23956,
    "preview": "// This file is @generated by prost-build.\n/// EchoRequest is the request for echo.\n#[derive(Clone, PartialEq, Eq, Hash,"
  },
  {
    "path": "grpc/src/inmemory/mod.rs",
    "chars": 12173,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/lib.rs",
    "chars": 1829,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/macros.rs",
    "chars": 5137,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/rt/hyper_wrapper.rs",
    "chars": 5667,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/rt/mod.rs",
    "chars": 8253,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/rt/tokio/hickory_resolver.rs",
    "chars": 8819,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/rt/tokio/mod.rs",
    "chars": 9385,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/send_future.rs",
    "chars": 3600,
    "preview": "/*\n *\n * Copyright 2026 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/server/mod.rs",
    "chars": 6519,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/status/server_status.rs",
    "chars": 2967,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/status/status_code.rs",
    "chars": 2472,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "grpc/src/status.rs",
    "chars": 2318,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "interop/Cargo.toml",
    "chars": 1132,
    "preview": "[package]\nauthors = [\"Lucio Franco <luciofranco14@gmail.com>\"]\nedition = \"2024\"\nlicense = \"MIT\"\nname = \"interop\"\nrust-ve"
  },
  {
    "path": "interop/build.rs",
    "chars": 639,
    "preview": "fn main() {\n    let proto = \"proto/grpc/testing/test.proto\";\n\n    eprintln!(\"{}\", tonic_protobuf_build::protoc());\n    l"
  },
  {
    "path": "interop/data/README.md",
    "chars": 551,
    "preview": "# Tonic Testing Certificates\n\nThis directory contains certificates used for testing interop between Tonic's\nimplementati"
  },
  {
    "path": "interop/data/ca.pem",
    "chars": 1196,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIDRjCCAi6gAwIBAgIQd5pnuFdwgGxb4RiClYEPMTANBgkqhkiG9w0BAQsFADA9\nMQ4wDAYDVQQKEwVUb2tpbzEQMA4"
  },
  {
    "path": "interop/data/cert-generator/.gitignore",
    "chars": 39,
    "preview": ".terraform/\n*.tfstate\n*.tfstate.backup\n"
  },
  {
    "path": "interop/data/cert-generator/ca.tf",
    "chars": 530,
    "preview": "resource \"tls_private_key\" \"root\" {\n  algorithm = \"RSA\"\n  rsa_bits = \"2048\"\n}\n\nresource \"tls_self_signed_cert\" \"root\" {\n"
  },
  {
    "path": "interop/data/cert-generator/server_certs.tf",
    "chars": 849,
    "preview": "resource \"tls_private_key\" \"server\" {\n  algorithm = \"RSA\"\n  rsa_bits = \"2048\"\n}\n\nresource \"tls_cert_request\" \"server\" {\n"
  },
  {
    "path": "interop/data/server1.key",
    "chars": 1679,
    "preview": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA7iJJ8gLlKsp+r15CR15Iz2rmi3f3OZmA8FZ0hpB5hNkQHfVA\nRlC2yawIfHiLO4tpUmjtX8i"
  },
  {
    "path": "interop/data/server1.pem",
    "chars": 1204,
    "preview": "-----BEGIN CERTIFICATE-----\nMIIDTDCCAjSgAwIBAgIRAL1ZcIwdi/AfgLm2T41fHO4wDQYJKoZIhvcNAQELBQAw\nPTEOMAwGA1UEChMFVG9raW8xEDA"
  },
  {
    "path": "interop/proto/grpc/testing/empty.proto",
    "chars": 956,
    "preview": "// Copyright 2015 gRPC authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use"
  },
  {
    "path": "interop/proto/grpc/testing/messages.proto",
    "chars": 5438,
    "preview": "// Copyright 2015-2016 gRPC authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "interop/proto/grpc/testing/test.proto",
    "chars": 3245,
    "preview": "// Copyright 2015-2016 gRPC authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
  },
  {
    "path": "interop/src/bin/client.rs",
    "chars": 4746,
    "preview": "use interop::client::{InteropTest, InteropTestUnimplemented};\nuse interop::{client_prost, client_protobuf};\nuse std::{st"
  },
  {
    "path": "interop/src/bin/server.rs",
    "chars": 2793,
    "preview": "use interop::{server_prost, server_protobuf};\nuse std::str::FromStr;\nuse tonic::transport::Server;\nuse tonic::transport:"
  },
  {
    "path": "interop/src/client.rs",
    "chars": 1037,
    "preview": "use crate::TestAssertion;\nuse tonic::async_trait;\n\n#[async_trait]\npub trait InteropTest: Send {\n    async fn empty_unary"
  },
  {
    "path": "interop/src/client_prost.rs",
    "chars": 14960,
    "preview": "use crate::client::{InteropTest, InteropTestUnimplemented};\nuse crate::{\n    TestAssertion, pb::test_service_client::*, "
  },
  {
    "path": "interop/src/client_protobuf.rs",
    "chars": 15625,
    "preview": "/*\n *\n * Copyright 2025 gRPC authors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy"
  },
  {
    "path": "interop/src/lib.rs",
    "chars": 4808,
    "preview": "#![recursion_limit = \"256\"]\n\npub mod client;\npub mod client_prost;\npub mod client_protobuf;\npub mod server_prost;\npub mo"
  },
  {
    "path": "interop/src/server_prost.rs",
    "chars": 7232,
    "preview": "use crate::pb::{self, *};\nuse async_stream::try_stream;\nuse http::header::{HeaderMap, HeaderName};\nuse http_body_util::B"
  },
  {
    "path": "interop/src/server_protobuf.rs",
    "chars": 7346,
    "preview": "use crate::grpc_pb::{self, *};\nuse async_stream::try_stream;\nuse http::header::{HeaderMap, HeaderName};\nuse http_body_ut"
  },
  {
    "path": "interop/test.sh",
    "chars": 3012,
    "preview": "#!/usr/bin/env bash\n\nset -eu\nset -o pipefail\n\n# the go client does not support passing an argument with multiple test ca"
  },
  {
    "path": "interop/update_binaries.sh",
    "chars": 837,
    "preview": "#!/bin/bash\nset -e\n\n# This script updates server and client go binaries for interop tests.\n# It clones grpc-go, compiles"
  },
  {
    "path": "prepare-release.sh",
    "chars": 1123,
    "preview": "#!/usr/bin/env bash\n\n# Script which automates modifying source version fields, and creating a release\n# commit and tag. "
  },
  {
    "path": "protoc-gen-rust-grpc/.bazelrc",
    "chars": 389,
    "preview": "# Define a custom config for common Unix-like flags\nbuild:unix --cxxopt=-std=c++17\nbuild:unix --host_cxxopt=-std=c++17\n\n"
  },
  {
    "path": "protoc-gen-rust-grpc/.gitignore",
    "chars": 125,
    "preview": "# Bazel\nbazel-bin\nbazel-genfiles\nbazel-out\nbazel-protoc-gen-rust-grpc\nbazel-testlogs\nMODULE.bazel.lock\n\nbuild/*\nCMakeFil"
  },
  {
    "path": "protoc-gen-rust-grpc/CMakeLists.txt",
    "chars": 3380,
    "preview": "cmake_minimum_required(VERSION 3.14)\nproject(protoc-gen-rust-grpc LANGUAGES CXX)\n\nset(CMAKE_CXX_STANDARD 17)\nset(CMAKE_C"
  },
  {
    "path": "protoc-gen-rust-grpc/README.md",
    "chars": 1352,
    "preview": "# protoc-gen-rust-grpc\n\nA protoc plugin that generates Rust gRPC service code using the Tonic framework.\n\n## Build\n\nRequ"
  },
  {
    "path": "protoc-gen-rust-grpc/cmake/FetchProtobuf.cmake",
    "chars": 2352,
    "preview": "# FetchProtobuf.cmake - Helper to download and configure protobuf\n#\n# This file provides a function to download protobuf"
  },
  {
    "path": "protoc-gen-rust-grpc/src/BUILD",
    "chars": 1362,
    "preview": "# Copyright 2025 gRPC authors.\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of thi"
  },
  {
    "path": "protoc-gen-rust-grpc/src/grpc_rust_generator.cc",
    "chars": 35844,
    "preview": "// Copyright 2025 gRPC authors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of"
  },
  {
    "path": "protoc-gen-rust-grpc/src/grpc_rust_generator.h",
    "chars": 4130,
    "preview": "// Copyright 2025 gRPC authors.\n//\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//"
  },
  {
    "path": "protoc-gen-rust-grpc/src/grpc_rust_plugin.cc",
    "chars": 3743,
    "preview": "// Copyright 2025 gRPC authors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of"
  },
  {
    "path": "publish-release.sh",
    "chars": 510,
    "preview": "#!/usr/bin/env bash\n\n# Script which automates publishing a crates.io release of the prost crates.\n\nset -ex\n\nif [ \"$#\" -n"
  },
  {
    "path": "tests/compile/Cargo.toml",
    "chars": 306,
    "preview": "[package]\nname = \"test-compile\"\nedition = \"2021\"\nlicense = \"MIT\"\n\n[dependencies]\nprost = \"0.14\"\n\n[dev-dependencies]\nstat"
  },
  {
    "path": "tests/compile/build.rs",
    "chars": 1044,
    "preview": "fn main() {\n    tonic_prost_build::compile_protos(\"proto/result.proto\").unwrap();\n    tonic_prost_build::compile_protos("
  },
  {
    "path": "tests/compile/proto/ambiguous_methods.proto",
    "chars": 459,
    "preview": "syntax = \"proto3\";\n\npackage ambiguous_methods;\n\nmessage DropReq {}\nmessage DropResp {}\n\n// The generated stubs can confu"
  },
  {
    "path": "tests/compile/proto/includee.proto",
    "chars": 165,
    "preview": "syntax = \"proto3\";\n\npackage includee;\n\nservice Included {\n  rpc SomeMethod(SomeRequest) returns (SomeResponse) {}\n}\n\nmes"
  },
  {
    "path": "tests/compile/proto/includer.proto",
    "chars": 163,
    "preview": "syntax = \"proto3\";\n\npackage includer;\n\nmessage TopMessage {}\n\nservice TopService {\n  rpc TopMethod(TopMessage) returns ("
  }
]

// ... and 279 more files (download for full content)