Struct RequestQueue 

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

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)

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> = 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

Tracker for requests sent to clients.

Implementations

impl<I> RequestQueue<I>

pub fn new() -> Self

Creates a new empty request queue.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<I> Default for RequestQueue<I>

fn default() -> Self

Returns the “default value” for a type.