large rewrite to make mize run on every platform

src/core/error.rs

@@ -0,0 +1,265 @@
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::format;
+use std::string::FromUtf8Error;
+use std::io;
+use colored::Colorize;
+use log::{trace, debug, info, warn, error};
+
+use crate::proto::MizeMessage;
+
+pub type MizeResult<T> = Result<T, MizeError>;
+
+pub trait MizeResultTrait<T> {
+    fn critical(self) -> T;
+}
+pub trait IntoMizeResult<T, S> {
+    fn mize_result(self) -> MizeResult<T>;
+    fn mize_result_msg(self, msg: S) -> MizeResult<T> where S: std::fmt::Display ;
+}
+
+#[derive(Debug, Clone)]
+pub struct MizeError {
+    pub category: Vec<String>,
+    pub code: u32,
+    pub messages: Vec<String>,
+    pub caused_by_msg: Option<CausedByMessage>,
+    pub code_location: Option<MizeCodeLocation>,
+}
+
+#[derive(Debug, Clone)]
+pub struct CausedByMessage {
+    // peer: &Connection, // TODO: add later
+    msg: Box<MizeMessage>,
+}
+
+#[derive(Debug, Clone)]
+pub struct MizeCodeLocation {
+    file: String,
+    line: u32,
+    column: u32,
+}
+
+impl Display for MizeCodeLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "file: {} line: {} column: {}", self.file, self.line, self.column)
+    }
+}
+
+impl From<&std::panic::Location <'_>> for MizeCodeLocation {
+    fn from(panic_location: &std::panic::Location) -> MizeCodeLocation {
+        let file = panic_location.file().to_string();
+        let line = panic_location.line();
+        let column = panic_location.column();
+        MizeCodeLocation {file, line, column}
+    }
+}
+
+impl MizeError {
+    #[track_caller]
+    pub fn code(code: u32) -> MizeError {
+        let caller_location = std::panic::Location::caller();
+
+        get_error_by_code(code, caller_location)
+    }
+
+    pub fn set_code(mut self, code: u32) -> MizeError {
+        self.code = code;
+        return self;
+    }
+
+    #[track_caller]
+    pub fn new() -> MizeError {
+        let caller_location = std::panic::Location::caller();
+
+        return MizeError {
+            category: Vec::new(),
+            code: 0,
+            messages: Vec::new(),
+            caused_by_msg: None,
+            code_location: Some(caller_location.into()),
+        }
+    }
+
+    pub fn msg<E>(mut self, msg: E) -> MizeError 
+        where E: std::fmt::Display
+    {
+        self.messages.push(format!("{}", msg));
+        return self;
+    }
+
+    pub fn category<T>(mut self, category: T) -> MizeError where T: Into<String> {
+        self.category.push(category.into());
+        return self;
+    }
+    
+    fn send(self) -> MizeError{
+        self
+    }
+
+    fn add_to_err_item(self) -> MizeError {
+        self
+    }
+
+    pub fn log(self) -> MizeError {
+        error!("MizeError encountered: {}", self.messages.join("\n"));
+        self
+    }
+
+    pub fn handle(self) -> MizeError {
+        return self.send().add_to_err_item().log();
+    }
+
+    pub fn critical(self){
+        let mut msg_iter = self.messages.iter();
+        match msg_iter.next() {
+            None => {
+                error!("{} MizeError with code: {}", "CRITICAL".red(), self.code);
+            },
+            Some(msg) => {
+                error!("{} MizeError with code: {} - {}", "CRITICAL".red(), self.code, msg);
+            },
+        }
+        for msg in msg_iter {
+            error!("{} {}", "MSG".red(), msg)
+        }
+        if let Some(location) = self.code_location {
+            error!("{} {}", "LOCATION".red(), location)
+        }
+        if let Some(caused_by_msg) = self.caused_by_msg {
+            error!("{} {:?}", "CAUSED_BY_MESSAGE".red(), caused_by_msg)
+        }
+        panic!();
+    }
+
+}
+
+/*
+pub trait MizeResultExtension<T> {
+    fn extra_msg<E>(self, msg: E) -> Result<T, MizeError>
+        where E: std::fmt::Display
+    ;
+    fn handle(self) -> Result<T, MizeError>;
+
+    fn is_critical(self) -> T;
+}
+
+impl<T> MizeResultExtension<T> for Result<T, MizeError> {
+    fn msg<E>(mut self, msg: E) -> Result<T, MizeError>
+        where E: std::fmt::Display
+    {
+        match self {
+            Err(ref mut e) => {
+                e.msg.push(format!("{}", msg));
+                return self;
+            },
+            Ok(something) => Ok(something),
+        }
+    }
+    fn handle(self) -> Result<T, MizeError> {
+        match self {
+            Err(e) => {
+                Err(e.send().add_to_err_item().write_to_stderr())
+            },
+            Ok(something) => Ok(something)
+        }
+    }
+    fn is_critical(self) -> T {
+        self.expect("Aborting because of a critical Error")
+    }
+}
+*/
+
+/*
+impl From<FromUtf8Error> for MizeError {
+    #[track_caller]
+    fn from(utf_err: FromUtf8Error) -> MizeError{
+        let caller_location = std::panic::Location::caller();
+
+        let mut err = MizeError::code(109).msg(format!("From std::string::FromUtf8Error: {}", utf_err));
+        err.code_location = Some(caller_location.into());
+        return err;
+    }
+}
+*/
+
+impl<E> From<E> for MizeError where E: std::fmt::Display {
+    fn from(e: E) -> MizeError {
+        MizeError::new().msg(format!("From generic Rust error: {}", e))
+    }
+}
+
+impl <T> MizeResultTrait<T> for MizeResult<T> {
+    fn critical(self) -> T {
+        match self {
+            Ok(val) => val,
+            Err(err) => {
+                err.critical();
+                unreachable!()
+            },
+        }
+    }
+}
+
+impl<T, E, S> IntoMizeResult<T, S> for Result<T, E> where E: std::fmt::Display {
+    #[track_caller]
+    fn mize_result(self) -> MizeResult<T> {
+        let caller_location = std::panic::Location::caller();
+
+        match self {
+            Ok(val) => MizeResult::Ok(val),
+            Err(err) => MizeResult::Err(MizeError::new().category("misc").msg(format!("From any Error: {}", err))),
+        }
+    }
+    #[track_caller]
+    fn mize_result_msg(self, msg: S) -> MizeResult<T> where S: std::fmt::Display {
+        let caller_location = std::panic::Location::caller();
+        match self {
+            Ok(val) => MizeResult::Ok(val),
+            Err(err) => MizeResult::Err(MizeError::new().category("misc").msg(format!("{}", msg)).msg(format!("From any Error: {}", err))),
+        }
+    }
+}
+
+/*
+impl<T> IntoMizeResult<T> for io::Result<T> {
+    #[track_caller]
+    fn mize_result(self) -> MizeResult<T> {
+        let caller_location = std::panic::Location::caller();
+
+        match self {
+            Ok(val) => MizeResult::Ok(val),
+            Err(io_err) => MizeResult::Err(MizeError::new().category("io").msg(format!("From an io::Error: {}", io_err))),
+        }
+    }
+    #[track_caller]
+    fn mize_result_msg(self, msg: dyn Into<&str>) -> MizeResult<T> {
+        let caller_location = std::panic::Location::caller();
+        match self {
+            Ok(val) => MizeResult::Ok(val),
+            Err(io_err) => MizeResult::Err(MizeError::new().category("io").msg(msg).msg(format!("From an io::Error: {}", io_err))),
+        }
+    }
+}
+*/
+
+
+fn get_error_by_code(code: u32, caller_location: &std::panic::Location) -> MizeError {
+    let err = MizeError {
+        category: Vec::new(),
+        code: 0,
+        messages: Vec::new(),
+        caused_by_msg: None,
+        code_location: Some(caller_location.into()),
+    };
+
+    match code {
+        109 => err.set_code(109).category("decoding").msg("conversion from utf8 failed"),
+        108 => err.set_code(108).category("decoding").msg("serde deserialisation failed"),
+        _ => err,
+    }
+}
+
+
+