Struct bsp_server::Connection

pub struct Connection {
    pub sender: Sender<Message>,
    pub receiver: Receiver<Message>,
}

Connection is just a pair of channels of LSP messages.

Fields

sender: Sender<Message>

receiver: Receiver<Message>

Implementations

impl Connection

pub fn stdio() -> (Connection, IoThreads)

Create connection over standard in/standard out.

Use this to create a real language server.

pub fn connect<A: ToSocketAddrs>(addr: A) -> Result<(Connection, IoThreads)>

Open a connection over tcp. This call blocks until a connection is established.

pub fn listen<A: ToSocketAddrs>(addr: A) -> Result<(Connection, IoThreads)>

Listen for a connection over tcp. This call blocks until a connection is established.

pub fn memory() -> (Connection, Connection)

Creates a pair of connected connections in memory for testing.

pub fn initialize<V: Serialize>(
    &self,
    process: impl FnOnce(&InitializeBuild) -> V
) -> Result<InitializeBuild, ProtocolError>

Initialize the connection. Sends the server initialize response to the client and returns the serialized client capabilities on success. If more fine-grained initialization is required use initialize_start/initialize_finish.

Example

use std::error::Error;
use build_server_protocol::types::InitializeBuildResult;
use build_server_protocol::server::{Connection, Message, Request, RequestId, Response};

fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
   // Create the transport
   let (conn, io_threads) = Connection::stdio();

   // Run the server
   conn.initialize(|_params| {
       Ok(InitializeBuildResult::new_simple(
        "MyBuildServer",
        "0.1",
        "2.0",
        ServerCapabilities::default()))
   })?;

   // ... Run main loop ...

   Ok(())
}

pub fn handle_shutdown(&self, req: &Request) -> Result<bool, ProtocolError>

If req is Shutdown, respond to it and return true, otherwise return false

pub fn send<T: Into<Message>>(&self, msg: T) -> Result<(), SendError<Message>>

delegates to self.sender

pub fn try_send<T: Into<Message>>(
    &self,
    msg: T
) -> Result<(), TrySendError<Message>>

delegates to self.sender

pub fn send_timeout<T: Into<Message>>(
    &self,
    msg: T,
    timeout: Duration
) -> Result<(), SendTimeoutError<Message>>

delegates to self.sender

pub fn send_deadline<T: Into<Message>>(
    &self,
    msg: T,
    deadline: Instant
) -> Result<(), SendTimeoutError<Message>>

delegates to self.sender