Struct x11rb::rust_connection::RustConnection

pub struct RustConnection<S: Stream = DefaultStream> {
    inner: Mutex<ConnectionInner>,
    stream: S,
    packet_reader: Mutex<PacketReader>,
    reader_condition: Condvar,
    setup: Setup,
    extension_manager: Mutex<ExtensionManager>,
    maximum_request_bytes: Mutex<MaxRequestBytes>,
    id_allocator: Mutex<IdAllocator>,
}

A connection to an X11 server implemented in pure rust

This type is generic over S, which allows to use a generic stream to communicate with the server. This stream can written to and read from, but it can also be polled, meaning that one checks if new data can be read or written.

RustConnection always used an internal buffer for reading, so R does not need to be buffered.

Fields

inner: Mutex<ConnectionInner>

stream: S

packet_reader: Mutex<PacketReader>

reader_condition: Condvar

setup: Setup

extension_manager: Mutex<ExtensionManager>

maximum_request_bytes: Mutex<MaxRequestBytes>

id_allocator: Mutex<IdAllocator>

Implementations

impl RustConnection<DefaultStream>

pub fn connect(dpy_name: Option<&str>) -> Result<(Self, usize), ConnectError>

Establish a new connection.

If no dpy_name is provided, the value from $DISPLAY is used.

impl<S: Stream> RustConnection<S>

pub fn connect_to_stream(stream: S, screen: usize) -> Result<Self, ConnectError>

Establish a new connection to the given streams.

read is used for reading data from the X11 server and write is used for writing. screen is the number of the screen that should be used. This function checks that a screen with that number exists.

pub fn connect_to_stream_with_auth_info( stream: S, screen: usize, auth_name: Vec<u8>, auth_data: Vec<u8>, ) -> Result<Self, ConnectError>

Establish a new connection to the given streams.

read is used for reading data from the X11 server and write is used for writing. screen is the number of the screen that should be used. This function checks that a screen with that number exists.

The parameters auth_name and auth_data are used for the members authorization_protocol_name and authorization_protocol_data of the SetupRequest that is sent to the X11 server.

pub fn for_connected_stream( stream: S, setup: Setup, ) -> Result<Self, ConnectError>

Establish a new connection for an already connected stream.

The given stream is used for communicating with the X11 server. It is assumed that setup was just received from the server. Thus, the first reply to a request that is sent will have sequence number one.

fn send_request( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, kind: ReplyFdKind, ) -> Result<SequenceNumber, ConnectionError>

Internal function for actually sending a request.

This function “does the actual work” for send_request_with_reply() and send_request_without_reply().

fn send_sync<'a>( &'a self, inner: MutexGuard<'a, ConnectionInner>, ) -> Result<MutexGuard<'a, ConnectionInner>, Error>

Send a synchronisation packet to the X11 server.

This function sends a GetInputFocus request to the X11 server and arranges for its reply to be ignored. This ensures that a reply is expected (ConnectionInner.next_reply_expected increases).

fn write_all_vectored<'a>( &'a self, inner: MutexGuard<'a, ConnectionInner>, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<MutexGuard<'a, ConnectionInner>>

Write a set of buffers on a writer. May also read packets from the server.

fn flush_impl<'a>( &'a self, inner: MutexGuard<'a, ConnectionInner>, ) -> Result<MutexGuard<'a, ConnectionInner>>

fn read_packet_and_enqueue<'a>( &'a self, inner: MutexGuard<'a, ConnectionInner>, mode: BlockingMode, ) -> Result<MutexGuard<'a, ConnectionInner>, Error>

Read a packet from the connection.

This function waits for an X11 packet to be received. It drops the mutex protecting the inner data while waiting for a packet so that other threads can make progress. For this reason, you need to pass in a MutexGuard to be dropped. This function locks the mutex again and returns a new MutexGuard.

Note: If mode is BlockingMode::Blocking, the lock on inner will be temporarily released. While sending a request, inner must be kept locked to avoid sending the data of different requests interleaved. So, when read_packet_and_enqueue is called as part of a write, it must always be done with mode set to BlockingMode::NonBlocking.

fn prefetch_maximum_request_bytes_impl( &self, max_bytes: &mut MutexGuard<'_, MaxRequestBytes>, )

pub fn stream(&self) -> &S

Returns a reference to the contained stream.

Trait Implementations

impl<S: Stream> Connection for RustConnection<S>

fn wait_for_raw_event_with_sequence( &self, ) -> Result<RawEventAndSeqNumber<Vec<u8>>, ConnectionError>

Wait for a new raw/unparsed event from the X11 server.

fn poll_for_raw_event_with_sequence( &self, ) -> Result<Option<RawEventAndSeqNumber<Vec<u8>>>, ConnectionError>

Poll for a new unparsed/raw event from the X11 server.

fn flush(&self) -> Result<(), ConnectionError>

Send all pending requests to the server.

fn setup(&self) -> &Setup

Get the setup information sent by the X11 server.

fn generate_id(&self) -> Result<u32, ReplyOrIdError>

Generate a new X11 identifier.

fn wait_for_event(&self) -> Result<Event, ConnectionError>

Wait for a new event from the X11 server.

fn wait_for_raw_event(&self) -> Result<Self::Buf, ConnectionError>

Wait for a new raw/unparsed event from the X11 server.

fn wait_for_event_with_sequence( &self, ) -> Result<EventAndSeqNumber, ConnectionError>

Wait for a new event from the X11 server.

fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>

Poll for a new event from the X11 server.

fn poll_for_raw_event(&self) -> Result<Option<Self::Buf>, ConnectionError>

Poll for a new raw/unparsed event from the X11 server.

fn poll_for_event_with_sequence( &self, ) -> Result<Option<EventAndSeqNumber>, ConnectionError>

Poll for a new event from the X11 server.

impl<S: Debug + Stream> Debug for RustConnection<S>

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

Formats the value using the given formatter.

impl<S: Stream> RequestConnection for RustConnection<S>

type Buf = Vec<u8>

Type used as buffer to store raw replies or events before they are parsed.

fn send_request_with_reply<Reply>( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<Cookie<'_, Self, Reply>, ConnectionError>

where Reply: TryParse,

Send a request with a reply to the server.

fn send_request_with_reply_with_fds<Reply>( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<CookieWithFds<'_, Self, Reply>, ConnectionError>

where Reply: TryParseFd,

Send a request with a reply containing file descriptors to the server.

fn send_request_without_reply( &self, bufs: &[IoSlice<'_>], fds: Vec<RawFdContainer>, ) -> Result<VoidCookie<'_, Self>, ConnectionError>

Send a request without a reply to the server.

fn discard_reply( &self, sequence: SequenceNumber, _kind: RequestKind, mode: DiscardMode, )

A reply to an error should be discarded.

fn prefetch_extension_information( &self, extension_name: &'static str, ) -> Result<(), ConnectionError>

Prefetches information about an extension.

fn extension_information( &self, extension_name: &'static str, ) -> Result<Option<ExtensionInformation>, ConnectionError>

Get information about an extension.

fn wait_for_reply_or_raw_error( &self, sequence: SequenceNumber, ) -> Result<ReplyOrError<Vec<u8>>, ConnectionError>

Wait for the reply to a request.

fn wait_for_reply( &self, sequence: SequenceNumber, ) -> Result<Option<Vec<u8>>, ConnectionError>

Wait for the reply to a request.

fn check_for_raw_error( &self, sequence: SequenceNumber, ) -> Result<Option<<RustConnection as RequestConnection>::Buf>, ConnectionError>

Check whether a request that does not have a reply caused an X11 error.

fn wait_for_reply_with_fds_raw( &self, sequence: SequenceNumber, ) -> Result<ReplyOrError<BufWithFds, <RustConnection as RequestConnection>::Buf>, ConnectionError>

Wait for the reply to a request that has FDs.

fn maximum_request_bytes(&self) -> usize

The maximum number of bytes that the X11 server accepts in a request.

fn prefetch_maximum_request_bytes(&self)

Prefetches the maximum request length.

fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>

Parse a generic error.

fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>

Parse a generic event.

fn send_trait_request_with_reply<R>( &self, request: R, ) -> Result<Cookie<'_, Self, <R as ReplyRequest>::Reply>, ConnectionError>

where R: ReplyRequest,

Send a request with a reply to the server.

fn send_trait_request_with_reply_with_fds<R>( &self, request: R, ) -> Result<CookieWithFds<'_, Self, R::Reply>, ConnectionError>

where R: ReplyFDsRequest,

Send a request with a reply containing file descriptors to the server.

fn send_trait_request_without_reply<R>( &self, request: R, ) -> Result<VoidCookie<'_, Self>, ConnectionError>

where R: VoidRequest,

Send a request without a reply to the server.

fn wait_for_reply_or_error( &self, sequence: SequenceNumber, ) -> Result<Self::Buf, ReplyError>

Wait for the reply to a request.

fn wait_for_reply_with_fds( &self, sequence: SequenceNumber, ) -> Result<BufWithFds<Self::Buf>, ReplyError>

Wait for the reply to a request that has FDs.

fn check_for_error(&self, sequence: SequenceNumber) -> Result<(), ReplyError>

Check whether a request that does not have a reply caused an X11 error.