Struct ResponseWriter 

pub struct ResponseWriter { /* private fields */ }

ResponseWriter is the handle through which a Handler writes its response.

Two response modes are supported:

• Buffered: call set_status / set_header then write (or the shorthand respond). This sends headers + body atomically and closes the stream.
• Streaming: call stream_write one or more times, then stream_end (or stream_close on error). Response headers must have been sent by a prior buffered call in this case, or the stream is left headerless.

Implementations

impl ResponseWriter

pub fn set_status(&mut self, status: &str)

set_status sets the NWEP status string for the pending buffered response.

The default status is "ok". Must be called before write.

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

set_header appends a response header to the pending buffered response.

pub fn write(&mut self, body: &[u8]) -> Result<(), Error>

write sends the buffered response headers and body, then closes the stream.

If called more than once the subsequent calls are no-ops; only the first call transmits data. Use stream_write / stream_end for incremental streaming.

Errors

Returns an Error if the underlying nwep_stream_respond or nwep_stream_end C call fails.

pub fn respond(&mut self, status: &str, body: &[u8]) -> Result<(), Error>

respond sets status and writes body in a single call.

Equivalent to calling set_status followed by write.

Errors

Returns an Error if the underlying send fails.

Examples found in repository

examples/server.rs (line 55)

fn main() {
    nwep::init().unwrap_or_else(|e| {
        eprintln!("init: {e}");
        process::exit(1);
    });

    let key_file = std::env::var("NWEP_KEY_FILE").unwrap_or_else(|_| DEFAULT_KEY_FILE.into());
    let keypair = load_or_generate_keypair(&key_file).unwrap_or_else(|e| {
        eprintln!("keypair: {e}");
        process::exit(1);
    });

    let node_id = keypair.node_id().unwrap_or_else(|e| {
        eprintln!("node_id: {e}");
        process::exit(1);
    });
    eprintln!("node id: {node_id}");

    let mut router = Router::new();
    router.handle_func("/hello", |w: &mut ResponseWriter, _r: &Request| {
        let _ = w.respond("ok", b"hello from nwep-rust");
    });

    let addr = std::env::args().nth(1).unwrap_or_else(|| DEFAULT_ADDR.into());

    let (server, event_loop) = ServerBuilder::new(&addr, keypair)
        .on_connect(|info| eprintln!("connected: {}", info.node_id))
        .on_disconnect(|info, code| eprintln!("disconnected: {} (code {code})", info.node_id))
        .build(router)
        .unwrap_or_else(|e| {
            eprintln!("server: {e}");
            process::exit(1);
        });

    let url = server.url("/hello");
    eprintln!("listening on {}", server.addr());
    println!("{url}"); // URL printed to stdout for the client to read

    if let Err(e) = event_loop.run() {
        eprintln!("server run: {e}");
        process::exit(1);
    }
}

pub fn stream_write(&mut self, data: &[u8]) -> Result<isize, Error>

stream_write writes a chunk of body data directly to the open QUIC stream.

This is the low-level building block for streaming responses. Call stream_end when all chunks have been written. Returns the number of bytes written.

Errors

Returns an Error if nwep_stream_write returns a negative result code.

pub fn stream_end(&mut self) -> Result<(), Error>

stream_end signals the end of the response body and closes the QUIC stream cleanly.

Errors

Returns an Error if nwep_stream_end fails.

pub fn stream_close(&mut self, err: i32)

stream_close aborts the stream with an application error code.

Use this to signal an error mid-stream without sending a complete response. Unlike stream_end, this does not return a result because the close is best-effort.

pub fn stream_id(&self) -> i64

stream_id returns the QUIC stream identifier for this response stream.

Useful for correlating log output or for advanced stream management.

pub fn is_server_initiated(&self) -> bool

is_server_initiated returns true if this stream was opened by the server.

Server-initiated streams correspond to notify messages; client-initiated streams correspond to ordinary requests.