use std::convert::{TryFrom, TryInto};
use std::marker::PhantomData;
use crate::connection::{BufWithFds, DiscardMode, RequestConnection, RequestKind, SequenceNumber};
use crate::errors::{ConnectionError, ParseError, ReplyError};
use crate::protocol::xproto::ListFontsWithInfoReply;
use crate::utils::RawFdContainer;
#[derive(Debug)]
pub struct VoidCookie<'a, C>
where
C: RequestConnection + ?Sized,
{
connection: &'a C,
sequence_number: SequenceNumber,
}
impl<'a, C> VoidCookie<'a, C>
where
C: RequestConnection + ?Sized,
{
pub fn new(connection: &C, sequence_number: SequenceNumber) -> VoidCookie<'_, C> {
VoidCookie {
connection,
sequence_number,
}
}
pub fn sequence_number(&self) -> SequenceNumber {
self.sequence_number
}
fn consume(self) -> (&'a C, SequenceNumber) {
let result = (self.connection, self.sequence_number);
std::mem::forget(self);
result
}
pub fn check(self) -> Result<(), ReplyError> {
let (connection, sequence) = self.consume();
connection.check_for_error(sequence)
}
pub fn ignore_error(self) {
let (connection, sequence) = self.consume();
connection.discard_reply(
sequence,
RequestKind::IsVoid,
DiscardMode::DiscardReplyAndError,
)
}
}
impl<C> Drop for VoidCookie<'_, C>
where
C: RequestConnection + ?Sized,
{
fn drop(&mut self) {
self.connection.discard_reply(
self.sequence_number,
RequestKind::IsVoid,
DiscardMode::DiscardReply,
)
}
}
#[derive(Debug)]
struct RawCookie<'a, C>
where
C: RequestConnection + ?Sized,
{
connection: &'a C,
sequence_number: SequenceNumber,
}
impl<C> RawCookie<'_, C>
where
C: RequestConnection + ?Sized,
{
fn new(connection: &C, sequence_number: SequenceNumber) -> RawCookie<'_, C> {
RawCookie {
connection,
sequence_number,
}
}
fn into_sequence_number(self) -> SequenceNumber {
let number = self.sequence_number;
std::mem::forget(self);
number
}
}
impl<C> Drop for RawCookie<'_, C>
where
C: RequestConnection + ?Sized,
{
fn drop(&mut self) {
self.connection.discard_reply(
self.sequence_number,
RequestKind::HasResponse,
DiscardMode::DiscardReply,
);
}
}
#[derive(Debug)]
pub struct Cookie<'a, C, R>
where
C: RequestConnection + ?Sized,
{
raw_cookie: RawCookie<'a, C>,
phantom: PhantomData<R>,
}
impl<C, R> Cookie<'_, C, R>
where
R: for<'a> TryFrom<&'a [u8], Error = ParseError>,
C: RequestConnection + ?Sized,
{
pub fn new(connection: &C, sequence_number: SequenceNumber) -> Cookie<'_, C, R> {
Cookie {
raw_cookie: RawCookie::new(connection, sequence_number),
phantom: PhantomData,
}
}
pub fn sequence_number(&self) -> SequenceNumber {
self.raw_cookie.sequence_number
}
pub fn raw_reply(self) -> Result<C::Buf, ReplyError> {
let conn = self.raw_cookie.connection;
Ok(conn.wait_for_reply_or_error(self.raw_cookie.into_sequence_number())?)
}
pub fn raw_reply_unchecked(self) -> Result<Option<C::Buf>, ConnectionError> {
let conn = self.raw_cookie.connection;
Ok(conn.wait_for_reply(self.raw_cookie.into_sequence_number())?)
}
pub fn reply(self) -> Result<R, ReplyError> {
Ok(self.raw_reply()?.as_ref().try_into()?)
}
pub fn reply_unchecked(self) -> Result<Option<R>, ConnectionError> {
self.raw_reply_unchecked()?
.map(|buf| buf.as_ref().try_into())
.transpose()
.map_err(Into::into)
}
pub fn discard_reply_and_errors(self) {
let conn = self.raw_cookie.connection;
conn.discard_reply(
self.raw_cookie.into_sequence_number(),
RequestKind::HasResponse,
DiscardMode::DiscardReplyAndError,
)
}
pub(crate) fn into_sequence_number(self) -> SequenceNumber {
self.raw_cookie.into_sequence_number()
}
}
#[derive(Debug)]
pub struct CookieWithFds<'a, C, R>
where
C: RequestConnection + ?Sized,
{
raw_cookie: RawCookie<'a, C>,
phantom: PhantomData<R>,
}
impl<C, R> CookieWithFds<'_, C, R>
where
R: for<'a> TryFrom<(&'a [u8], Vec<RawFdContainer>), Error = ParseError>,
C: RequestConnection + ?Sized,
{
pub fn new(connection: &C, sequence_number: SequenceNumber) -> CookieWithFds<'_, C, R> {
CookieWithFds {
raw_cookie: RawCookie::new(connection, sequence_number),
phantom: PhantomData,
}
}
pub fn sequence_number(&self) -> SequenceNumber {
self.raw_cookie.sequence_number
}
pub fn raw_reply(self) -> Result<BufWithFds<C::Buf>, ReplyError> {
let conn = self.raw_cookie.connection;
Ok(conn.wait_for_reply_with_fds(self.raw_cookie.into_sequence_number())?)
}
pub fn reply(self) -> Result<R, ReplyError> {
let (buffer, fds) = self.raw_reply()?;
Ok(R::try_from((buffer.as_ref(), fds))?)
}
}
#[derive(Debug)]
pub struct ListFontsWithInfoCookie<'a, C: RequestConnection + ?Sized>(Option<RawCookie<'a, C>>);
impl<C> ListFontsWithInfoCookie<'_, C>
where
C: RequestConnection + ?Sized,
{
pub(crate) fn new(
cookie: Cookie<'_, C, ListFontsWithInfoReply>,
) -> ListFontsWithInfoCookie<'_, C> {
ListFontsWithInfoCookie(Some(cookie.raw_cookie))
}
pub fn sequence_number(&self) -> Option<SequenceNumber> {
self.0.as_ref().map(|x| x.sequence_number)
}
}
impl<C> Iterator for ListFontsWithInfoCookie<'_, C>
where
C: RequestConnection + ?Sized,
{
type Item = Result<ListFontsWithInfoReply, ReplyError>;
fn next(&mut self) -> Option<Self::Item> {
let cookie = match self.0.take() {
None => return None,
Some(cookie) => cookie,
};
let reply = cookie
.connection
.wait_for_reply_or_error(cookie.sequence_number);
let reply = match reply {
Err(e) => return Some(Err(e)),
Ok(v) => v,
};
let reply = ListFontsWithInfoReply::try_from(reply.as_ref()).map_err(ReplyError::from);
match reply {
Ok(ref reply) if reply.name.is_empty() => None,
Ok(reply) => {
self.0 = Some(cookie);
Some(Ok(reply))
}
Err(e) => Some(Err(e)),
}
}
}