north-config 0.0.1

North config is a multi source configuration crate designed as part of the North Microservice Framework
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

use std::fmt::{Display};

/// # Error
///
/// Custom error for north config
#[derive(Debug)]
pub enum Error {
    IoError(std::io::Error),
    JsonParseError(serde_json::Error),
    #[cfg(feature = "ron")]
    RonParseError(ron::Error),
    #[cfg(feature = "yaml")]
    YamlParseError(serde_yaml::Error),
    #[cfg(feature = "toml")]
    TomlParseError(toml::de::Error),
}

impl Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::IoError(io_error) =>
                write!(f, "{}", io_error),
            Error::JsonParseError(io_error) =>
                write!(f, "{}", io_error),
            #[cfg(feature = "ron")]
            Error::RonParseError(error) =>
                write!(f, "{}", error),
            #[cfg(feature = "yaml")]
            Error::YamlParseError(error) =>
                write!(f, "{}", error),
            #[cfg(feature = "toml")]
            Error::TomlParseError(error) =>
                write!(f, "{}", error),
        }
    }
}

impl std::error::Error for Error {}

impl From<serde_json::Error> for Error {
    fn from(e: serde_json::Error) -> Self {
        Error::JsonParseError(e)
    }
}

#[cfg(feature = "ron")]
impl From<ron::Error> for Error {
    fn from(e: ron::Error) -> Self {
        Error::RonParseError(e)
    }
}

#[cfg(feature = "yaml")]
impl From<serde_yaml::Error> for Error {
    fn from(e: serde_yaml::Error) -> Self {
        Error::YamlParseError(e)
    }
}

#[cfg(feature = "toml")]
impl From<toml::de::Error> for Error {
    fn from(e: toml::de::Error) -> Self {
        Error::TomlParseError(e)
    }
}

impl From<std::io::Error> for Error {
    fn from(e: std::io::Error) -> Self {
        Error::IoError(e)
    }
}