Tonic

https://docs.rs/tonic/latest/
Admin
Tonic is a Rust implementation of gRPC over HTTP/2 focused on high performance, interoperability,...
Tokens:266,308
Snippets:2,413
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### serve

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Router.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the server on the specified address.

```APIDOC
## pub async fn serve<ResBody>(self, addr: SocketAddr) -> Result<(), Error>

### Description
Consumes the router and starts the server on the provided `SocketAddr` using the tokio default executor.
```

--------------------------------

### serve

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the server and begins listening for incoming requests.

```APIDOC
## serve

### Description
Serves the provided service at the specified socket address.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
```

--------------------------------

### Panic on Server Start

Source: https://docs.rs/tonic/latest/tonic/service/struct.AxumRouter.html?search=

Example of starting a server that panics if binding fails.

```rust
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, handler.into_make_service()).await.unwrap();
```

--------------------------------

### serve_with_incoming

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=

Starts the server using a custom incoming stream of connections.

```APIDOC
## serve_with_incoming

### Description
Serves the service on the provided incoming stream. Note that tcp_nodelay and tcp_keepalive settings are ignored when using this method.

### Parameters
- **svc** (S) - The service to serve.
- **incoming** (I) - A stream of incoming connections.
```

--------------------------------

### serve

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=std%3A%3Avec

Starts the server to serve the provided service on the specified address.

```APIDOC
## pub async fn serve<S, ResBody>(self, addr: SocketAddr, svc: S) -> Result<(), Error>

### Description
Serve the service on the specified socket address.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
```

--------------------------------

### Server::serve

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=

Starts the server and begins listening for incoming requests on the specified address.

```APIDOC
## Server::serve

### Description
Serves the provided service on the specified socket address.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
```

--------------------------------

### Router::serve

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html

Consumes the server and starts it on the tokio default executor.

```APIDOC
## Router::serve

### Description
Starts the server on the provided socket address using the tokio default executor.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
```

--------------------------------

### serve

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=std%3A%3Avec

Consumes the server and starts it on the tokio default executor at the specified address.

```APIDOC
## serve<ResBody>(addr: SocketAddr) -> Result<(), super::Error>

### Description
Starts the server on the provided socket address using the configured routes and layers.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
```

--------------------------------

### serve

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html

Starts the gRPC service on the specified socket address.

```APIDOC
## pub async fn serve<S, ResBody>(self, addr: SocketAddr, svc: S) -> Result<(), Error>

### Description
Serve the service on the provided socket address.
```

--------------------------------

### serve

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Router.html?search=std%3A%3Avec

Consumes the router and starts the server on the specified socket address.

```APIDOC
### pub async fn serve<ResBody>(self, addr: SocketAddr) -> Result<(), Error>

Consumes this `Router` and creates a future that executes the server on tokio's default executor.
```

--------------------------------

### serve_with_incoming_shutdown

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=

Starts the server using a custom incoming stream and a shutdown signal.

```APIDOC
## serve_with_incoming_shutdown

### Description
Serves the service with a shutdown signal on the provided incoming stream.

### Parameters
- **svc** (S) - The service to serve.
- **incoming** (I) - A stream of incoming connections.
- **signal** (F) - A future that triggers the shutdown when it completes.
```

--------------------------------

### Configure and Start a Tonic Server

Source: https://docs.rs/tonic/latest/tonic/transport/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates setting up a Server with TLS identity and concurrency limits before serving on a specific address.

```rust
let cert = std::fs::read_to_string("server.pem")?;
let key = std::fs::read_to_string("server.key")?;

let addr = "[::1]:50051".parse()?;

Server::builder()
    .tls_config(ServerTlsConfig::new()
        .identity(Identity::from_pem(&cert, &key)))?
    .concurrency_limit_per_connection(256)
    .add_service(my_svc)
    .serve(addr)
    .await?;
```

--------------------------------

### serve_with_shutdown

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=

Starts the server with a provided shutdown signal future.

```APIDOC
## serve_with_shutdown

### Description
Serves the provided service with a shutdown signal. The server will stop accepting new connections when the signal future completes.

### Parameters
- **addr** (SocketAddr) - The address to bind the server to.
- **svc** (S) - The service to serve.
- **signal** (F) - A future that triggers the shutdown when it completes.
```

--------------------------------

### Basic Axum Server Setup

Source: https://docs.rs/tonic/latest/tonic/service/struct.AxumRouter.html?search=

Standard boilerplate for binding a TCP listener and serving an Axum router.

```rust
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, routes).await.unwrap();
```

--------------------------------

### serve_with_incoming<S, I, IO, IE, ResBody>(self, svc: S, incoming: I)

Source: https://docs.rs/tonic/latest/tonic/transport/struct.Server.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the gRPC service using a custom incoming stream of connections.

```APIDOC
## serve_with_incoming<S, I, IO, IE, ResBody>(self, svc: S, incoming: I)

### Description
Serves the service on the provided incoming stream. Note that `tcp_nodelay` and `tcp_keepalive` settings are ignored when using this method.

### Parameters
- **svc** (S) - The service implementation.
- **incoming** (I) - A stream of incoming connections.
```

--------------------------------

### Server Execution

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html

Methods to consume the server and start listening on a socket address.

```rust
pub async fn serve<ResBody>(self, addr: SocketAddr) -> Result<(), super::Error>
    where
        L: Layer<Routes> + Clone,
        L::Service: Service<Request<Body>, Response = Response<ResBody>> + Clone + Send + 'static,
        <<L as Layer<Routes>>::Service as Service<Request<Body>>>::Future: Send,
        <<L as Layer<Routes>>::Service as Service<Request<Body>>>::Error:
            Into<crate::BoxError> + Send,
        ResBody: http_body::Body<Data = Bytes> + Send + 'static,
        ResBody::Error: Into<crate::BoxError>,
    {
        self.server.serve(addr, self.routes.prepare()).await
    }
```

--------------------------------

### serve<S, ResBody>(self, addr: SocketAddr, svc: S)

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the server and serves the provided service on the specified socket address.

```APIDOC
## serve<S, ResBody>(self, addr: SocketAddr, svc: S)

### Description
Serve the service on the given address.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
```

--------------------------------

### serve_with_shutdown

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Router.html?search=std%3A%3Avec

Consumes the router and starts the server, with support for a graceful shutdown signal.

```APIDOC
### pub async fn serve_with_shutdown<F: Future<Output = ()>, ResBody>(self, addr: SocketAddr, signal: F) -> Result<(), Error>

Consumes this `Router` and executes the server, shutting down when the provided signal future completes.
```

--------------------------------

### Router::serve

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=

Consumes the server and starts execution on the tokio executor at the specified address.

```APIDOC
## serve

### Description
Starts the server and binds it to the provided socket address.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
```

--------------------------------

### Parsing Metadata Keys

Source: https://docs.rs/tonic/latest/tonic/metadata/struct.MetadataKey.html?search=

Examples demonstrating the creation of MetadataKey instances and common validation failures.

```rust
// Parsing a metadata key
let CUSTOM_KEY: &'static str = "custom-key";

let a = AsciiMetadataKey::from_bytes(b"custom-key").unwrap();
let b = AsciiMetadataKey::from_static(CUSTOM_KEY);
assert_eq!(a, b);
```

```rust
// Parsing a metadata key that contains invalid symbols(s):
AsciiMetadataKey::from_static("content{}{}length"); // This line panics!
```

```rust
// Parsing a metadata key that contains invalid uppercase characters.
let a = AsciiMetadataKey::from_static("foobar");
let b = AsciiMetadataKey::from_static("FOOBAR"); // This line panics!
```

```rust
// Parsing a -bin metadata key as an Ascii key.
let b = AsciiMetadataKey::from_static("hello-bin"); // This line panics!
```

```rust
// Parsing a non-bin metadata key as an Binary key.
let b = BinaryMetadataKey::from_static("hello"); // This line panics!
```

--------------------------------

### Retrieve Endpoint URI

Source: https://docs.rs/tonic/latest/src/tonic/transport/channel/endpoint.rs.html?search=

Example demonstrating how to retrieve the URI from an Endpoint instance.

```rust
let endpoint = Endpoint::from_static("https://example.com");

assert_eq!(endpoint.uri(), &Uri::from_static("https://example.com"));
```

--------------------------------

### Configure file descriptor set path

Source: https://docs.rs/tonic/latest/tonic/macro.include_file_descriptor_set.html?search=

Example of configuring the file descriptor set path in a build.rs file.

```rust
let descriptor_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("my_descriptor.bin")
tonic_build::configure()
    .file_descriptor_set_path(&descriptor_path)
    .compile_protos(&["proto/reflection.proto"], &["proto/"])?;
```

--------------------------------

### Configure gRPC Server Compression and Limits

Source: https://docs.rs/tonic/latest/src/tonic/server/grpc.rs.html?search=

Examples of configuring compression and message size limits on a generated gRPC server.

```rust
# enum CompressionEncoding { Gzip }
# struct Svc;
# struct ExampleServer<T>(T);
# impl<T> ExampleServer<T> {
#     fn new(svc: T) -> Self { Self(svc) }
#     fn accept_compressed(self, _: CompressionEncoding) -> Self { self }
# }
# #[tonic::async_trait]
# trait Example {}

#[tonic::async_trait]
impl Example for Svc {
    // ...
}

let service = ExampleServer::new(Svc).accept_compressed(CompressionEncoding::Gzip);
```

```rust
# enum CompressionEncoding { Gzip }
# struct Svc;
# struct ExampleServer<T>(T);
# impl<T> ExampleServer<T> {
#     fn new(svc: T) -> Self { Self(svc) }
#     fn send_compressed(self, _: CompressionEncoding) -> Self { self }
# }
# #[tonic::async_trait]
# trait Example {}

#[tonic::async_trait]
impl Example for Svc {
    // ...
}

let service = ExampleServer::new(Svc).send_compressed(CompressionEncoding::Gzip);
```

```rust
# struct Svc;
# struct ExampleServer<T>(T);
# impl<T> ExampleServer<T> {
#     fn new(svc: T) -> Self { Self(svc) }
#     fn max_decoding_message_size(self, _: usize) -> Self { self }
# }
# #[tonic::async_trait]
# trait Example {}

#[tonic::async_trait]
impl Example for Svc {
    // ...
```

--------------------------------

### Define complex routing patterns

Source: https://docs.rs/tonic/latest/tonic/service/struct.AxumRouter.html?search=

Example demonstrating various route types including static paths, captures, and wildcards.

```rust
use axum::{Router, routing::{get, delete}, extract::Path};

let app = Router::new()
    .route("/", get(root))
    .route("/users", get(list_users).post(create_user))
    .route("/users/{id}", get(show_user))
    .route("/api/{version}/users/{id}/action", delete(do_users_action))
    .route("/assets/{*path}", get(serve_asset));

async fn root() {}

async fn list_users() {}

async fn create_user() {}

async fn show_user(Path(id): Path<u64>) {}

async fn do_users_action(Path((version, id)): Path<(String, u64)>) {}

async fn serve_asset(Path(path): Path<String>) {}
```

--------------------------------

### serve_with_shutdown

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=

Starts the gRPC service with a graceful shutdown signal.

```APIDOC
## pub async fn serve_with_shutdown<S, F, ResBody>(self, addr: SocketAddr, svc: S, signal: F) -> Result<(), Error>

### Description
Serve the service with the provided shutdown signal.
```

--------------------------------

### serve<ResBody>(self, addr: SocketAddr) -> Result<(), Error>

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Router.html?search=u32+-%3E+bool

Consumes the router and starts the server on the specified socket address.

```APIDOC
## pub async fn serve<ResBody>(self, addr: SocketAddr) -> Result<(), Error>

### Description
Consumes this Router, creating a future that will execute the server on tokio's default executor at the provided address.
```

--------------------------------

### Configure a gRPC Server with TLS and Limits

Source: https://docs.rs/tonic/latest/src/tonic/transport/mod.rs.html

Demonstrates initializing a Server with TLS identity and per-connection concurrency limits.

```rust
# use std::convert::Infallible;
# #[cfg(feature = "rustls")]
# use tonic::transport::{Server, Identity, ServerTlsConfig};
# use tonic::body::Body;
# use tower::Service;
# #[cfg(feature = "rustls")]
# async fn do_thing() -> Result<(), Box<dyn std::error::Error>> {
# #[derive(Clone)]
# pub struct Svc;
# impl Service<hyper::Request<Body>> for Svc {
#   type Response = hyper::Response<Body>;
#   type Error = Infallible;
#   type Future = std::future::Ready<Result<Self::Response, Self::Error>>;
#   fn poll_ready(&mut self, _cx: &mut std::task::Context<'_>) -> std::task::Poll<Result<(), Self::Error>> {
#       Ok(()).into()
#  }
#   fn call(&mut self, _req: hyper::Request<Body>) -> Self::Future {
#       unimplemented!()
#   }
# }
# impl tonic::server::NamedService for Svc {
# const NAME: &'static str = "some_svc";
# }
# let my_svc = Svc;
let cert = std::fs::read_to_string("server.pem")?;
let key = std::fs::read_to_string("server.key")?;

let addr = "[::1]:50051".parse()?;

Server::builder()
    .tls_config(ServerTlsConfig::new()
        .identity(Identity::from_pem(&cert, &key)))?
    .concurrency_limit_per_connection(256)
    .add_service(my_svc)
    .serve(addr)
    .await?;

# Ok(())
# }
```

--------------------------------

### Get slice length

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Configure a gRPC Client with TLS and Limits

Source: https://docs.rs/tonic/latest/src/tonic/transport/mod.rs.html

Demonstrates setting up a Channel with TLS configuration, request timeouts, rate limiting, and concurrency limits.

```rust
# #[cfg(feature = "rustls")]
# use tonic::transport::{Channel, Certificate, ClientTlsConfig};
# use std::time::Duration;
# use tonic::client::GrpcService;;
# use http::Request;
# #[cfg(feature = "rustls")]
# async fn do_thing() -> Result<(), Box<dyn std::error::Error>> {
let cert = std::fs::read_to_string("ca.pem")?;

let mut channel = Channel::from_static("https://example.com")
    .tls_config(ClientTlsConfig::new()
        .ca_certificate(Certificate::from_pem(&cert))
        .domain_name("example.com".to_string()))?
    .timeout(Duration::from_secs(5))
    .rate_limit(5, Duration::from_secs(1))
    .concurrency_limit(256)
    .connect()
    .await?;

channel.call(Request::new(tonic::body::empty_body())).await?;
# Ok(())
# }
```

--------------------------------

### Get path component

Source: https://docs.rs/tonic/latest/tonic/transport/struct.Uri.html

Retrieves the path component from a Uri.

```rust
let uri: Uri = "/hello/world".parse().unwrap();

assert_eq!(uri.path(), "/hello/world");
```

```rust
let uri: Uri = "http://example.org/hello/world".parse().unwrap();
```

--------------------------------

### Configure and Connect a Tonic Client

Source: https://docs.rs/tonic/latest/tonic/transport/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates initializing a Channel with TLS configuration, timeouts, rate limiting, and concurrency limits.

```rust
let cert = std::fs::read_to_string("ca.pem")?;

let mut channel = Channel::from_static("https://example.com")
    .tls_config(ClientTlsConfig::new()
        .ca_certificate(Certificate::from_pem(&cert))
        .domain_name("example.com".to_string()))?
    .timeout(Duration::from_secs(5))
    .rate_limit(5, Duration::from_secs(1))
    .concurrency_limit(256)
    .connect()
    .await?;

channel.call(Request::new(tonic::body::empty_body())).await?;
```

--------------------------------

### Get MetadataMap Capacity

Source: https://docs.rs/tonic/latest/tonic/metadata/struct.MetadataMap.html?search=

Returns the current capacity of the map.

```rust
let mut map = MetadataMap::new();

assert_eq!(0, map.capacity());

map.insert("x-host", "hello.world".parse().unwrap());
assert_eq!(6, map.capacity());
```

--------------------------------

### ServerTlsConfig::new

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/tls.rs.html?search=std%3A%3Avec

Creates a new instance of ServerTlsConfig with default settings.

```APIDOC
### Method
`ServerTlsConfig::new()`

### Description
Creates a new `ServerTlsConfig` with default values.
```

--------------------------------

### Certificate::get_mut

Source: https://docs.rs/tonic/latest/tonic/transport/struct.Certificate.html?search=

Get a mutable reference to the underlying certificate bytes.

```APIDOC
## pub fn get_mut(&mut self) -> &mut [u8]

### Description
Get a mutable reference to the underlying certificate bytes.
```

--------------------------------

### Configure Server TCP Settings

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html?search=

Demonstrates how to initialize a Tonic server with default TCP settings and how to override them using the builder pattern.

```rust
#[test]
    fn server_tcp_defaults() {
        const EXAMPLE_TCP_KEEPALIVE: Duration = Duration::from_secs(10);
        const EXAMPLE_TCP_KEEPALIVE_INTERVAL: Duration = Duration::from_secs(5);
        const EXAMPLE_TCP_KEEPALIVE_RETRIES: u32 = 3;

        // Using ::builder() or ::default() should do the same thing
        let server_via_builder = Server::builder();
        assert!(server_via_builder.tcp_nodelay);
        assert_eq!(server_via_builder.tcp_keepalive, None);
        assert_eq!(server_via_builder.tcp_keepalive_interval, None);
        assert_eq!(server_via_builder.tcp_keepalive_retries, None);
        let server_via_default = Server::default();
        assert!(server_via_default.tcp_nodelay);
        assert_eq!(server_via_default.tcp_keepalive, None);
        assert_eq!(server_via_default.tcp_keepalive_interval, None);
        assert_eq!(server_via_default.tcp_keepalive_retries, None);

        // overriding should be possible
        let server_via_builder = Server::builder()
            .tcp_nodelay(false)
            .tcp_keepalive(Some(EXAMPLE_TCP_KEEPALIVE))
            .tcp_keepalive_interval(Some(EXAMPLE_TCP_KEEPALIVE_INTERVAL))
            .tcp_keepalive_retries(Some(EXAMPLE_TCP_KEEPALIVE_RETRIES));
        assert!(!server_via_builder.tcp_nodelay);
        assert_eq!(
            server_via_builder.tcp_keepalive,
            Some(EXAMPLE_TCP_KEEPALIVE)
        );
        assert_eq!(
            server_via_builder.tcp_keepalive_interval,
            Some(EXAMPLE_TCP_KEEPALIVE_INTERVAL)
        );
        assert_eq!(
            server_via_builder.tcp_keepalive_retries,
            Some(EXAMPLE_TCP_KEEPALIVE_RETRIES)
        );
    }
```

--------------------------------

### Certificate::get_ref

Source: https://docs.rs/tonic/latest/tonic/transport/struct.Certificate.html?search=

Get an immutable reference to the underlying certificate bytes.

```APIDOC
## pub fn get_ref(&self) -> &[u8]

### Description
Get an immutable reference to the underlying certificate bytes.
```

--------------------------------

### Basic MetadataMap Usage

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Demonstrates how to initialize a MetadataMap, insert ASCII and binary values, check for key existence, retrieve values, and remove entries.

```rust
# use tonic::metadata::*;
let mut map = MetadataMap::new();

map.insert("x-host", "example.com".parse().unwrap());
map.insert("x-number", "123".parse().unwrap());
map.insert_bin("trace-proto-bin", MetadataValue::from_bytes(b"[binary data]"));

assert!(map.contains_key("x-host"));
assert!(!map.contains_key("x-location"));

assert_eq!(map.get("x-host").unwrap(), "example.com");

map.remove("x-host");

assert!(!map.contains_key("x-host"));
```

--------------------------------

### Get length of Extensions

Source: https://docs.rs/tonic/latest/tonic/struct.Extensions.html?search=

Return the number of entries in the extensions map.

```rust
let mut ext = Extensions::new();
assert_eq!(ext.len(), 0);
ext.insert(5i32);
assert_eq!(ext.len(), 1);
```

--------------------------------

### Create and compare MetadataKey instances

Source: https://docs.rs/tonic/latest/tonic/metadata/struct.MetadataKey.html

Demonstrates creating MetadataKey instances from bytes and static strings and verifying their equality.

```rust
// Parsing a metadata key
let CUSTOM_KEY: &'static str = "custom-key";

let a = AsciiMetadataKey::from_bytes(b"custom-key").unwrap();
let b = AsciiMetadataKey::from_static(CUSTOM_KEY);
assert_eq!(a, b);
```

--------------------------------

### Get values from Extensions

Source: https://docs.rs/tonic/latest/tonic/struct.Extensions.html?search=

Retrieve a reference to a previously inserted type.

```rust
let mut ext = Extensions::new();
assert!(ext.get::<i32>().is_none());
ext.insert(5i32);

assert_eq!(ext.get::<i32>(), Some(&5i32));
```

--------------------------------

### Get length of AsciiMetadataValue

Source: https://docs.rs/tonic/latest/src/tonic/metadata/value.rs.html?search=

Shows how to retrieve the byte length of an AsciiMetadataValue.

```rust
# use tonic::metadata::*;
let val = AsciiMetadataValue::from_static("hello");
assert_eq!(val.len(), 5);
```

--------------------------------

### Iterate Mutably over MetadataMap

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=u32+-%3E+bool

Examples of mutable iteration over MetadataMap entries.

```rust
#[test]
fn test_iter_mut_categorizes_ascii_entries() {
    let mut map = MetadataMap::new();

    map.insert("x-word", "hello".parse().unwrap());
    map.append_bin("x-word-bin", MetadataValue::from_bytes(b"goodbye"));
    map.insert_bin("x-number-bin", MetadataValue::from_bytes(b"123"));

    let mut found_x_word = false;
    for key_and_value in map.iter_mut() {
        if let KeyAndMutValueRef::Ascii(key, _value) = key_and_value {
            if key.as_str() == "x-word" {
                found_x_word = true;
            } else {
                panic!("Unexpected key");
            }
        }
    }
    assert!(found_x_word);
}
```

```rust
#[test]
fn test_iter_mut_categorizes_binary_entries() {
    let mut map = MetadataMap::new();

    map.insert("x-word", "hello".parse().unwrap());
    map.append_bin("x-word-bin", MetadataValue::from_bytes(b"goodbye"));

    let mut found_x_word_bin = false;
    for key_and_value in map.iter_mut() {
        if let KeyAndMutValueRef::Binary(key, _value) = key_and_value {
            if key.as_str() == "x-word-bin" {
                found_x_word_bin = true;
            } else {
                panic!("Unexpected key");
            }
        }
    }
    assert!(found_x_word_bin);
}
```

--------------------------------

### Routes::new

Source: https://docs.rs/tonic/latest/src/tonic/service/router.rs.html?search=u32+-%3E+bool

Creates a new Routes instance with an initial service.

```APIDOC
## pub fn new<S>(svc: S) -> Self

### Description
Creates a new Routes instance and adds the provided service to it.

### Parameters
- **svc** (S) - Required - The initial service to register.
```

--------------------------------

### pub async fn serve_with_incoming_shutdown<S, I, F, IO, IE, ResBody>(self, svc: S, incoming: I, signal: F) -> Result<(), Error>

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=u32+-%3E+bool

Starts the gRPC service using a custom incoming stream with a graceful shutdown signal.

```APIDOC
## pub async fn serve_with_incoming_shutdown<S, I, F, IO, IE, ResBody>(self, svc: S, incoming: I, signal: F) -> Result<(), Error>

### Description
Serve the service with the signal on the provided incoming stream.

### Parameters
- **svc** (S) - Required - The service to be served.
- **incoming** (I) - Required - A stream of incoming connections.
- **signal** (F) - Required - A future that triggers the shutdown when completed.
```

--------------------------------

### MetadataMap Usage

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Demonstrates how to initialize a MetadataMap, insert ASCII and binary values, check for key existence, retrieve values, and remove entries.

```APIDOC
## MetadataMap

### Description
MetadataMap is a collection of gRPC custom metadata entries. It supports both standard ASCII metadata and binary metadata (keys ending in '-bin').

### Usage Example
```rust
use tonic::metadata::*;

let mut map = MetadataMap::new();

// Insert ASCII metadata
map.insert("x-host", "example.com".parse().unwrap());

// Insert binary metadata
map.insert_bin("trace-proto-bin", MetadataValue::from_bytes(b"[binary data]"));

// Check for keys
assert!(map.contains_key("x-host"));

// Retrieve values
assert_eq!(map.get("x-host").unwrap(), "example.com");

// Remove entries
map.remove("x-host");
```
```

--------------------------------

### Get last element

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html

Returns the last element of the slice, or None if empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Configure and Run Server Connection Loop

Source: https://docs.rs/tonic/latest/src/tonic/transport/server/mod.rs.html

Configures the HTTP/2 connection builder and manages the main server loop for accepting and serving incoming connections.

```rust
let http2_adaptive_window = self.http2_adaptive_window;
        let http2_max_pending_accept_reset_streams = self.http2_max_pending_accept_reset_streams;
        let http2_max_local_error_reset_streams = self.http2_max_local_error_reset_streams;
        let max_connection_age = self.max_connection_age;
        let max_connection_age_grace = self.max_connection_age_grace;

        let svc = self.service_builder.service(svc);

        let incoming = io_stream::ServerIoStream::new(
            incoming,
            #[cfg(feature = "_tls-any")]
            self.tls,
        );
        let mut svc = MakeSvc {
            inner: svc,
            concurrency_limit,
            load_shed,
            timeout,
            trace_interceptor,
            _io: PhantomData,
        };

        let server = {
            let mut builder = ConnectionBuilder::new(TokioExecutor::new());

            if http2_only {
                builder = builder.http2_only();
            }

            builder
                .http2()
                .timer(TokioTimer::new())
                .initial_connection_window_size(init_connection_window_size)
                .initial_stream_window_size(init_stream_window_size)
                .max_concurrent_streams(max_concurrent_streams)
                .keep_alive_interval(http2_keepalive_interval)
                .keep_alive_timeout(http2_keepalive_timeout)
                .adaptive_window(http2_adaptive_window.unwrap_or_default())
                .max_pending_accept_reset_streams(http2_max_pending_accept_reset_streams)
                .max_local_error_reset_streams(http2_max_local_error_reset_streams)
                .max_frame_size(max_frame_size);

            if let Some(max_header_list_size) = max_header_list_size {
                builder.http2().max_header_list_size(max_header_list_size);
            }

            builder
        };

        let (signal_tx, signal_rx) = tokio::sync::watch::channel(());
        let signal_tx = Arc::new(signal_tx);

        let graceful = signal.is_some();
        let mut sig = pin!(Fuse { inner: signal });
        let mut incoming = pin!(incoming);

        loop {
            tokio::select! {
                _ = &mut sig => {
                    trace!("signal received, shutting down");
                    break;
                },
                io = incoming.next() => {
                    let io = match io {
                        Some(Ok(io)) => io,
                        Some(Err(e)) => {
                            trace!("error accepting connection: {}", DisplayErrorStack(&*e));
                            continue;
                        },
                        None => {
                            break
                        },
                    };

                    trace!("connection accepted");

                    let req_svc = svc
                        .call(&io)
                        .await
                        .map_err(super::Error::from_source)?;

                    let hyper_io = TokioIo::new(io);
                    let hyper_svc = TowerToHyperService::new(req_svc.map_request(|req: Request<Incoming>| req.map(Body::new)));

                    serve_connection(hyper_io, hyper_svc, server.clone(), graceful.then(|| signal_rx.clone()), max_connection_age, max_connection_age_grace);
                }
            }
        }

        if graceful {
            let _ = signal_tx.send(());
            drop(signal_rx);
            trace!(
                "waiting for {} connections to close",
                signal_tx.receiver_count()
            );

            // Wait for all connections to close
            signal_tx.closed().await;
        }

        Ok(())
    }
}
```

--------------------------------

### Get first element

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html

Returns the first element of the slice, or None if empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### include_proto!

Source: https://docs.rs/tonic/latest/tonic/macro.include_proto.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A macro to include generated proto server and client items by specifying the gRPC package name.

```APIDOC
## include_proto!

### Description
Includes generated gRPC server and client items into the current scope. This macro requires the gRPC package name as an argument and relies on the default `OUT_DIR` environment variable set by `tonic-build`.

### Usage
```rust
mod pb {
    tonic::include_proto!("helloworld");
}
```
```

--------------------------------

### Get MetadataValue length

Source: https://docs.rs/tonic/latest/src/tonic/metadata/value.rs.html?search=u32+-%3E+bool

Returns the length of the MetadataValue in bytes for Ascii encoding.

```rust
/// # Examples
///
/// ```
/// # use tonic::metadata::*;
/// let val = AsciiMetadataValue::from_static("hello");
/// assert_eq!(val.len(), 5);
/// ```
#[inline]
pub fn len(&self) -> usize {
    self.inner.len()
}
```

--------------------------------

### include_proto!

Source: https://docs.rs/tonic/latest/tonic/macro.include_proto.html?search=std%3A%3Avec

A macro to include generated gRPC server and client items based on the specified package name.

```APIDOC
## include_proto!(package)

### Description
Includes generated gRPC server and client items into the current scope. This macro requires the gRPC package name as an argument and relies on the default `OUT_DIR` environment variable set by `tonic-build`.

### Usage
```rust
mod pb {
    tonic::include_proto!("helloworld");
}
```
```

--------------------------------

### Creating and Validating MetadataKeys

Source: https://docs.rs/tonic/latest/src/tonic/metadata/key.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples demonstrating the creation of AsciiMetadataKey from bytes and static strings, as well as scenarios that trigger panics due to invalid characters or incorrect encoding types.

```rust
# use tonic::metadata::*;
// Parsing a metadata key
let CUSTOM_KEY: &'static str = "custom-key";

let a = AsciiMetadataKey::from_bytes(b"custom-key").unwrap();
let b = AsciiMetadataKey::from_static(CUSTOM_KEY);
assert_eq!(a, b);
```

```rust
# use tonic::metadata::*;
// Parsing a metadata key that contains invalid symbols(s):
AsciiMetadataKey::from_static("content{}{}length"); // This line panics!
```

```rust
# use tonic::metadata::*;
// Parsing a metadata key that contains invalid uppercase characters.
let a = AsciiMetadataKey::from_static("foobar");
let b = AsciiMetadataKey::from_static("FOOBAR"); // This line panics!
```

```rust
# use tonic::metadata::*;
// Parsing a -bin metadata key as an Ascii key.
let b = AsciiMetadataKey::from_static("hello-bin"); // This line panics!
```

```rust
# use tonic::metadata::*;
// Parsing a non-bin metadata key as an Binary key.
let b = BinaryMetadataKey::from_static("hello"); // This line panics!
```

--------------------------------

### serve_with_shutdown<S, F, ResBody>(self, addr: SocketAddr, svc: S, signal: F)

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the server and serves the provided service, with support for a graceful shutdown signal.

```APIDOC
## serve_with_shutdown<S, F, ResBody>(self, addr: SocketAddr, svc: S, signal: F)

### Description
Serve the service with the shutdown signal.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
- **signal** (F) - Required - A future that triggers the server shutdown.
```

--------------------------------

### Trim ASCII whitespace from start

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html

Removes leading ASCII whitespace bytes from the slice.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

--------------------------------

### pub async fn serve<S, ResBody>(self, addr: SocketAddr, svc: S) -> Result<(), Error>

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=u32+-%3E+bool

Starts the gRPC service on the specified socket address.

```APIDOC
## pub async fn serve<S, ResBody>(self, addr: SocketAddr, svc: S) -> Result<(), Error>

### Description
Serve the service on the provided socket address.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
```

--------------------------------

### include_proto!

Source: https://docs.rs/tonic/latest/src/tonic/macros.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Includes generated gRPC server and client items from the tonic-build output directory.

```APIDOC
## macro include_proto!($package)

### Description
Includes generated gRPC server and client items. The macro expects the gRPC package name as an argument and assumes the files are located in the directory specified by the OUT_DIR environment variable.

### Usage
```rust
mod pb {
    tonic::include_proto!("helloworld");
}
```
```

--------------------------------

### Get first chunk

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html

Returns an array reference to the first N items in the slice.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### Get MetadataMap Key Count

Source: https://docs.rs/tonic/latest/tonic/metadata/struct.MetadataMap.html?search=

Returns the number of unique keys stored in the map.

```rust
let mut map = MetadataMap::new();

assert_eq!(0, map.keys_len());

map.insert("x-host-ip", "127.0.0.1".parse().unwrap());
map.insert_bin("x-host-name-bin", MetadataValue::from_bytes(b"localhost"));

assert_eq!(2, map.keys_len());

map.append("x-host-ip", "text/html".parse().unwrap());

assert_eq!(2, map.keys_len());
```

--------------------------------

### Initialize and call UserAgent service

Source: https://docs.rs/tonic/latest/src/tonic/transport/channel/service/user_agent.rs.html?search=

Demonstrates creating a new UserAgent instance with a custom service and header value, then executing a call.

```rust
let expected_user_agent = format!("request-ua/x.y Greeter 1.1 {TONIC_USER_AGENT}");
        let mut ua = UserAgent::new(
            TestSvc {
                expected_user_agent,
            },
            Some(HeaderValue::from_static("Greeter 1.1")),
        );
        let _ = ua.call(req).await;
    }
}
```

--------------------------------

### get<K>

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=

Retrieves a reference to the ASCII metadata value associated with the given key.

```APIDOC
## fn get<K>(&self, key: K) -> Option<&MetadataValue<Ascii>>

### Description
Returns a reference to the value associated with the key for ASCII metadata. If multiple values exist, the first one is returned.

### Parameters
- **key** (K) - Required - The key to look up, must implement AsMetadataKey<Ascii>.

### Returns
- **Option<&MetadataValue<Ascii>>** - The metadata value if found, otherwise None.
```

--------------------------------

### Get number of keys in the map

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Returns the count of unique keys stored in the map.

```rust
# use tonic::metadata::*;
let mut map = MetadataMap::new();

assert_eq!(0, map.keys_len());

map.insert("x-host-ip", "127.0.0.1".parse().unwrap());
map.insert_bin("x-host-name-bin", MetadataValue::from_bytes(b"localhost"));

assert_eq!(2, map.keys_len());

map.append("x-host-ip", "text/html".parse().unwrap());

assert_eq!(2, map.keys_len());
```

--------------------------------

### serve_with_incoming<S, I, IO, IE, ResBody>(self, svc: S, incoming: I)

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Serves the service on a provided incoming stream of connections.

```APIDOC
## serve_with_incoming<S, I, IO, IE, ResBody>(self, svc: S, incoming: I)

### Description
Serve the service on the provided incoming stream. Note that `tcp_nodelay` and `tcp_keepalive` settings are ignored when using this method.

### Parameters
- **svc** (S) - Required - The service to be served.
- **incoming** (I) - Required - The stream of incoming connections.
```

--------------------------------

### Checking Result Status

Source: https://docs.rs/tonic/latest/tonic/type.Result.html?search=std%3A%3Avec

Examples of using is_ok and is_ok_and to inspect Result values.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### Split slice into chunks

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html?search=

Methods for splitting slices into fixed-size array references from the start or end.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

assert_eq!(None, x.split_first_chunk::<4>());
```

```rust
let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());
```

--------------------------------

### Body Creation Methods

Source: https://docs.rs/tonic/latest/tonic/body/struct.Body.html?search=

Methods to initialize a new Body instance.

```rust
pub const fn empty() -> Self
```

```rust
pub fn new<B>(body: B) -> Self
where B: Body<Data = Bytes> + Send + 'static, B::Error: Into<Box<dyn Error + Send + Sync>>,
```

--------------------------------

### into_make_service

Source: https://docs.rs/tonic/latest/tonic/service/struct.AxumRouter.html?search=

Converts the router into a MakeService, which is a service that produces other services, typically used for starting a server.

```APIDOC
## pub fn into_make_service(self) -> IntoMakeService<Router>

### Description
Convert this router into a `MakeService`, that is a `Service` whose response is another service. This is the standard way to prepare a router for use with `axum::serve`.

### Example
```rust
use axum::{routing::get, Router};

let app = Router::new().route("/", get(|| async { "Hi!" }));

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();
```
```

--------------------------------

### pub async fn serve_with_shutdown<S, F, ResBody>(self, addr: SocketAddr, svc: S, signal: F) -> Result<(), Error>

Source: https://docs.rs/tonic/latest/tonic/transport/server/struct.Server.html?search=u32+-%3E+bool

Starts the gRPC service on the specified address with a graceful shutdown signal.

```APIDOC
## pub async fn serve_with_shutdown<S, F, ResBody>(self, addr: SocketAddr, svc: S, signal: F) -> Result<(), Error>

### Description
Serve the service on the provided address with a shutdown signal.

### Parameters
- **addr** (SocketAddr) - Required - The address to bind the server to.
- **svc** (S) - Required - The service to be served.
- **signal** (F) - Required - A future that triggers the shutdown when completed.
```

--------------------------------

### Get pointer range of slice

Source: https://docs.rs/tonic/latest/tonic/transport/struct.CertificateDer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a half-open range of raw pointers spanning the slice.

```rust
let a = [1, 2, 3];
let x = &a[1] as *const _;
let y = &5 as *const _;

assert!(a.as_ptr_range().contains(&x));
assert!(!a.as_ptr_range().contains(&y));
```

--------------------------------

### include_proto!

Source: https://docs.rs/tonic/latest/src/tonic/macros.rs.html?search=

Includes the generated gRPC server and client items from the default output directory.

```APIDOC
## macro_rules! include_proto

### Description
Includes generated proto server and client items. This macro expects the gRPC package name as an argument and assumes the tonic-build output directory is the default `OUT_DIR`.

### Usage
```rust
mod pb {
    tonic::include_proto!("helloworld");
}
```
```

--------------------------------

### Get or insert value

Source: https://docs.rs/tonic/latest/tonic/struct.Extensions.html?search=

Retrieve a mutable reference to a type, inserting the provided value if it does not exist.

```rust
let mut ext = Extensions::new();
*ext.get_or_insert(1i32) += 2;

assert_eq!(*ext.get::<i32>().unwrap(), 3);
```

--------------------------------

### Get mutable reference to Extensions values

Source: https://docs.rs/tonic/latest/tonic/struct.Extensions.html?search=

Retrieve a mutable reference to a previously inserted type.

```rust
let mut ext = Extensions::new();
ext.insert(String::from("Hello"));
ext.get_mut::<String>().unwrap().push_str(" World");

assert_eq!(ext.get::<String>().unwrap(), "Hello World");
```

--------------------------------

### Configure Request Compression

Source: https://docs.rs/tonic/latest/src/tonic/client/grpc.rs.html?search=

Demonstrates how to enable request compression using a generated tonic client.

```rust
use tonic::transport::Channel;
# enum CompressionEncoding { Gzip }
# struct TestClient<T>(T);
# impl<T> TestClient<T> {
#     fn new(channel: T) -> Self { Self(channel) }
#     fn send_compressed(self, _: CompressionEncoding) -> Self { self }
# }

# async {
let channel = Channel::builder("127.0.0.1:3000".parse().unwrap())
    .connect()
    .await
    .unwrap();

let client = TestClient::new(channel).send_compressed(CompressionEncoding::Gzip);
# };
```

--------------------------------

### Convert HTTP Headers to MetadataMap

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Demonstrates initializing a MetadataMap from an existing http::HeaderMap.

```rust
fn test_from_headers_takes_http_headers() {
        let mut http_map = http::HeaderMap::new();
        http_map.insert("x-host", "example.com".parse().unwrap());

        let map = MetadataMap::from_headers(http_map);

        assert_eq!(map.get("x-host").unwrap(), "example.com");
    }
```

--------------------------------

### entry_bin

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Gets the given binary key's corresponding entry in the map for in-place manipulation.

```APIDOC
## fn entry_bin<K>(&mut self, key: K) -> Result<Entry<'_, Binary>, InvalidMetadataKey>

### Description
Gets the given binary key's corresponding entry in the map for in-place manipulation.

### Parameters
- **key** (K) - Required - The key to look up, must implement AsMetadataKey<Binary>.

### Returns
- **Result<Entry<'_, Binary>, InvalidMetadataKey>** - An entry for the specified binary key or an error if the key is invalid.
```

--------------------------------

### entry

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Gets the given ASCII key's corresponding entry in the map for in-place manipulation.

```APIDOC
## fn entry<K>(&mut self, key: K) -> Result<Entry<'_, Ascii>, InvalidMetadataKey>

### Description
Gets the given ASCII key's corresponding entry in the map for in-place manipulation. For binary keys, use `entry_bin`.

### Parameters
- **key** (K) - Required - The key to look up, must implement AsMetadataKey<Ascii>.

### Returns
- **Result<Entry<'_, Ascii>, InvalidMetadataKey>** - An entry for the specified key or an error if the key is invalid.
```

--------------------------------

### Get map capacity

Source: https://docs.rs/tonic/latest/src/tonic/metadata/map.rs.html?search=std%3A%3Avec

Returns the approximate number of entries the map can hold before requiring reallocation.

```rust
# use tonic::metadata::*;
let mut map = MetadataMap::new();

assert_eq!(0, map.capacity());

map.insert("x-host", "hello.world".parse().unwrap());
assert_eq!(6, map.capacity());
```

--------------------------------

### Initialize UserAgent Service

Source: https://docs.rs/tonic/latest/src/tonic/transport/channel/service/user_agent.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Instantiate a UserAgent wrapper with a custom service and header value.

```rust
let expected_user_agent = format!("request-ua/x.y Greeter 1.1 {TONIC_USER_AGENT}");
let mut ua = UserAgent::new(
    TestSvc {
        expected_user_agent,
    },
    Some(HeaderValue::from_static("Greeter 1.1")),
);
let _ = ua.call(req).await;
```

--------------------------------

### Cloning Result Contents

Source: https://docs.rs/tonic/latest/tonic/type.Result.html?search=u32+-%3E+bool

Examples of using cloned() to map Result<&T, E> to Result<T, E>.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```
Tokens:
Raw