ommui_data 0.36.5

#[macro_use]
extern crate log;

#[macro_use]
extern crate snafu;

extern crate ommui_file_loading;
extern crate structopt;

mod args;

use args::Arguments;
use snafu::{ErrorCompat, ResultExt};
use structopt::StructOpt;

type Result<T, E = error::Error> = std::result::Result<T, E>;

mod error {
    use snafu::Backtrace;

    #[derive(Snafu, Debug)]
    #[snafu(visibility(pub(crate)))]
    pub enum Error {
        /// An error in the OMMUI data crate.
        #[snafu(display("OMMUI data error: {:?}", source))]
        OmmuiData {
            /// The source error.
            #[snafu(backtrace)]
            source: ommui_data::Error,
        },
        /// An error in the OMMUI file loading crate.
        #[snafu(display("OMMUI file loading: {:?}", source))]
        OmmuiFileLoading {
            /// The source error.
            #[snafu(backtrace)]
            source: ommui_file_loading::Error,
        },
        /// Serde JSON error.
        #[snafu(display("Serde JSON error: {:?}", source))]
        SerdeJson {
            /// The source error.
            source: serde_json::Error,
            /// The backtrace
            backtrace: Backtrace,
        },
    }
}

fn run(args: Arguments) -> Result<()> {
    use ommui_data::annalisa::Bin;
    use ommui_file_loading::load_json;

    let input: Bin =
        load_json(args.file).context(error::OmmuiFileLoading)?;

    if let Bin::Pipeline(details) = input {
        let pipeline = details.to_arnalisa().context(error::OmmuiData)?;
        serde_json::to_writer_pretty(
            std::io::stdout(),
            &arnalisa::bins::SourceSinkDescription::Pipeline(pipeline),
        )
        .context(error::SerdeJson)?;
    } else {
        eprintln!("Not a pipeline: {:#?}", input);
    }

    Ok(())
}

fn main() {
    env_logger::Builder::new()
        .filter(None, log::LevelFilter::Warn)
        .init();

    if let Err(s) = run(Arguments::from_args()) {
        warn!("{:#?}", s);
        if let Some(backtrace) = ErrorCompat::backtrace(&s) {
            warn!("{}", backtrace);
        }
        std::process::exit(2);
    }
}