xwrust::xwmd::xwmq

Struct XwmqRx

source 
pub struct XwmqRx<'a, const N: XwSz, T>
where
    [u8; { _ }]: Sized,
{ /* private fields */ }

Implementations§

source§

impl<'a, const N: XwSz, T> XwmqRx<'a, N, T>
where [u8; { _ }]: Sized,

source

pub fn dq(&self) -> Result<Box<T>, XwmqError>

等待从消息队列 首端 接收一条消息

  • 从消息队列的 首端 取出消息，称为 离队 。
  • 当消息队列中没有消息时，接收线程会阻塞等待。
  • 当消息队列中有可用的消息时，接收线程被唤醒，并取走一个消息，释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
  • 当线程阻塞等待被中断时，通过 Err() 返回 XwmqError::Interrupt 。
§上下文
  • 线程
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.dq();
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn dq_to(&self, to: XwTm) -> Result<Box<T>, XwmqError>

限时等待从消息队列 首端 接收一条消息

  • 从消息队列的 首端 取出消息，称为 离队 。
  • 当消息队列中没有消息时，接收线程会阻塞等待，等待时会指定一个唤醒时间点。
  • 当消息队列中有可用的消息时，接收线程被唤醒，并取走一个消息，释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
  • 当线程阻塞等待被中断时，通过 Err() 返回 XwmqError::Interrupt 。
  • 当到达指定的唤醒时间点，线程被唤醒，并通过 Err() 返回 XwmqError::Timedout 。
§参数说明
  • to: 期望唤醒的时间点
§上下文
  • 线程
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwtm;
use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.dq_to(xwtm::ft(xwtm::s(1)));
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn dq_unintr(&self) -> Result<Box<T>, XwmqError>

等待从消息队列 首端 接收一条消息，且等待不可被中断

  • 从消息队列的 首端 取出消息，称为 离队 。
  • 当消息队列中没有消息时，接收线程会阻塞等待。
  • 接收线程的阻塞等待不可被中断。
  • 当消息队列中有可用的消息时，接收线程被唤醒，并取走一个消息，释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
§上下文
  • 线程
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.dq();
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn trydq(&self) -> Result<Box<T>, XwmqError>

尝试从消息队列 首端 接收一条消息

  • 从消息队列的 首端 取出消息，称为 离队 。
  • 当消息队列中没有消息时，立即通过 Err() 返回 XwmqError::NoMsg 。
  • 当消息队列中有可用的消息时，会取走一个消息，并释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
§上下文
  • 任意
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.trydq();
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn rq(&self) -> Result<Box<T>, XwmqError>

等待从消息队列 尾端 接收一条消息

  • 从消息队列的 尾端 取出消息，称为 反向离队 。
  • 当消息队列中没有消息时，接收线程会阻塞等待。
  • 当消息队列中有可用的消息时，接收线程被唤醒，并取走一个消息，释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
  • 当线程阻塞等待被中断时，通过 Err() 返回 XwmqError::Interrupt 。
§上下文
  • 线程
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.rq();
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn rq_to(&self, to: XwTm) -> Result<Box<T>, XwmqError>

限时等待从消息队列 尾端 接收一条消息

  • 从消息队列的 尾端 取出消息，称为 反向离队 。
  • 当消息队列中没有消息时，接收线程会阻塞等待，等待时会指定一个唤醒时间点。
  • 当消息队列中有可用的消息时，接收线程被唤醒，并取走一个消息，释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
  • 当线程阻塞等待被中断时，通过 Err() 返回 XwmqError::Interrupt 。
  • 当到达指定的唤醒时间点，线程被唤醒，并通过 Err() 返回 XwmqError::Timedout 。
§参数说明
  • to: 期望唤醒的时间点
§上下文
  • 线程
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwtm;
use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.rq_to(xwtm::ft(xwtm::s(1)));
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn rq_unintr(&self) -> Result<Box<T>, XwmqError>

等待从消息队列 尾端 接收一条消息，且等待不可被中断

  • 从消息队列的 尾端 取出消息，称为 反向离队 。
  • 当消息队列中没有消息时，接收线程会阻塞等待。
  • 接收线程的阻塞等待不可被中断。
  • 当消息队列中有可用的消息时，接收线程被唤醒，并取走一个消息，释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
§上下文
  • 线程
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.rq();
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}
source

pub fn tryrq(&self) -> Result<Box<T>, XwmqError>

尝试从消息队列 尾端 接收一条消息

  • 从消息队列的 尾端 取出消息，称为 反向离队 。
  • 当消息队列中没有消息时，立即通过 Err() 返回 XwmqError::NoMsg 。
  • 当消息队列中有可用的消息时，会取走一个消息，并释放消息槽。 若有发送线程正在等待消息槽，将唤醒发送线程。
  • 消息 离队 时，会通过 Box::from_raw() 将数据重新放入 Box 中，然后通过 Ok() 返回。
§上下文
  • 任意
§错误码
§示例
extern crate alloc;
use alloc::string::String;
use alloc::string::ToString;

use xwrust::xwmd::xwmq::*;

static MQ: Xwmq<16, String> = Xwmq::new();

pub fn xwrust_example_xwmq() {
    let (tx, rx) = MQ.init();
    // ...省略...
    let rc = rx.tryrq();
        match rc {
            Ok(d) => { // d是Box<String>
            },
            Err(e) => { // e是错误码
            },
        };
    // ...省略...
}

Trait Implementations§

source§

impl<'a, const N: XwSz, T> Send for XwmqRx<'a, N, T>
where [u8; { _ }]: Sized,

source§

impl<'a, const N: XwSz, T> !Sync for XwmqRx<'a, N, T>
where [u8; { _ }]: Sized,

Auto Trait Implementations§

§

impl<'a, const N: usize, T> Freeze for XwmqRx<'a, N, T>
where [u8; { _ }]: Sized,

§

impl<'a, const N: usize, T> !RefUnwindSafe for XwmqRx<'a, N, T>

§

impl<'a, const N: usize, T> Unpin for XwmqRx<'a, N, T>
where [u8; { _ }]: Sized,

§

impl<'a, const N: usize, T> !UnwindSafe for XwmqRx<'a, N, T>

Blanket Implementations§

§

impl<T> Any for T
where T: 'static + ?Sized,

§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Borrow<T> for T
where T: ?Sized,

§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

impl<T> BorrowMut<T> for T
where T: ?Sized,

§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> From<T> for T

§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T, U> Into<U> for T
where U: From<T>,

§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.