to_bytes_derive 0.1.0

Serialize values into memory bytes
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#![allow(unused_macros)]
#![allow(dead_code)]
macro_rules! try_parser {
    { $f:ident($input:expr) } => {{
        let fork = &$input.fork();
        match $f(fork) {
            Ok(v) => { $input.advance_to(fork); Some(v) },
            Err(_) => None
        }
    }};
    { $input:expr; . $($t:tt)+ } => {{
        let fork = &$input.fork();
        match fork . $($t)+ {
            Ok(v) => { $input.advance_to(fork); Some(v) },
            Err(_) => None
        }
    }};
    { $input:expr; $($t:tt)+ } => {{
        let fork = &$input.fork();
        match fork.parse::<$($t)+>() {
            Ok(v) => { $input.advance_to(fork); Some(v) },
            Err(_) => None
        }
    }};
}
macro_rules! peek_parser {
    { $f:ident($input:expr) } => {{
        let fork = &$input.fork();
        match $f(fork) {
            Ok(v) => Some(v),
            Err(_) => None
        }
    }};
    { $input:expr; . $($t:tt)+ } => {{
        let fork = &$input.fork();
        match fork . $($t)+ {
            Ok(v) => Some(v),
            Err(_) => None
        }
    }};
    { $input:expr; $($t:tt)+ } => {{
        let fork = &$input.fork();
        match fork.parse::<$($t)+>() {
            Ok(v) => Some(v),
            Err(_) => None
        }
    }};
}
macro_rules! parse_char {
    { $input:expr; $($t:tt)* } => {
        $(
            $input.parse::<Token![$t]>()?;
        )*
    };
}

use syn::{
    parse::{ParseStream, Result},
    Attribute, Token,
};

#[inline]
pub fn parse_attrs(input: ParseStream) -> Result<Vec<Attribute>> {
    input.call(Attribute::parse_outer)
}
/// `---`
#[inline]
pub fn parse_split(input: ParseStream) -> Result<()> {
    parse_char![input;---];
    Ok(())
}
/// `;`
#[inline]
pub fn parse_end(input: ParseStream) -> Result<()> {
    parse_char![input;;];
    Ok(())
}
/// `,`
#[inline]
pub fn parse_comma(input: ParseStream) -> Result<()> {
    parse_char![input;,];
    Ok(())
}
/// `=`
#[inline]
pub fn parse_eq(input: ParseStream) -> Result<()> {
    parse_char![input;=];
    Ok(())
}

#[inline]
pub fn uppercase_first_letter(s: &String) -> String {
    let mut c = s.chars();
    match c.next() {
        None => String::new(),
        Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
    }
}