assembly 0.4.1

Library for files/resources for LU related software
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

extern crate getopts;
use std::io::{BufReader, Error as IoError};
use std::fs::File;
use assembly::fdb::core::{Field};
use assembly::fdb::io::{SchemaLoader, LoaderConfigImpl, LoadError};
use assembly::fdb::sysdiagram::core::SysDiagram;
use assembly::fdb::sysdiagram::io::LoadError as SysDiagramError;
use std::convert::TryFrom;
use getopts::Options;


#[derive(Debug)]
pub enum MainError {
    Io(IoError),
    Load(LoadError),
    SysDiagram(SysDiagramError),
    TableNotFound,
}

impl From<IoError> for MainError {
    fn from(e: IoError) -> Self {
        MainError::Io(e)
    }
}

impl From<LoadError> for MainError {
    fn from(e: LoadError) -> Self {
        MainError::Load(e)
    }
}

impl From<SysDiagramError> for MainError {
    fn from(e: SysDiagramError) -> Self {
        MainError::SysDiagram(e)
    }
}

fn load_database(filename: &str) -> Result<(), MainError> {
    println!("Loading tables... (this may take a while)");
    let file = File::open(filename)?;
    let mut reader = BufReader::new(file);
    let config = LoaderConfigImpl {
        table_data_policy: |def| def.name == "sysdiagrams",
    };
    let mut loader = SchemaLoader::open(&mut reader, config);
    let schema = loader.try_load_schema()?;

    match schema.table("sysdiagrams") {
        Some(table) => {
            for row in table {
                match &row.fields_ref()[4] {
                    Field::Text(text) => {
                        let sysdiagram = SysDiagram::try_from(&text[..])?;
                        println!("{:?}", sysdiagram);
                    },
                    data => println!("Wrong data: {:?}", data),
                }
            }
            Ok(())
        },
        None => Err(MainError::TableNotFound),
    }
}

fn print_usage(program: &str, opts: Options) {
    let brief = format!("Usage: {} FILE [options]", program);
    print!("{}", opts.usage(&brief));
}

pub fn main(args: Vec<String>) -> Result<(), MainError> {
    let program = args[0].clone();

    let mut opts = Options::new();
    opts.optflag("h", "help", "print this help menu");
    let matches = match opts.parse(&args[1..]) {
        Ok(m) => { m }
        Err(f) => { panic!(f.to_string()) }
    };
    if matches.opt_present("h") {
        print_usage(&program, opts);
        return Ok(());
    }
    let input = if !matches.free.is_empty() {
        matches.free[0].clone()
    } else {
        print_usage(&program, opts);
        return Ok(());
    };
    load_database(&input)
}