pareg_core 0.13.0

This library contains the implementation for the pareg 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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::Reader;
use std::cell::{Ref, RefCell};

use super::{FromRead, ParsedFmt, TrimSide};

/// Format for read function with reader.
#[derive(Debug, Clone, Default)]
pub struct ReadFmt<'a> {
    pub fmt: &'a str,
    parsed: RefCell<Option<ParsedFmt<'a>>>,
}

impl<'a> ReadFmt<'a> {
    /// Create new format from string. The format is parsed lazily.
    pub fn new(fmt: &'a str) -> Self {
        Self {
            fmt,
            parsed: None.into(),
        }
    }

    /// Creates new format where only the base is preserved.
    pub fn keep_base(&self) -> ReadFmt<'_> {
        ReadFmt {
            fmt: "",
            parsed: Some(ParsedFmt {
                base: self.base(),
                ..ParsedFmt::default()
            })
            .into(),
        }
    }

    /// Gets the parsed format.
    pub fn get_parsed(&self) -> ParsedFmt<'a> {
        self.get_parsed_inner().clone()
    }

    /// Get non standart part of the format.
    pub fn custom(&self) -> &'a str {
        self.get_parsed_inner().custom()
    }

    /// Get the trim information from the format.
    pub fn trim(&self) -> Option<(TrimSide, Option<char>)> {
        self.get_parsed_inner().trim()
    }

    /// Get the length range from the format.
    pub fn length_range(&self) -> Option<(usize, usize)> {
        self.get_parsed_inner().length_range()
    }

    /// Get the numerical base from the format.
    pub fn base(&self) -> Option<u32> {
        self.get_parsed_inner().base()
    }

    fn get_parsed_inner(&self) -> Ref<'_, ParsedFmt<'a>> {
        {
            let r = self.parsed.borrow();
            if r.is_some() {
                return Ref::map(r, |o| o.as_ref().unwrap());
            }
        }

        // Parse the input
        {
            *self.parsed.borrow_mut() = Some(self.parse());
        }
        Ref::map(self.parsed.borrow(), |o| o.as_ref().unwrap())
    }

    fn parse(&self) -> ParsedFmt<'a> {
        let mut res = ParsedFmt::default();

        // Check the trimming.
        let mut chrs = self.fmt.char_indices();
        let Some(c1) = chrs.next() else {
            return res;
        };

        let mut fmt = self.fmt;

        if let Some(c2) = chrs.next() {
            fmt = if let Some(t) = TrimSide::from_char(c2.1) {
                res.trim_side = Some(t);
                res.trim_char = Some(c1.1);
                &self.fmt[c2.0 + c2.1.len_utf8()..]
            } else if let Some(t) = TrimSide::from_char(c1.1) {
                res.trim_side = Some(t);
                &self.fmt[c2.0..]
            } else {
                self.fmt
            };
        } else if let Some(t) = TrimSide::from_char(c1.1) {
            res.trim_side = Some(t);
            fmt = &fmt[1..]
        }

        let mut fmt_read: Reader = fmt.into();

        let start = usize::from_read(&mut fmt_read, &"".into())
            .map(|(s, _)| s)
            .ok();

        if start.is_some() {
            fmt = &fmt[fmt_read.pos()..];
        }

        if let Some(f) = fmt.strip_prefix("..") {
            fmt = f;
            let end = usize::from_read(&mut fmt_read, &"".into())
                .map(|(s, _)| s)
                .ok();

            if start.is_some() {
                fmt = &fmt[fmt_read.pos()..];
            }

            res.length_range =
                Some((start.unwrap_or_default(), end.unwrap_or(usize::MAX)));
        } else {
            res.length_range = start.map(|s| (s, s));
        }

        let Some(c) = fmt.chars().next() else {
            res.custom_fmt = fmt;
            return res;
        };

        res.base = match c.to_ascii_lowercase() {
            'd' => Some(10),
            'x' => Some(16),
            'o' => Some(8),
            _ => None,
        };

        if res.base.is_some() {
            fmt = &fmt[1..];
        }

        res.custom_fmt = fmt;
        res
    }
}

impl<'a> From<&'a str> for ReadFmt<'a> {
    fn from(value: &'a str) -> Self {
        Self::new(value)
    }
}