Resposta

Em um Handler, a Response é passada como parâmetro:

A estrutura Response encapsula todos os componentes de uma resposta HTTP, fornecendo uma API abrangente para construir e manipular respostas HTTP.
Suporta um estilo fluente e encadeável (ex.: res.status_code(200).body("Hello")), facilitando a construção suave de respostas.
As funcionalidades principais incluem:
- Definir códigos de status e cabeçalhos
- Manipular o corpo da resposta (suportando strings, bytes, arquivos e dados em fluxo)
- Gerenciar cookies
- Múltiplos métodos de renderização de conteúdo
Esta estrutura emprega um padrão de referência mutável, retornando uma referência a si mesma via &mut self, permitindo que os handlers construam e personalizem convenientemente respostas HTTP para atender a diversos requisitos de serviços web.

#[handler]
async fn hello_world(res: &mut Response) {
    res.render("Hello world!");
}

Após o servidor receber uma requisição do cliente, qualquer Handler ou middleware correspondente pode escrever dados na Response. Em certos cenários, como quando um middleware deseja impedir a execução de middlewares e Handlers subsequentes, você pode usar FlowCtrl:

#[handler]
async fn hello_world(res: &mut Response, ctrl: &mut FlowCtrl) {
    ctrl.skip_rest();
    res.render("Hello world!");
}

Escrevendo Conteúdo

Escrever dados em uma Response é direto:

Escrevendo dados de texto simples
```
res.render("Hello world!");
```

Escrevendo dados serializados em JSON

use serde::Serialize;
use salvo::prelude::Json;

#[derive(Serialize, Debug)]
struct User {
    name: String,
}
let user = User{name: "jobs".to_string()};
res.render(Json(user));

Warning

Se o método render for chamado múltiplas vezes para escrever dados JSON, esses dados não serão mesclados em um único objeto JSON. Em vez disso, serão concatenados sequencialmente como fragmentos de texto independentes, potencialmente resultando em um formato JSON inválido. Se múltiplos itens de dados precisarem ser retornados, eles devem ser combinados em um único objeto antes da serialização, ou a lógica deve ser tratada manualmente.

Escrevendo HTML

res.render(Text::Html("<html><body>hello</body></html>"));

Escrevendo Erros HTTP

Usar render permite escrever informações detalhadas de erro na Response.

use salvo::http::errors::*;
res.render(StatusError::internal_server_error().brief("error when serialize object to json"))

Se informações de erro personalizadas não forem necessárias, você pode chamar diretamente set_http_code.
```
use salvo::http::StatusCode;
res.status_code(StatusCode::BAD_REQUEST);
```

Redirecionando para Outra URL

Usando o método render, você pode escrever uma resposta de redirecionamento na Response, navegando para uma nova URL. Quando você chama Redirect::found, ele define o código de status HTTP para 302 (Found), indicando um redirecionamento temporário.
```
use salvo::prelude::*;

#[handler]
async fn redirect(res: &mut Response) {
    res.render(Redirect::found("https://salvo.rs/"));
}
```

ResBody

O tipo de corpo retornado pela Response é ResBody, que é uma enumeração. Em caso de erro, é definido como ResBody::Error, contendo informações de erro para tratamento diferido. Notavelmente, StatusError não implementa Writer; este design permite que você personalize sua exibição no Catcher.

Visão Geral dos Métodos da Estrutura Response

Categoria	Método	Descrição
Criação	`new()` / `with_cookies()`	Criar uma nova resposta
Código de Status	`status_code()`	Definir o código de status
Cabeçalhos	`headers()/headers_mut()`	Obter cabeçalhos
	`set_headers()/add_header()`	Definir/Adicionar cabeçalhos
	`content_type()`	Obter tipo de conteúdo
Versão HTTP	`version()/version_mut()`	Obter/Modificar versão HTTP
Corpo da Resposta	`body()/body_mut()`	Definir/Obter o corpo da resposta
	`replace_body()/take_body()`	Substituir/Extrair o corpo da resposta
	`write_body()`	Escrever dados no corpo da resposta
	`stream()/channel()`	Resposta em fluxo / Criar um canal de envio
Manipulação de Cookies	`cookies()/cookie()`	Obter cookies / Obter um cookie específico
	`add_cookie()/remove_cookie()`	Adicionar/Remover um cookie
Resposta de Conteúdo	`render()`	Renderizar conteúdo
	`stuff()`	Definir código de status e renderizar conteúdo
	`send_file()`	Enviar um arquivo
Consulta de Status	`is_stamped()`	Verificar se a resposta está pronta para ser escrita de volta

#Resposta

#Escrevendo Conteúdo

#Escrevendo Erros HTTP

#Redirecionando para Outra URL