flexpiler 0.2.1

Deserialiser aiming at high customizability
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

use std::str::FromStr;

use crate::common::rustc::{block as block, Format};
use crate::{error, Error};
use crate::error::{Trait, Context};
use crate::parser;
use crate::reader;


// Proxy class
pub struct PrimitiveUSize;


impl crate::identity::Trait for usize {
    fn definition() -> String {
        return String::from("usize");
    }
}


impl crate::deserializer::Trait<
    usize,
    crate::common::rustc::Format
> for PrimitiveUSize {
    fn deserialize<ReaderType>(reader_mut_ref: &mut ReaderType)
        -> crate::deserializer::Result<usize, crate::common::rustc::deserializer::Context, crate::Error<crate::common::rustc::error::Source>>
    where ReaderType: reader::Trait {
        use crate::deserializer::context::Trait;
        use crate::error::Trait as ErrorTrait;
        use crate::error::propagation::Trait as PropagationTrait;
        use crate::parser::Parse;

        let (number_data, number_finish) = match block::Number::parse(reader_mut_ref) {
            Err(parser_error) => {
                let error = error::Error::gen(parser_error)
                    .propagate(<Self as crate::deserializer::context::Trait<usize, crate::common::rustc::Format>>::context());
                return crate::deserializer::Result::Err(error);
            },
            Ok(block::number::Result::NoDataFound { finish }) => {
                return crate::deserializer::Result::NoDataFound {
                    context: finish.into()
                };
            }
            Ok(block::number::Result::DataFound { data, finish }) => {
                (data, finish)
            },
        };

        let data = match usize::from_str(number_data.as_str()) {
            Err(parse_int_error) => {
                let error = error::Error::gen(parse_int_error)
                    .propagate(<Self as crate::deserializer::context::Trait<usize, crate::common::rustc::Format>>::context());
                return crate::deserializer::Result::Err(error);
            },
            Ok(value) => value,
        };
        let context = number_finish.into();

        return crate::deserializer::Result::DataFound {
            data,
            context,
        };
    }
}


impl crate::Deserialization<crate::common::rustc::Format> for usize {
    type Deserializer = PrimitiveUSize;
}