webgestalt_lib 0.3.2

Library for computing enrichment for different analytes using ORA or GSEA.
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

#![doc = include_str!("../README.md")]
use std::{error::Error, fmt};

pub mod methods;
pub mod readers;
pub mod stat;
pub mod writers;
trait CustomError {
    fn msg(&self) -> String;
}

#[derive(Debug)]
pub enum WebGestaltError {
    MalformedFile(MalformedError),
    StatisticsError(StatisticsError),
    IOError(std::io::Error),
}

impl Error for WebGestaltError {}

impl fmt::Display for WebGestaltError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let msg: String = match &self {
            WebGestaltError::MalformedFile(x) => x.msg(),
            WebGestaltError::StatisticsError(x) => x.msg(),
            WebGestaltError::IOError(x) => x.to_string(),
        };
        write!(f, "{}", msg)
    }
}

#[derive(Debug)]
pub struct MalformedError {
    pub path: String,
    pub kind: MalformedErrorType,
}

#[derive(Debug)]
pub enum MalformedErrorType {
    NoColumnsFound { delimeter: String },
    WrongFormat { found: String, expected: String },
    Unknown,
}

impl CustomError for MalformedError {
    fn msg(&self) -> String {
        let error_msg = match &self.kind {
            MalformedErrorType::WrongFormat { found, expected } => format!(
                "Wrong Format Found. Found: {}; Expected: {}",
                found, expected
            ),
            MalformedErrorType::Unknown => String::from("Unknown error type."),
            MalformedErrorType::NoColumnsFound { delimeter } => format!(
                "No column found with delimeter {}",
                if delimeter == "\t" { "\\t" } else { delimeter }
            ),
        };
        format!("Error in {}: {}.", self.path, error_msg)
    }
}

#[derive(Debug)]
pub enum StatisticsError {
    FoundNANValue,
    InvalidValue { value: f64 },
}

impl CustomError for StatisticsError {
    fn msg(&self) -> String {
        let error_msg = match &self {
            StatisticsError::FoundNANValue => String::from("Found a NAN value"),
            StatisticsError::InvalidValue { value } => format!("Found invalid value: {}", value),
        };
        format!("Statstical Error: {}.", error_msg)
    }
}