lj_rust/src/conf.rs

use config::Config;
use serde::{Serialize,Deserialize};
use crate::errors::{LJError,LJResult};
use crate::transformer;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Conf {
    pub laser_id: u8,
    pub debug: bool,
    pub redis_url: String,
    pub dac: DacFamily,
    #[serde(default)]
    pub transformers: Vec<TransformConf>
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DacFamily {
    #[serde(rename = "helios")] 
    Helios(HeliosConf),
    #[serde(rename = "etherdream")] 
    Etherdream(EtherDreamConf),
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct HeliosConf {
    pub id: u8
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct EtherDreamConf {
    pub url: String
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TransformConf {
    #[serde(rename = "translate")] 
    Translate(transformer::Translate),
    #[serde(rename = "replicate")] 
    Replicate(transformer::Replicate)
}


impl Conf {
    pub fn new(path: &str) -> LJResult<Conf> {
	let settings = Config::builder()
            .add_source(config::File::with_name(path))
	    .build()?;
        
	let conf : Conf = settings.try_deserialize().map_err(LJError::Config)?;
	Ok(conf)
    }

    pub fn get_transformers(&self) -> Vec<Box<dyn transformer::Transformers>> {
	let mut v = vec![];
	for t in &self.transformers {
	    let t : Box<dyn transformer::Transformers> = match t {
		TransformConf::Translate(t) => Box::new(*t),
		TransformConf::Replicate(r) => Box::new(*r)
	    };
	    v.push(t);
	}
	v
    }

    #[allow(dead_code)]
    pub fn dump() {
	let conf = Conf { laser_id: 0,
			  debug: true,
			  redis_url: "redis://127.0.0.1:6379/".to_string(),
			  dac: DacFamily::Helios(HeliosConf { id: 0 }),
			  transformers: vec![
			      TransformConf::Translate(transformer::Translate::new(2000.0,2000.0)),
			      TransformConf::Replicate(transformer::Replicate::Until(48))
			  ]
	};
	let s = toml::to_string(&conf).unwrap();
	println!("{}", s);
    }
}