Struct Response 

pub struct Response {
    pub status_code: u16,
    pub status_text: String,
    pub headers: Vec<(String, String)>,
    pub body: Vec<u8>,
}

Represents an HTTP response payload and metadata.

You create this type on the response path, add headers, and serialize it to any Write sink (for example TcpStream or an in-memory buffer in tests).

Examples

use http_handle::response::Response;

let response = Response::new(200, "OK", b"hello".to_vec());
assert_eq!(response.status_code, 200);

Panics

This type does not panic on construction.

Fields

status_code: u16

The HTTP status code (e.g., 200 for OK, 404 for Not Found).

status_text: String

The HTTP status text associated with the status code (e.g., “OK”, “Not Found”).

headers: Vec<(String, String)>

A list of headers in the response, each represented as a tuple containing the header name and its corresponding value.

body: Vec<u8>

The body of the response, represented as a vector of bytes.

Implementations

impl Response

pub fn new(status_code: u16, status_text: &str, body: Vec<u8>) -> Self

Creates a response with status, reason, and body bytes.

The headers are initialized as an empty list and can be added later using the add_header method.

Arguments

• status_code - The HTTP status code for the response.
• status_text - The status text corresponding to the status code.
• body - The body of the response, represented as a vector of bytes.

Examples

use http_handle::response::Response;

let response = Response::new(204, "NO CONTENT", Vec::new());
assert_eq!(response.status_code, 204);

Panics

This function does not panic.

pub fn add_header(&mut self, name: &str, value: &str)

Adds a header to the response.

This method allows you to add custom headers to the response, which will be included in the HTTP response when it is sent to the client.

Examples

use http_handle::response::Response;

let mut response = Response::new(200, "OK", Vec::new());
response.add_header("Content-Type", "text/plain");
assert_eq!(response.headers.len(), 1);

Panics

This function does not panic.

pub fn send<W: Write>(&self, stream: &mut W) -> Result<(), ServerError>

Sends the response over the provided Write stream.

This method writes the HTTP status line, headers, and body to the stream, ensuring the client receives the complete response.

Arguments

• stream - A mutable reference to any stream that implements Write.

Examples

use http_handle::response::Response;
use std::io::Cursor;

let mut response = Response::new(200, "OK", b"hello".to_vec());
response.add_header("Content-Type", "text/plain");

let mut out = Cursor::new(Vec::<u8>::new());
response.send(&mut out).expect("response write should succeed");
assert!(!out.get_ref().is_empty());

Errors

Returns Err when writing headers or body to the output stream fails.

Panics

This function does not intentionally panic.

Trait Implementations

impl Clone for Response

fn clone(&self) -> Response

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Response

fn default() -> Response

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Response

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Response

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Response

fn eq(&self, other: &Response) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Response

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Response

impl StructuralPartialEq for Response