inno 0.4.2

Library for reading Inno Setup executables
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

use std::io;

use encoding_rs::Encoding;

use crate::{read::ReadBytesExt, version::InnoVersion};

#[derive(Clone, Debug, Default)]
pub struct Condition {
    components: Option<String>,
    tasks: Option<String>,
    languages: Option<String>,
    check: Option<String>,
    after_install: Option<String>,
    before_install: Option<String>,
}

impl Condition {
    pub fn read<R>(
        mut reader: R,
        codepage: &'static Encoding,
        version: InnoVersion,
    ) -> io::Result<Self>
    where
        R: io::Read,
    {
        let mut condition = Self::default();

        if version >= 2 || (version.is_isx() && version >= (1, 3, 8)) {
            condition.components = reader.read_decoded_pascal_string(codepage)?;
        }

        if version >= 2 || (version.is_isx() && version >= (1, 3, 17)) {
            condition.tasks = reader.read_decoded_pascal_string(codepage)?;
        }

        if version >= (4, 0, 1) {
            condition.languages = reader.read_decoded_pascal_string(codepage)?;
        }

        if version >= 4 || (version.is_isx() && version >= (1, 3, 24)) {
            condition.check = reader.read_decoded_pascal_string(codepage)?;
        }

        if version >= 4.1 {
            condition.after_install = reader.read_decoded_pascal_string(codepage)?;
            condition.before_install = reader.read_decoded_pascal_string(codepage)?;
        }

        Ok(condition)
    }

    /// Returns the components as a string slice.
    #[must_use]
    #[inline]
    pub fn as_str(&self) -> Option<&str> {
        self.components.as_deref()
    }

    /// Returns the tasks as a string slice.
    #[must_use]
    #[inline]
    pub fn tasks(&self) -> Option<&str> {
        self.tasks.as_deref()
    }

    /// Returns the languages as a string slice.
    #[must_use]
    #[inline]
    pub fn languages(&self) -> Option<&str> {
        self.languages.as_deref()
    }

    /// Returns the check condition as a string slice.
    #[must_use]
    #[inline]
    pub fn check(&self) -> Option<&str> {
        self.check.as_deref()
    }

    /// Returns the after install condition as a string slice.
    #[must_use]
    #[inline]
    pub fn after_install(&self) -> Option<&str> {
        self.after_install.as_deref()
    }

    /// Returns the before install condition as a string slice.
    #[must_use]
    #[inline]
    pub fn before_install(&self) -> Option<&str> {
        self.before_install.as_deref()
    }
}