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
//! # rtr //! //! rtr is a crate that return strings from translation files <br/> //! _Thoses files need to be manually created with the [rtrTranslator](https://github.com/ProbablyClem/rtrTranslator) software_ #[macro_use] extern crate lazy_static; use std::io; use std::fs::File; use std::io::prelude::*; use std::io::BufReader; use std::sync::Mutex; use std::sync::atomic::{AtomicBool, Ordering}; lazy_static! { static ref ORIGIN_VEC : Mutex<Vec<String>> = Mutex::new(Vec::new()); //The vector that containt every line of the origin langage static ref DEST_VEC : Mutex<Vec<String>> = Mutex::new(Vec::new()); //The vector that containt every line of the destination language (e.g fr, it, de...) static ref STATE : Mutex<AtomicBool> = Mutex::new(AtomicBool::new(true)); } fn create_path(source: String) -> String { let mut new_path = String::from("./lang/.txt"); new_path.insert_str(7, source.as_str()); return new_path; } ///Set the language for the program /// # Examples /// /// To set the program in french /// /// ``` /// extern crate rtr; /// /// match rtr::init("fr"){ /// Ok(_) => (), /// Err(e) => panic!("couldn't load the fr translation file, error {}", e), /// }; /// ``` ///Don't forget that it will need the ./lang/fr.txt file /// /// # Errors ///Will return an std::io:Error in case of trouble loading the translation file pub fn init(new_lang: &str) -> Result<(), io::Error> { let f = File::open(create_path("origin".to_string()))?; let f = BufReader::new(f); for line in f.lines() { ORIGIN_VEC.lock().unwrap().push(line.unwrap()); } let g = File::open(create_path(new_lang.to_string()))?; let g = BufReader::new(g); for line in g.lines() { DEST_VEC.lock().unwrap().push(line.unwrap()); } Ok(()) } ///Disable the translation <br/> /// [rtr](./fn.rtr.html) will returns the argument /// /// # Examples /// /// disable() is mostly useful for error handling /// ``` /// extern crate rtr; /// use rtr::rtr; /// /// match rtr::init("fr") { /// Ok(_) => (), /// Err(e) => { /// println!("couldn't load fr translation file"); /// rtr::disable(); /// } /// } /// ``` /// /// use [enable](./fn.enable.html) to enable it again pub fn disable() { &STATE.lock().unwrap().store(false, Ordering::Relaxed); } ///Enable the translation<br/> ///[rtr](./fn.rtr.html) will now try to read strings from the translation file <br/> ///*_The translation then need to be loaded with [init](./fn.init.html)!_*<br/> ///Only useful after using [disable](./fn.disable.html) pub fn enable() { &STATE.lock().unwrap().store(true, Ordering::Relaxed); } ///Return the state of the translation<br/> ///If *false* [rtr](./fn.rtr.html) will return the argument<br/> ///If *true* [rtr](./fn.rtr.html) will act normaly<br/> ///True by default /// # Examples /// ``` ///extern crate rtr; ///use rtr::rtr; ///rtr::init("fr").unwrap(); /// ///assert_eq!(rtr::is_enable(), true); /// //assuming that "hello" correspond to "bonjour" in the fr.txt file ///assert_eq!(rtr("hello"), "bonjour".to_string()); /// ///rtr::disable(); ///assert_eq!(rtr("hello"), "hello".to_string()); pub fn is_enable() -> bool{ return STATE.lock().unwrap().load(Ordering::Relaxed); } ///Use with every str that you need to translate /// # Examples /// /// ``` /// extern crate rtr; /// use rtr::rtr; /// /// rtr::init("fr"); /// println!("{}", rtr("hello world")); /// ``` /// Will return the sentence that correspond to "hello world" in the ./lang/fr.txt file pub fn rtr(text: &str) -> String { if &STATE.lock().unwrap().load(Ordering::Relaxed) == &true { match ORIGIN_VEC.lock().unwrap().binary_search(&text.to_string()) { Ok(index) => { return DEST_VEC.lock().unwrap()[index].clone(); } Err(_) => return text.to_string(), } } else { return text.to_string(); } }