baseic 0.1.1

A simple numeric conversion tool
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

mod ascii;
mod bin;
mod conv_types;
mod dec;
mod hex;
mod octal;

use indexmap::{IndexMap, IndexSet};

use crate::Opts;

pub use conv_types::{InputConverterType, OutputConverterType};

/// Intermediate type used for conversions
type IntermediateValue = i128;

/// Represents a generic output converter
pub trait OutputConverter {
    /// Convert value to the intermediate type
    fn convert(&self, input: IntermediateValue) -> Result<String, ()>;
}

/// Represents a generic input converter
pub trait InputConverter {
    /// Convert value to the intermediate type
    fn convert(&self, input: &str) -> Result<IntermediateValue, ()>;
}

/// Represents the result of conversion
#[derive(Debug)]
pub struct ConversionOutput {
    pub inner: IndexMap<InputConverterType, ConversionResult>,
}

impl ConversionOutput {
    /// Checks if there are any results
    pub fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }
}

impl From<IndexMap<InputConverterType, ConversionResult>> for ConversionOutput {
    fn from(value: IndexMap<InputConverterType, ConversionResult>) -> Self {
        Self { inner: value }
    }
}

impl FromIterator<(InputConverterType, ConversionResult)> for ConversionOutput {
    fn from_iter<T: IntoIterator<Item = (InputConverterType, ConversionResult)>>(iter: T) -> Self {
        let mut inner = IndexMap::new();

        for (outconv, val) in iter {
            inner.insert(outconv, val);
        }

        Self::from(inner)
    }
}

/// Represents the result of conversion starting from a single input converter type
#[derive(Debug)]
pub struct ConversionResult {
    pub inner: IndexMap<OutputConverterType, String>,
}

impl ConversionResult {
    /// Checks if there are any results
    pub fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }
}

impl From<IndexMap<OutputConverterType, String>> for ConversionResult {
    fn from(value: IndexMap<OutputConverterType, String>) -> Self {
        Self { inner: value }
    }
}

impl FromIterator<(OutputConverterType, String)> for ConversionResult {
    fn from_iter<T: IntoIterator<Item = (OutputConverterType, String)>>(iter: T) -> Self {
        let mut inner = IndexMap::new();

        for (outconv, val) in iter {
            inner.insert(outconv, val);
        }

        Self::from(inner)
    }
}

/// Conversion error
#[derive(Debug)]
pub enum ConversionError {
    NoResults,
}

/// Performs conversion with given options
pub fn do_convert(opts: Opts) -> Result<ConversionOutput, ConversionError> {
    let res: ConversionOutput = opts
        .inconvs
        .into_iter()
        .filter_map(|inconv| {
            // Run input converter
            if let Ok(int) = inconv.get_converter().convert(&opts.input) {
                let res = proces_outconvs(&opts.outconvs, &inconv, int);
                if res.is_empty() {
                    None
                } else {
                    Some((inconv, res))
                }
            } else {
                None
            }
        })
        .collect();

    // Check if result is empty
    if res.is_empty() {
        Err(ConversionError::NoResults)
    } else {
        Ok(res)
    }
}

/// Process output converters from a given intermediate value
pub fn proces_outconvs(
    outconvs: &IndexSet<OutputConverterType>,
    inconv: &InputConverterType,
    input: IntermediateValue,
) -> ConversionResult {
    // Run selected output converters
    outconvs
        .into_iter()
        .filter_map(|outconv| {
            // Check if this output converter is excluded
            if inconv.is_outconv_excluded(outconv) {
                return None;
            }

            if let Ok(out) = outconv.get_converter().convert(input) {
                Some((outconv.clone(), out))
            } else {
                None
            }
        })
        .collect()
}