flat_message_proc_macro 0.2.1

Procedural macros for the FlatMessage serialization library.
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

pub(crate) enum AttributeValue {
    Direct(String),
    String(String),
    RawString(String),
}
impl AttributeValue {
    pub(crate) fn as_str(&self) -> &str {
        match self {
            AttributeValue::Direct(value) => value.as_str(),
            AttributeValue::String(value) => value.as_str(),
            AttributeValue::RawString(value) => value.as_str(),
        }
    }
    pub(crate) fn is_string_representation(&self) -> bool {
        matches!(self, AttributeValue::String(_))
    }
    // pub(crate) fn is_direct_representation(&self) -> bool {
    //     matches!(self, AttributeValue::Direct(_))
    // }    
}
impl From<String> for AttributeValue {
    fn from(mut value: String) -> Self {
        if value.starts_with('"') && value.ends_with('"') && value.len() > 1 {
            //println!("Processing : |{}|",value);
            value.pop();
            value.remove(0);     
            if value.contains('\\') {
                unescape_string(&mut value);
            }   
            //println!("       ->    |{}|",value);
            AttributeValue::String(value)
        } else if value.starts_with("r#\"") && value.ends_with("\"#") && value.len() >4 {
            //println!("Processing : |{}|",value);
            // remove the last two characters
            value.pop();
            value.pop();
            value.replace_range(0..3, "");
            if value.contains('\\') {
                unescape_string(&mut value);
            }         
            //println!("       ->    |{}|",value);
            AttributeValue::RawString(value)
        } else {
            AttributeValue::Direct(value)
        }
    }
}
fn unescape_string(s: &mut String) {
    let mut write = 0;
    let bytes = unsafe { s.as_bytes_mut() };

    let mut read = 0;
    while read < bytes.len() {
        if bytes[read] == b'\\' && read + 1 < bytes.len() {
            bytes[write] = bytes[read + 1];
            read += 2;
        } else {
            bytes[write] = bytes[read];
            read += 1;
        }
        write += 1;
    }

    s.truncate(write);
}