bitbuffer_derive 0.11.3

Reading bit sequences from a byte slice
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

use crate::params::field::FieldParam;
use proc_macro2::{Ident, Span};
use syn::{Attribute, DataStruct, Fields, Result};

pub struct StructParam {
    pub span: Span,
    pub ident: Ident,
    pub fields: Vec<FieldParam>,
    pub is_unit: bool,
}

impl StructParam {
    pub fn size_can_be_predicted(&self) -> bool {
        self.fields
            .iter()
            .all(|field| field.size_can_be_predicted())
    }

    pub fn parse(
        data: &DataStruct,
        ident: Ident,
        _attrs: &[Attribute],
        span: Span,
    ) -> Result<StructParam> {
        let fields = data
            .fields
            .iter()
            .map(FieldParam::parse)
            .collect::<Result<Vec<FieldParam>>>()?;

        let is_unit = matches!(data.fields, Fields::Unit);

        Ok(StructParam {
            span,
            ident,
            fields,
            is_unit,
        })
    }

    pub fn span(&self) -> Span {
        self.span
    }
}