Struct interchange::Channel

pub struct Channel<Rq, Rp> { /* private fields */ }

Channel used for Request/Response mechanism.

#[derive(Clone, Debug, PartialEq)]
pub enum Request {
    This(u8, u32),
    That(i64),
}

#[derive(Clone, Debug, PartialEq)]
pub enum Response {
    Here(u8, u8, u8),
    There(i16),
}

static CHANNEL: Channel<Request,Response> = Channel::new();

let (mut rq, mut rp) = CHANNEL.split().unwrap();

assert!(rq.state() == State::Idle);

// happy path: no cancelation
let request = Request::This(1, 2);
assert!(rq.request(request).is_ok());

let request = rp.take_request().unwrap();
println!("rp got request: {:?}", request);

let response = Response::There(-1);
assert!(!rp.is_canceled());
assert!(rp.respond(response).is_ok());

let response = rq.take_response().unwrap();
println!("rq got response: {:?}", response);

// early cancelation path
assert!(rq.request(request).is_ok());

let request =  rq.cancel().unwrap().unwrap();
println!("responder could cancel: {:?}", request);

assert!(rp.take_request().is_none());
assert!(State::Idle == rq.state());

// late cancelation
assert!(rq.request(request).is_ok());
let request = rp.take_request().unwrap();

println!("responder could cancel: {:?}", &rq.cancel().unwrap().is_none());
assert!(rp.is_canceled());
assert!(rp.respond(response).is_err());
assert!(rp.acknowledge_cancel().is_ok());
assert!(State::Idle == rq.state());

// building into request buffer
impl Default for Request {
  fn default() -> Self {
    Request::That(0)
  }
}

rq.with_request_mut(|r| *r = Request::This(1,2)).unwrap() ;
assert!(rq.send_request().is_ok());
let request = rp.take_request().unwrap();
assert_eq!(request, Request::This(1, 2));
println!("rp got request: {:?}", request);

// building into response buffer
impl Default for Response {
  fn default() -> Self {
    Response::There(1)
  }
}

rp.with_response_mut(|r| *r = Response::Here(3,2,1)).unwrap();
assert!(rp.send_response().is_ok());
let response = rq.take_response().unwrap();
assert_eq!(response, Response::Here(3,2,1));

Implementations

impl<Rq, Rp> Channel<Rq, Rp>

pub const fn new() -> Self

pub fn requester(&self) -> Option<Requester<'_, Rq, Rp>>

Obtain the requester end of the channel if it hasn’t been taken yet.

Can be called again if the previously obtained Requester has been dropped

pub fn responder(&self) -> Option<Responder<'_, Rq, Rp>>

Obtain the responder end of the channel if it hasn’t been taken yet.

Can be called again if the previously obtained Responder has been dropped

pub fn split(&self) -> Option<(Requester<'_, Rq, Rp>, Responder<'_, Rq, Rp>)>

Obtain both the requester and responder ends of the channel.

Can be called again if the previously obtained Responder and Requester have been dropped

Trait Implementations

impl<Rq, Rp> Default for Channel<Rq, Rp>

fn default() -> Self

Returns the “default value” for a type.

impl<Rq, Rp> Sync for Channel<Rq, Rp>where Rq: Send + Sync, Rp: Send + Sync,