xwrust::xwmd::xwcq

Struct Xwcq

source 
pub struct Xwcq<const S: XwSz, const N: XwSz>
where
    [u8; { _ }]: Sized,
{ /* private fields */ }
Expand description

循环队列对象结构体

Implementations§

source§

impl<const S: XwSz, const N: XwSz> Xwcq<S, N>
where [u8; { _ }]: Sized,

source

pub const fn new() -> Self

新建循环队列对象

新建时需要指定类型常量参数。

  • S 是数据槽的大小，不能为0，若 S 不满足内存对齐的要求，会自动向上调整。
  • N 是数据槽的数量，不能为0。

此方法是编译期方法。循环队列只可被定义为具有 'static 约束的全局变量全局变量：

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 8> = Xwcq::new(); // 64字节 * 8个槽
source

pub fn init(&'static self) -> XwcqError

初始化循环队列对象

循环队列对象必须调用此方法一次，方可正常使用。

如果在创建循环队列时，指定的 S * N == 0 ，初始化时将返回错误 XwcqError::PoolSize 。

§错误码
§上下文
  • 任意
§示例
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 8> = Xwcq::new(); // 64字节 * 8个槽

pub fn xwrust_example_xwcq() {
    let rc = CQ.init();
}
source

pub fn eq<T>(&self, data: T) -> Result<XwSz, XwcqError>
where T: Sized + Send,

将数据发送到循环队列的 尾端 （入队，EnQueue）

  • 如果循环队列数据已被填满，循环队列会循环回队列 首端 的位置，覆盖掉原数据。
  • 发送时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地被拷贝到循环队列的数据槽内的。
  • 当发送的数据类型大小大于循环队列的数据槽大小 S ，发送会失败，并返回错误码 XwcqError::DataSize 。
§参数说明
  • data: 类型为 T 的数据
§错误码
§上下文
  • 任意
§示例
use xwrust::xwos::thd::SThd;
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();
static CHILD: SThd<1024, &str> = SThd::new("CHILD0", true);

pub fn xwrust_example_xwcq() {
    CQ.init();
    CHILD.run(|_| { // 子线程0
            // 将utf-8字符串放入 `[u8; 64]` 数组中后发送
            let mut buffer: [u8; 64] = [0; 64];
            let msg = "子线程数据".as_bytes();
            let msgsize = msg.len();
            buffer[..msgsize].copy_from_slice(msg);
            let rc = CQ.eq(buffer);
            match rc {
                Ok(sz) => { // 发送数据成功
                },
                Err(e) => { // 发送数据失败
                },
            };
            "OK"
        });
}
source

pub fn jq<T>(&self, data: T) -> Result<XwSz, XwcqError>
where T: Sized + Send,

将数据发送循环队列的 首端 （插队，Jump the Queue）

  • 如果循环队列数据已被填满，循环队列会循环回队列 尾端 的位置，覆盖掉原数据。
  • 发送时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地被拷贝到循环队列的数据槽内的。
  • 当发送的数据类型大小大于循环队列的数据槽大小 S ，发送会失败，并返回错误码 XwcqError::DataSize 。
§参数说明
  • data: 类型为 T 的数据
§错误码
§上下文
  • 任意
§示例
use xwrust::xwos::thd::SThd;
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();
static CHILD: SThd<1024, &str> = SThd::new("CHILD0", true);

pub fn xwrust_example_xwcq() {
    CQ.init();
    CHILD.run(|_| { // 子线程0
            // 将utf-8字符串放入 `[u8; 64]` 数组中后发送
            let mut buffer: [u8; 64] = [0; 64];
            let msg = "子线程数据".as_bytes();
            let msgsize = msg.len();
            buffer[..msgsize].copy_from_slice(msg);
            let rc = CQ.jq(buffer);
            match rc {
                Ok(sz) => { // 发送数据成功
                },
                Err(e) => { // 发送数据失败
                },
            };
            "OK"
        });
}
source

pub fn dq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列的 首端 接收数据（离队，DeQueue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，线程会阻塞等待。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.dq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn dq_to<T>(&self, to: XwTm) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列的 首端 接收数据（离队，DeQueue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，线程会阻塞等待，等待时会指定一个唤醒时间点。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
  • 当到达指定的唤醒时间点，线程被唤醒，返回错误码 XwcqError::Timedout 。
§参数说明
  • to: 期望唤醒的时间点
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwtm;
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.dq_to::<[u8; 64]>(xwtm::ft(xwtm::s(1)));
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn dq_unintr<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列的 首端 接收数据（离队，DeQueue），并且等待不可被中断

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，线程会阻塞等待，且不可被中断。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.dq_unintr::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn trydq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

尝试从循环队列的 首端 接收数据（离队，DeQueue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，立即返回 XwcqError::DataSize ，此方法不会阻塞等待。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 任意
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.trydq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
        },
    };
}
source

pub fn rq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列的 尾端 接收数据（反向离队，Reversely deQueue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，线程会阻塞等待。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.rq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn rq_to<T>(&self, to: XwTm) -> Result<T, XwcqError>
where T: Sized + Send,

限时等待从循环队列的 尾端 接收数据（反向离队，Reversely deQueue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，线程会阻塞等待，等待时会指定一个唤醒时间点。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
  • 当到达指定的唤醒时间点，线程被唤醒，返回错误码 XwcqError::Timedout 。
§参数说明
  • to: 期望唤醒的时间点
§上下文
  • 线程
§错误码
§上下文
  • 线程
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwtm;
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.rq_to::<[u8; 64]>(xwtm::ft(xwtm::s(1)));
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn rq_unintr<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列的 尾端 接收数据（反向离队，Reversely deQueue），并且等待不可被中断

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，线程会阻塞等待，且不可被中断。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.rq_unintr::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn tryrq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

尝试从循环队列的 尾端 接收数据（反向离队，Reversely deQueue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 若循环队列为空，立即返回 XwcqError::DataSize ，此方法不会阻塞。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 任意
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.tryrq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
        },
    };
}
source

pub fn pfq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列 头端 拷贝数据（Peek at the Front of Queue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，线程会阻塞等待。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.pfq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn pfq_to<T>(&self, to: XwTm) -> Result<T, XwcqError>
where T: Sized + Send,

限时等待从循环队列 头端 拷贝数据（Peek at the Front of Queue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，线程会阻塞等待，等待时会指定一个唤醒时间点。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
  • 当到达指定的唤醒时间点，线程被唤醒，返回错误码 XwcqError::Timedout 。
§参数说明
  • to: 期望唤醒的时间点
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwtm;
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.pfq_to::<[u8; 64]>(xwtm::ft(xwtm::s(1)));
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn pfq_unintr<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列 头端 拷贝数据（Peek at the Front of Queue），并且等待不可被中断

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，线程会阻塞等待，且不可被中断。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.pfq_unintr::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn trypfq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

尝试从循环队列 头端 拷贝数据（Peek at the Front of Queue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，立即返回 XwcqError::DataSize ，此方法不会阻塞。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 任意
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.trypfq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
        },
    };
}
source

pub fn prq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列 尾端 拷贝数据（Peek at the Rear of Queue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，线程会阻塞等待。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.prq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn prq_to<T>(&self, to: XwTm) -> Result<T, XwcqError>
where T: Sized + Send,

限时等待从循环队列 尾端 拷贝数据（Peek at the Rear of Queue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，线程会阻塞等待，等待时会指定一个唤醒时间点。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
  • 当线程阻塞等待被中断时，返回错误码 XwcqError::Interrupt 。
  • 当到达指定的唤醒时间点，线程被唤醒，返回错误码 XwcqError::Timedout 。
§参数说明
  • to: 期望唤醒的时间点
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwtm;
use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.prq_to::<[u8; 64]>(xwtm::ft(xwtm::s(1)));
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn prq_unintr<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

等待从循环队列 尾端 拷贝数据（Peek at the Rear of Queue），并且等待不可被中断

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，线程会阻塞等待，且不可被中断。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 线程
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.prq_unintr::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
            break;
        },
    };
}
source

pub fn tryprq<T>(&self) -> Result<T, XwcqError>
where T: Sized + Send,

尝试从循环队列 尾端 拷贝数据（Peek at the Rear of Queue）

  • 当循环队列未初始化，返回错误码 XwcqError::NotInit 。
  • 拷贝数据不会取走数据，也不会释放数据槽，数据可被重复拷贝，也可继续被接收。
  • 若循环队列为空，立即返回 XwcqError::DataSize ，此方法不会阻塞。
  • 接收时，数据类型是泛型 T ，T 必须是 Sized 的，数据是被逐字节地从循环队列的数据槽中拷贝到出来的。
  • 循环队列不会对接收时的 T 与 发送时的 T 进行检查，因此用户必须确保两个类型是一样的，或能安全地进行转换。
  • 当 T 大小大于循环队列的数据槽大小 S ，接收会失败，并返回错误码 XwcqError::DataSize 。
§上下文
  • 任意
§错误码
§示例
extern crate core;
use core::str;
use core::slice::memchr::memchr;

use xwrust::xwmd::xwcq::*;

static CQ: Xwcq<64, 16> = Xwcq::new();

pub fn xwrust_example_xwcq() {
    CQ.init();
    // ...省略...
    let rc = CQ.tryprq::<[u8; 64]>();
    match rc {
        Ok(d) => { // 获取数据成功
            // 从 `[u8; 64]` 数组中构建切片 `&str`
            let totalslice = &d[0..64];
            let nullpos = memchr(0, totalslice).unwrap_or(64);
            let msgu8slice = &d[0..nullpos];
            let msg = str::from_utf8(msgu8slice);
        },
        Err(e) => { // 获取数据失败
        },
    };
}
source

pub fn flush(&self) -> XwcqError

清空循环队列

§上下文
  • 任意
source

pub const fn capacity(&self) -> XwSz

获取循环队列的容量

循环队列的容量也即是数据槽的数量，是在创建循环队列时，指明的类型常数 N 。

§上下文
  • 任意
source

pub const fn size(&self) -> XwSz

获取循环队列的单个数据槽的大小

循环队列的单个数据槽的大小是在创建循环队列时，指明的类型常数 S 。 若 S 不满足内存对齐的要求，会自动向上调整。

§上下文
  • 任意
source

pub fn availability(&self) -> Result<XwSz, XwcqError>

获取循环队列中有效数据槽的数量

有效数据槽是指包含了可被接收数据的数据槽。

§上下文
  • 任意

Trait Implementations§

source§

impl<const S: XwSz, const N: XwSz> !Send for Xwcq<S, N>
where [u8; { _ }]: Sized,

source§

impl<const S: XwSz, const N: XwSz> Sync for Xwcq<S, N>
where [u8; { _ }]: Sized,

Auto Trait Implementations§

§

impl<const S: usize, const N: usize> !Freeze for Xwcq<S, N>

§

impl<const S: usize, const N: usize> !RefUnwindSafe for Xwcq<S, N>

§

impl<const S: usize, const N: usize> Unpin for Xwcq<S, N>
where [u8; { _ }]: Sized,

§

impl<const S: usize, const N: usize> UnwindSafe for Xwcq<S, N>
where [u8; { _ }]: Sized,

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.