bitfield struct rs下载bitfield struct rs源代码下载

Bitfield结构

Bitfields的过程宏，允许将Bitfield指定为结构。由于该库提供了一个程序上的宏，因此它没有运行时依赖关系，并且适用于no-std环境。

驾驶员/OS/嵌入式开发（定义HW寄存器/结构）的理想选择
支持布尔标志，整数和自定义类型可转换为整数（结构/枚举）
产生简约，纯净，安全的生锈功能
编译类型和字段大小的编译时间检查
Rust-Analyzer/docrs友好（将文档传递到访问器功能）
导出场偏移和大小作为常数（对const断言有用）
Default ， fmt::Debug或defmt::Format性状的产生
自定义内部表示（Endianness）

用法

将其添加到您的Cargo.toml ：

[ dependencies ]
bitfield-struct = " 0.10 "

基础

让我们从一个简单的例子开始。假设我们要在单个字节中存储多个数据，如下所示：

7	6	5	4	3	2	1	0
p	等级		s	种类

该板条箱生成了一种不错的包装类型，使其很容易做到这一点：

 use bitfield_struct :: bitfield ;

/// Define your type like this with the bitfield attribute
# [ bitfield ( u8 ) ]
struct MyByte {
    /// The first field occupies the least significant bits
    # [ bits ( 4 ) ]
    kind : usize ,
    /// Booleans are 1 bit large
    system : bool ,
    /// The bits attribute specifies the bit size of this field
    # [ bits ( 2 ) ]
    level : usize ,
    /// The last field spans over the most significant bits
    present : bool
}
// The macro creates three accessor functions for each field:
// <name>, with_<name> and set_<name>
let my_byte = MyByte :: new ( )
    . with_kind ( 15 )
    . with_system ( false )
    . with_level ( 3 )
    . with_present ( true ) ;

assert ! ( my_byte . present ( ) ) ;

特征

此外，该板条箱具有一些有用的功能，此处将更详细地显示。

下面的示例显示了如何携带属性以及如何处理签名的整数，填充和自定义类型。

 use bitfield_struct :: bitfield ;

/// A test bitfield with documentation
# [ bitfield ( u64 ) ]
# [ derive ( PartialEq , Eq ) ] // <- Attributes after `bitfield` are carried over
struct MyBitfield {
    /// Defaults to 16 bits for u16
    int : u16 ,
    /// Interpreted as 1 bit flag, with a custom default value
    # [ bits ( default = true ) ]
    flag : bool ,
    /// Custom bit size
    # [ bits ( 1 ) ]
    tiny : u8 ,
    /// Sign extend for signed integers
    # [ bits ( 13 ) ]
    negative : i16 ,
    /// Supports any type with `into_bits`/`from_bits` functions
    # [ bits ( 16 ) ]
    custom : CustomEnum ,
    /// Public field -> public accessor functions
    # [ bits ( 10 ) ]
    pub public : usize ,
    /// Also supports read-only fields
    # [ bits ( 1 , access = RO ) ]
    read_only : bool ,
    /// And write-only fields
    # [ bits ( 1 , access = WO ) ]
    write_only : bool ,
    /// Padding
    # [ bits ( 5 ) ]
    __ : u8 ,
}

/// A custom enum
# [ derive ( Debug , PartialEq , Eq ) ]
# [ repr ( u16 ) ]
enum CustomEnum {
    A = 0 ,
    B = 1 ,
    C = 2 ,
}
impl CustomEnum {
    // This has to be a const fn
    const fn into_bits ( self ) -> u16 {
        self as _
    }
    const fn from_bits ( value : u16 ) -> Self {
        match value {
            0 => Self :: A ,
            1 => Self :: B ,
            _ => Self :: C ,
        }
    }
}

// Usage:
let mut val = MyBitfield :: new ( )
    . with_int ( 3 << 15 )
    . with_tiny ( 1 )
    . with_negative ( - 3 )
    . with_custom ( CustomEnum :: B )
    . with_public ( 2 )
    // .with_read_only(true) <- Would not compile
    . with_write_only ( false ) ;

println ! ( "{val:?}" ) ;
let raw : u64 = val . into ( ) ;
println ! ( "{raw:b}" ) ;

assert_eq ! ( val . int ( ) , 3 << 15 ) ;
assert_eq ! ( val . flag ( ) , true ) ;
assert_eq ! ( val . negative ( ) , - 3 ) ;
assert_eq ! ( val . tiny ( ) , 1 ) ;
assert_eq ! ( val . custom ( ) , CustomEnum :: B ) ;
assert_eq ! ( val . public ( ) , 2 ) ;
assert_eq ! ( val . read_only ( ) , false ) ;

// const members
assert_eq ! ( MyBitfield :: FLAG_BITS , 1 ) ;
assert_eq ! ( MyBitfield :: FLAG_OFFSET , 16 ) ;

val . set_negative ( 1 ) ;
assert_eq ! ( val . negative ( ) , 1 ) ;

宏为每个字段生成三个访问器功能。每个访问者还继承其字段的文档。

int的签名是：

 // generated struct
struct MyBitfield ( u64 ) ;
impl MyBitfield {
    const fn new ( ) -> Self { Self ( 0 ) }

    const INT_BITS : usize = 16 ;
    const INT_OFFSET : usize = 0 ;

    const fn int ( & self ) -> u16 { todo ! ( ) }

    const fn with_int ( self , value : u16 ) -> Self { todo ! ( ) }
    const fn with_int_checked ( self , value : u16 ) -> Result < Self , ( ) > { todo ! ( ) }

    const fn set_int ( & mut self , value : u16 ) { todo ! ( ) }
    const fn set_int_checked ( & mut self , value : u16 ) -> Result < ( ) , ( ) > { todo ! ( ) }

    // other field ...
}
// Also generates From<u64>, Into<u64>, Default, and Debug implementations...

提示：您可以使用Rust-Analyzer“递归扩展”操作来查看生成的代码。

自定义类型

宏支持任何可转换为基础比特菲尔德类型的类型。这可以是枚举，例如以下示例或任何其他结构。

转换和默认值可以用以下#[bits]参数指定：

from ：函数从原始位转换为自定义类型，默认为<ty>::from_bits
into ：函数从自定义类型转换为原始位，默认为<ty>::into_bits
default ：自定义表达式，默认为调用<ty>::from_bits(0)

 use bitfield_struct :: bitfield ;

# [ bitfield ( u16 ) ]
# [ derive ( PartialEq , Eq ) ]
struct Bits {
    /// Supports any convertible type
    # [ bits ( 8 , default = CustomEnum :: B , from = CustomEnum :: my_from_bits ) ]
    custom : CustomEnum ,
    /// And nested bitfields
    # [ bits ( 8 ) ]
    nested : Nested ,
}

# [ derive ( Debug , PartialEq , Eq ) ]
# [ repr ( u8 ) ]
enum CustomEnum {
    A = 0 ,
    B = 1 ,
    C = 2 ,
}
impl CustomEnum {
    // This has to be a const fn
    const fn into_bits ( self ) -> u8 {
        self as _
    }
    const fn my_from_bits ( value : u8 ) -> Self {
        match value {
            0 => Self :: A ,
            1 => Self :: B ,
            _ => Self :: C ,
        }
    }
}

/// Bitfields implement the conversion functions automatically
# [ bitfield ( u8 ) ]
struct Nested {
    # [ bits ( 4 ) ]
    lo : u8 ,
    # [ bits ( 4 ) ]
    hi : u8 ,
}

现场顺序

可选order宏参数确定位的布局，默认值是LSB（最不重要的位）：

 use bitfield_struct :: bitfield ;

# [ bitfield ( u8 , order = Lsb ) ]
struct MyLsbByte {
    /// The first field occupies the *least* significant bits
    # [ bits ( 4 ) ]
    kind : usize ,
    system : bool ,
    # [ bits ( 2 ) ]
    level : usize ,
    present : bool
}
let my_byte_lsb = MyLsbByte :: new ( )
    . with_kind ( 10 )
    . with_system ( false )
    . with_level ( 2 )
    . with_present ( true ) ;

//                          .- present
//                          | .- level
//                          | |  .- system
//                          | |  | .- kind
assert_eq ! ( my_byte_lsb . 0 , 0b1_10_0_1010 ) ;

指定MSB（最重要的位）时，宏会生成反向顺序：

 use bitfield_struct :: bitfield ;

# [ bitfield ( u8 , order = Msb ) ]
struct MyMsbByte {
    /// The first field occupies the *most* significant bits
    # [ bits ( 4 ) ]
    kind : usize ,
    system : bool ,
    # [ bits ( 2 ) ]
    level : usize ,
    present : bool
}
let my_byte_msb = MyMsbByte :: new ( )
    . with_kind ( 10 )
    . with_system ( false )
    . with_level ( 2 )
    . with_present ( true ) ;

//                          .- kind
//                          |    .- system
//                          |    | .- level
//                          |    | |  .- present
assert_eq ! ( my_byte_msb . 0 , 0b1010_0_10_1 ) ;

自定义代表和底色

宏支持Bitfield结构的表示自定义类型。这可以是以下示例（来自endian-num ）或任何可以转换为Bitfield类型的其他结构的eNDIAN定义类型。

可以使用以下#[bitfield]参数指定表示形式及其转换功能：

repr在内存中指定比特菲尔德的表示
from “从reper到Bitfield的整数类型”指定转换函数
从比特菲尔德的整数类型into转换函数到reper

这个示例即使在大型机器上也有一个小的字节订单：

 use bitfield_struct :: bitfield ;
use endian_num :: le16 ;

# [ bitfield ( u16 , repr = le16 , from = le16 :: from_ne , into = le16 :: to_ne ) ]
struct MyLeBitfield {
    # [ bits ( 4 ) ]
    first_nibble : u8 ,
    # [ bits ( 12 ) ]
    other : u16 ,
}

let my_be_bitfield = MyLeBitfield :: new ( )
    . with_first_nibble ( 0x1 )
    . with_other ( 0x234 ) ;

assert_eq ! ( my_be_bitfield . into_bits ( ) . to_le_bytes ( ) , [ 0x41 , 0x23 ] ) ;

这个示例即使在小型机器上也有大型字节订单：

 use bitfield_struct :: bitfield ;
use endian_num :: be16 ;

# [ bitfield ( u16 , repr = be16 , from = be16 :: from_ne , into = be16 :: to_ne ) ]
struct MyBeBitfield {
    # [ bits ( 4 ) ]
    first_nibble : u8 ,
    # [ bits ( 12 ) ]
    other : u16 ,
}

let my_be_bitfield = MyBeBitfield :: new ( )
    . with_first_nibble ( 0x1 )
    . with_other ( 0x234 ) ;

assert_eq ! ( my_be_bitfield . into_bits ( ) . to_be_bytes ( ) , [ 0x23 , 0x41 ] ) ;

自动特征实现

`Clone` ， `Copy`

默认情况下，此宏Clone并Copy 。如果克隆您的类型的语义需要它，则可以使用额外的clone参数禁用此功能（例如，该类型保留了一个必须克隆的数据指针）。在这种情况下，您可以为Clone和Copy提供自己的实现。

 use bitfield_struct :: bitfield ;

# [ bitfield ( u64 , clone = false ) ]
struct CustomClone {
    data : u64
}

impl Clone for CustomClone {
    fn clone ( & self ) -> Self {
        Self :: new ( ) . with_data ( self . data ( ) )
    }
}

// optionally:
impl Copy for CustomClone { }

`fmt::Debug` ， `Default`

默认情况下，它还生成合适的fmt::Debug和Default实现，类似于#[derive(Debug, Default)]为普通结构创建的实现。您可以使用额外的debug和default参数禁用此功能。

 use std :: fmt :: { Debug , Formatter , Result } ;
use bitfield_struct :: bitfield ;

# [ bitfield ( u64 , debug = false , default = false ) ]
struct CustomDebug {
    data : u64
}
impl Debug for CustomDebug {
    fn fmt ( & self , f : & mut Formatter < ' _ > ) -> Result {
        write ! ( f , "0x{:x}" , self . data ( ) )
    }
}
impl Default for CustomDebug {
    fn default ( ) -> Self {
        Self ( 123 )
    }
}

let val = CustomDebug :: default ( ) ;
println ! ( "{val:?}" )

支持`defmt::Format`

该宏可以自动实现defmt::Format ，该格式通过传递额外的defmt参数来反映默认的fmt::Debug实现。此实现要求Defmt板条作为defmt可用，并且具有与#[derive(defmt::Format)]相同规则和警告。

 use bitfield_struct :: bitfield ;

# [ bitfield ( u64 , defmt = true ) ]
struct DefmtExample {
    data : u64
}

有条件启用`new` / `Clone` / `Debug` / `Default` / `defmt::Format`

您可以为new ， clone ， debug ， default和defmt指定cfg(...)属性，而不是布尔值：

 use bitfield_struct :: bitfield ;

# [ bitfield ( u64 , debug = cfg ( test ) , default = cfg ( feature = "foo" ) ) ]
struct CustomDebug {
    data : u64
}

展开

bitfield struct rs

Bitfield结构

用法

基础

特征

自定义类型

现场顺序

自定义代表和底色

自动特征实现

`Clone` ， `Copy`

`fmt::Debug` ， `Default`

支持`defmt::Format`

有条件启用`new` / `Clone` / `Debug` / `Default` / `defmt::Format`

quicksync rs

redis rs

snkrs耐克app

rs开放世界驾驶

Drive RS游戏

RS开放世界驾驶游戏

chat.petals.dev

GPT Prompt Templates

GPTyped

Google Dorks

shepherd

mongo express

Google Dorks

shepherd

mongo express

bitfield struct rs

Bitfield结构

用法

基础

特征

自定义类型

现场顺序

自定义代表和底色

自动特征实现

Clone ， Copy

fmt::Debug ， Default

支持defmt::Format

有条件启用new / Clone / Debug / Default / defmt::Format

`Clone` ， `Copy`

`fmt::Debug` ， `Default`

支持`defmt::Format`

有条件启用`new` / `Clone` / `Debug` / `Default` / `defmt::Format`