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
92
93
94
95
96
97
98

#[allow(unused_imports)]
use crate::{FieldAttrModifiers, ContainerAttrModifiers, ByteDecode, BorrowByteDecode};
use crate::{parser::*, InputTrait};
use crate::get_byteorder;


// #[inline]
pub fn parse_bytes<'a, 'b>(input: &'a [u8], cattr: Option<&'b ContainerAttrModifiers>, fattr: Option<&'b FieldAttrModifiers>) -> JResult<&'a [u8], &'a [u8]> {
    let mut value_tmp = None;
    let mut input = input;
    let mut input_tmp = input;

    if let Some(fr) = fattr {
        if let Some(key) = &fr.key {
            (input, _) = input.find_subsequence(key, false)?;
        }

        if let Some(splits) = fr.split {
            (input, _) = input.find_subsequence(splits, false)?;
        }

        // if fr.linend {
        //     let (input, value) = input.find_subsequences(&[b"\r\n", b"\n", b"\x00"], false)?;

        //     value_tmp = Some(value);
        //     input_tmp = input;
        // }
        if let Some(linend_value) = fr.linend_value {
            let (input, value) = input.find_subsequence(linend_value, false)?;

            // value_tmp = Some(value);
            // input_tmp = input;

            return Ok((input, value));
        }
        else if let Some(length) = fr.length {
            let (input, value) = input_take(input, length)?;

            value_tmp = Some(value);
            input_tmp = input;
        }
        else if let Some(byte_count) = fr.byte_count {
            let (input, length) = input.to_bits(get_byteorder(cattr, fattr), byte_count as u8)?;
            let (input, value) = input.input_take(length as usize)?;

            value_tmp = Some(value);
            input_tmp = input;
        }
        // else {
        //     let (input, length) = input.to_be_bits_usize(1)?;
        //     let (input, value) = input.input_take(length)?;
        //     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 {
        return Ok((input_tmp, value));
    }

    Err(make_error(input, ErrorKind::Fail { offset: input.len() }))
}


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

        match parse_bytes(input, cattr, fattr) {
            Ok((input, value)) => {
                input_tmp = input;
                value_tmp = Some(value);    
            },
            Err(e) => {
                if let crate::ErrorKind::Fail { .. } = e.code {
                    input_tmp = &[];
                    value_tmp = Some(input);
                }
            }
        }
    
        if let Some(value) = value_tmp {
            return Ok((input_tmp, value));
        }

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