bibicode 0.2.1

A crate to convert any integer from one numeral system to another.
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


#[macro_use]

extern crate clap;
use clap::{App};

use std::process;
use std::fs;
use std::fs::File;
use std::path::Path;

extern crate bibicode;
use bibicode::{NumeralSystem, BibiCoder, BibiError};


extern crate serde_derive;
use serde_derive::{Serialize, Deserialize};



fn num_from_path(path: &str) -> Result<NumeralSystem, BibiError> {

    #[derive(Serialize, Deserialize, Debug)]
    pub struct FakeNumeralSystem {
        prefix: String,
        digits: Vec<Vec<String>>,
    }

    #[derive(Serialize, Deserialize, Debug)]
    pub struct FakeNumeralSystem2 {
        prefix: String,
        digits: Vec<String>,
    }

    match File::open(path) {
        Ok(file) => file,
        Err(_) => {
            return Err(BibiError::BadNumeralSystem);
        }
    };

    let contents = match fs::read_to_string(path) {
        Ok(contents) => contents,
        Err(_) => {
            return Err(BibiError::BadNumeralSystem);
        }
    };

    let test: Result<FakeNumeralSystem, _> = serde_json::from_str(&contents);
    match test {
        Ok(fakenum) => return NumeralSystem::new_from_strings(fakenum.prefix, fakenum.digits),
        Err(_) => {
            let test: Result<FakeNumeralSystem2, _> = serde_json::from_str(&contents);
            match test {
                Ok(fakenum) => return NumeralSystem::new_from_strings(fakenum.prefix, vec!(fakenum.digits)),
                Err(_) => return Err(BibiError::BadNumeralSystem)
            }
        }
    };
}


fn main() {

    let yaml = load_yaml!("bibic.yaml");
    let matches = App::from_yaml(yaml).get_matches();

    let mut res;

    let strfrom = matches.value_of("from").unwrap_or("dec");
    if Path::new(strfrom).exists() {
        res = num_from_path(strfrom);
    } else {
        res = NumeralSystem::new_from_tag(strfrom);
    }

    let from: NumeralSystem = match res {
        Ok(numsys) => numsys,
        Err(err) => {
            eprintln!("error: {:?}", err);
            process::exit(1);
        }
    };

    let strto = matches.value_of("to").unwrap_or("dec");
    if Path::new(strto).exists() {
        res = num_from_path(strto);
    } else {
        res = NumeralSystem::new_from_tag(strto);
    }

    let to: NumeralSystem = match res {
        Ok(numsys) => numsys,
        Err(err) => {
            eprintln!("error: {:?}", err);
            process::exit(1);
        }
    };

    let input_numbers: Vec<_> = matches.values_of("INPUT_NUMBER").unwrap().collect();

    let coder = BibiCoder::new(from, to);

    let mut res = String::from("");
    for input_number in input_numbers.iter() {
        let output_number = match coder.swap(input_number) {
            Ok(on) => on,
            Err(err) => {
                eprintln!("error: {:?}", err);
                process::exit(1);
            }
        };
        res = res + &output_number + &String::from(" ");
    }

    println!("{}", res);
    process::exit(0);
}