pdf_parser 0.1.0

PDF parser
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

use crate::{error::PdfResult, pdf_enum};

#[derive(Debug)]
pub(crate) enum StateModel {
    Marked(MarkedState),
    Review(ReviewState),
}

impl StateModel {
    pub fn default(state_model: &str) -> PdfResult<Self> {
        Ok(match state_model {
            "Marked" => Self::Marked(MarkedState::default()),
            "Review" => Self::Review(ReviewState::default()),
            found => {
                return Err(crate::error::ParseError::UnrecognizedVariant {
                    ty: "StateModel",
                    found: found.to_owned(),
                })
            }
        })
    }

    pub fn with_state(state_model: &str, state: &str) -> PdfResult<Self> {
        let state_model = Self::default(state_model)?;

        Ok(match state_model {
            Self::Marked(..) => Self::Marked(MarkedState::from_str(state)?),
            Self::Review(..) => Self::Review(ReviewState::from_str(state)?),
        })
    }
}

pdf_enum!(
    #[derive(Debug)]
    pub(crate) enum MarkedState {
        /// The annotation has been marked by the user
        Marked = "Marked",

        /// The annotation has not been marked by the user (the default)
        Unmarked = "Unmarked",
    }
);

impl Default for MarkedState {
    fn default() -> Self {
        Self::Unmarked
    }
}

pdf_enum!(
    #[derive(Debug)]
    pub(crate) enum ReviewState {
        /// The user agrees with the change
        Accepted = "Accepted",

        /// The user disagrees with the change
        Rejected = "Rejected",

        /// The change has been cancelled
        Cancelled = "Cancelled",

        /// The change has been completed
        Completed = "Completed",

        /// The user has indicated nothing about the change (the default)
        None = "None",
    }
);

impl Default for ReviewState {
    fn default() -> Self {
        Self::None
    }
}