Struct RequestQueue 

pub struct RequestQueue<I, O> {
    pub incoming: IncomingRequests<I>,
    pub outgoing: OutgoingRequests<O>,
}

Combined request queue tracking both incoming and outgoing requests.

This is the primary type for managing LSP request-response correlation. It provides separate tracking for:

• incoming: Requests received from clients that need responses
• outgoing: Requests sent to clients that are awaiting responses

Type Parameters

• I: Metadata type for incoming requests (e.g., handler context)
• O: Response type for outgoing requests

Example

use lsp_server_tokio::{RequestQueue, RequestId};
use tokio_util::sync::CancellationToken;

// Create a queue for a server that tracks method names for incoming
// requests and expects JSON responses for outgoing requests
let mut queue: RequestQueue<String, serde_json::Value> = RequestQueue::new();

// Track incoming request with cancellation token
let token = CancellationToken::new();
queue.incoming.register(1.into(), "textDocument/hover".to_string(), token);

// Operations on incoming don't affect outgoing
assert_eq!(queue.incoming.pending_count(), 1);
assert_eq!(queue.outgoing.pending_count(), 0);

Fields

incoming: IncomingRequests<I>

Tracker for requests received from clients.

outgoing: OutgoingRequests<O>

Tracker for requests sent to clients.

Implementations

impl<I, O> RequestQueue<I, O>

pub fn new() -> Self

Creates a new empty request queue.

Trait Implementations

impl<I: Debug, O: Debug> Debug for RequestQueue<I, O>

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

Formats the value using the given formatter.

impl<I, O> Default for RequestQueue<I, O>

fn default() -> Self

Returns the “default value” for a type.