jppe 1.1.1

This is a byte stream structured serialization and deserialization 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
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

use crate::std::*;
use crate::{BorrowByteDecode, ByteDecode, InputTrait};
use crate::{FieldAttrModifiers, ContainerAttrModifiers};
use crate::decode::impls_bytes::parse_bytes;
use crate::parser::errors::{ErrorKind, JResult, make_error};
// use crate::parse_subsequence;


#[inline]
fn parse_string<'a>(input: &'a [u8], cattr: Option<&ContainerAttrModifiers>, fattr: Option<&FieldAttrModifiers>) -> JResult<&'a [u8], String> {
    let value_tmp;
    let input_tmp;

    if let Ok((input, value)) = parse_bytes(input, cattr, fattr) {
        input_tmp = input;
        value_tmp = Some(value);
    }
    // else if let Ok((input, value)) = parse_subsequence(input, b"\n", false) {
    //     input_tmp = input;
    //     value_tmp = Some(value);
    // }
    else {
        let (input, length) = input.to_be_bits_usize(1)?;
        let (input, value) = input.input_take(length)?;
        input_tmp = input;
        value_tmp = Some(value);
    }

    if let Some(value) = value_tmp {
        // let value = value.trim_ascii_end().to_vec().extract_if(|v| *v != 0).collect::<Vec<_>>();
        // std::str::from_utf8(value).unwrap().to_string()
        // match String::from_utf8(value) {
        //     Ok(v) => return Ok((input_tmp, v)),
        //     Err(_e) => return Err(make_error(input_tmp, ErrorKind::Fail { offset: input_tmp.len() })),
        // }

        match str::from_utf8(value) {
            Ok(v) => return Ok((input_tmp, v.to_string())),
            Err(_e) => return Err(make_error(input_tmp, ErrorKind::Fail { offset: input_tmp.len() })),
        }
    }

    Err(make_error(input_tmp, ErrorKind::InvalidByteLength { offset: input_tmp.len() }))
}


impl ByteDecode for String {
    fn decode<'da>(input: &'da [u8], cattr: Option<&ContainerAttrModifiers>, fattr: Option<&FieldAttrModifiers>) -> JResult<&'da [u8], Self>
        where 
            Self: Sized
    {
        let (input, value) = parse_string(input, cattr, fattr)?;

        Ok((input, value))        
    }
}        


impl<'de> BorrowByteDecode<'de> for String {
    fn decode<'da: 'de>(input: &'da [u8], cattr: Option<&ContainerAttrModifiers>, fattr: Option<&FieldAttrModifiers>) -> JResult<&'da [u8], Self>
        where 
            Self: Sized
    {
        let (input, value) = parse_string(input, cattr, fattr)?;

        Ok((input, value))        
    }
}


impl<'de> BorrowByteDecode<'de> for &'de str {
    #[inline]
    fn decode<'da: 'de, 'db>(input: &'da [u8], cattr: Option<&'db ContainerAttrModifiers>, fattr: Option<&'db FieldAttrModifiers>) -> JResult<&'da [u8], Self>
        where 
            Self: Sized
    {
        let (input, value) = if let Ok((input, value)) = parse_bytes(input, cattr, fattr) {
            (input, value)
        }
        else {
            let (input, length) = input.to_be_bits_usize(1)?;
            let (input, value) = input.input_take(length)?;
            (input, value)
        };

        match str::from_utf8(value) {
            Ok(v) => return Ok((input, v)),
            Err(_e) => return Err(make_error(input, ErrorKind::Fail { offset: input.len() })),
        }
    }
}