binrw_derive 0.9.0

Derive macro for binrw
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use super::super::{
    keywords as kw,
    meta_types::{
        IdentPatType, IdentTypeMaybeDefault, MetaEnclosedList, MetaExpr, MetaList, MetaLit,
        MetaType, MetaValue, MetaVoid,
    },
    KeywordToken,
};
use proc_macro2::{Span, TokenStream};
use syn::{
    parse::{Parse, ParseBuffer},
    Expr, Token,
};

use core::ops::Deref;

pub struct ReadOnlyAttr<T>(pub T);

impl<T: KeywordToken> KeywordToken for ReadOnlyAttr<T> {
    type Token = T::Token;

    fn keyword_span(&self) -> Span {
        T::keyword_span(&self.0)
    }
}

impl<T: Parse> Parse for ReadOnlyAttr<T> {
    fn parse(buf: &ParseBuffer<'_>) -> Result<Self, syn::Error> {
        T::parse(buf).map(|x| ReadOnlyAttr(x))
    }
}

impl<T: Into<TokenStream>> From<ReadOnlyAttr<T>> for TokenStream {
    fn from(r: ReadOnlyAttr<T>) -> Self {
        r.0.into()
    }
}

impl<T> Deref for ReadOnlyAttr<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub(crate) type AlignAfter = MetaExpr<kw::align_after>;
pub(crate) type AlignBefore = MetaExpr<kw::align_before>;
pub(crate) type Args = MetaEnclosedList<kw::args, Expr, TokenStream>;
pub(crate) type ArgsRaw = MetaExpr<kw::args_raw>;
pub(crate) type AssertLike<K> = MetaList<K, Expr>;
pub(crate) type Assert = AssertLike<kw::assert>;
pub(crate) type Big = MetaVoid<kw::big>;
pub(crate) type Calc = MetaExpr<kw::calc>;
pub(crate) type Count = MetaExpr<kw::count>;
pub(crate) type Default = MetaVoid<kw::default>;
pub(crate) type DerefNow = MetaVoid<kw::deref_now>;
pub(crate) type ErrContext = MetaList<kw::err_context, Expr>;
pub(crate) type If = MetaList<Token![if], Expr>;
pub(crate) type Ignore = MetaVoid<kw::ignore>;
pub(crate) type Import =
    ReadOnlyAttr<MetaEnclosedList<kw::import, IdentPatType, IdentTypeMaybeDefault>>;
pub(crate) type ImportRaw = MetaValue<kw::import_raw, IdentPatType>;
pub(crate) type IsBig = MetaExpr<kw::is_big>;
pub(crate) type IsLittle = MetaExpr<kw::is_little>;
pub(crate) type Little = MetaVoid<kw::little>;
pub(crate) type Magic = MetaLit<kw::magic>;
pub(crate) type Map = MetaExpr<kw::map>;
pub(crate) type Offset = MetaExpr<kw::offset>;
pub(crate) type OffsetAfter = MetaExpr<kw::offset_after>;
pub(crate) type PadAfter = MetaExpr<kw::pad_after>;
pub(crate) type PadBefore = MetaExpr<kw::pad_before>;
pub(crate) type PadSizeTo = MetaExpr<kw::pad_size_to>;
pub(crate) type ParseWith = MetaExpr<kw::parse_with>;
pub(crate) type PostProcessNow = MetaVoid<kw::postprocess_now>;
pub(crate) type PreAssert = AssertLike<kw::pre_assert>;
pub(crate) type Repr = ReadOnlyAttr<MetaType<kw::repr>>;
pub(crate) type RestorePosition = MetaVoid<kw::restore_position>;
pub(crate) type ReturnAllErrors = MetaVoid<kw::return_all_errors>;
pub(crate) type ReturnUnexpectedError = MetaVoid<kw::return_unexpected_error>;
pub(crate) type SeekBefore = MetaExpr<kw::seek_before>;
pub(crate) type Temp = MetaVoid<kw::temp>;
pub(crate) type Try = MetaVoid<Token![try]>;
pub(crate) type TryMap = MetaExpr<kw::try_map>;