Struct Router

pub struct Router<St, Error = ResponseError> { /* private fields */ }

A router dispatching requests and notifications to individual handlers.

Implementations

impl<St, Error> Router<St, Error>

where Error: From<ResponseError> + Send + 'static,

pub fn new(state: St) -> Self

Create a empty Router.

pub fn request<R: Request, Fut>( &mut self, handler: impl Fn(&mut St, R::Params) -> Fut + Send + 'static, ) -> &mut Self

where Fut: Future<Output = Result<R::Result, Error>> + Send + 'static,

Add an asynchronous request handler for a specific LSP request R.

If handler for the method already exists, it replaces the old one.

pub fn notification<N: Notification>( &mut self, handler: impl Fn(&mut St, N::Params) -> ControlFlow<Result<()>> + Send + 'static, ) -> &mut Self

Add a synchronous request handler for a specific LSP notification N.

If handler for the method already exists, it replaces the old one.

pub fn event<E: Send + 'static>( &mut self, handler: impl Fn(&mut St, E) -> ControlFlow<Result<()>> + Send + 'static, ) -> &mut Self

Add a synchronous event handler for event type E.

If handler for the method already exists, it replaces the old one.

pub fn unhandled_request<Fut>( &mut self, handler: impl Fn(&mut St, AnyRequest) -> Fut + Send + 'static, ) -> &mut Self

where Fut: Future<Output = Result<JsonValue, Error>> + Send + 'static,

Set an asynchronous catch-all request handler for any requests with no corresponding handler for its method.

There can only be a single catch-all request handler. New ones replace old ones.

The default handler is to respond a error response with code ErrorCode::METHOD_NOT_FOUND.

pub fn unhandled_notification( &mut self, handler: impl Fn(&mut St, AnyNotification) -> ControlFlow<Result<()>> + Send + 'static, ) -> &mut Self

Set a synchronous catch-all notification handler for any notifications with no corresponding handler for its method.

There can only be a single catch-all notification handler. New ones replace old ones.

The default handler is to do nothing for methods starting with $/, and break the main loop with Error::Routing for other methods. Typically notifications are critical and losing them can break state synchronization, easily leading to catastrophic failures after incorrect incremental changes.

pub fn unhandled_event( &mut self, handler: impl Fn(&mut St, AnyEvent) -> ControlFlow<Result<()>> + Send + 'static, ) -> &mut Self

Set a synchronous catch-all event handler for any notifications with no corresponding handler for its type.

There can only be a single catch-all event handler. New ones replace old ones.

The default handler is to break the main loop with Error::Routing. Since events are emitted internally, mishandling are typically logic errors.

impl<S> Router<S>

where S: LanguageServer<NotifyResult = ControlFlow<Result<()>>>, ResponseError: From<S::Error>,

pub fn from_language_server(state: S) -> Self

Create a Router using its implementation of LanguageServer as handlers.

impl<S> Router<S>

where S: LanguageClient<NotifyResult = ControlFlow<Result<()>>>, ResponseError: From<S::Error>,

pub fn from_language_client(state: S) -> Self

Create a Router using its implementation of LanguageClient as handlers.

Trait Implementations

impl<St, Error> Default for Router<St, Error>

where St: Default, Error: From<ResponseError> + Send + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<St> LspService for Router<St>

fn notify(&mut self, notif: AnyNotification) -> ControlFlow<Result<()>>

The handler of LSP notifications.

fn emit(&mut self, event: AnyEvent) -> ControlFlow<Result<()>>

The handler of an arbitrary AnyEvent.

impl<St, Error> Service<AnyRequest> for Router<St, Error>

type Response = Value

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Value, Error>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: AnyRequest) -> Self::Future

Process the request and return the response asynchronously.