ble-peripheral-rust 0.2.0

A cross-platform Rust crate for building Bluetooth Low Energy peripherals
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use std::{error, fmt};

#[derive(Debug, Clone)]
pub enum ErrorType {
    Bluez,
    CoreBluetooth,
    Windows,
    PermissionDenied,
    ChannelError,
}

impl From<ErrorType> for &'static str {
    fn from(error_type: ErrorType) -> &'static str {
        match error_type {
            ErrorType::Bluez => "Bluez",
            ErrorType::CoreBluetooth => "CoreBluetooth",
            ErrorType::Windows => "Windows",
            ErrorType::PermissionDenied => "PermissionDenied",
            ErrorType::ChannelError => "ChannelError",
        }
    }
}

impl fmt::Display for ErrorType {
    fn fmt(self: &Self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_type: &str = self.clone().into();
        write!(f, "<BlePeripheralRust {} Error>", error_type)
    }
}

impl error::Error for ErrorType {}

#[derive(Debug, Clone)]
pub struct Error {
    name: String,
    description: String,
    combined_description: String,
    error_type: ErrorType,
}

impl Error {
    pub fn new<T: Into<String>>(name: T, description: T, error_type: ErrorType) -> Self {
        let name: String = name.into();
        let description: String = description.into();
        let combined_description = format!("{}: {}", name, description);
        Error {
            name,
            description,
            combined_description,
            error_type,
        }
    }

    pub fn from_type(error_type: ErrorType) -> Self {
        let name: String = error_type.to_string();
        let description: String = error_type.to_string();
        let combined_description = format!("{}: {}", name, description);
        Error {
            name,
            description,
            combined_description,
            error_type,
        }
    }

    pub fn from_string(error: String, error_type: ErrorType) -> Self {
        let name: String = error_type.to_string();
        let description: String = error;
        let combined_description = format!("{}: {}", name, description);
        Error {
            name,
            description,
            combined_description,
            error_type,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(self: &Self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_type: &str = self.error_type.clone().into();
        write!(
            f,
            "**BlePeripheralRust {} Error**\n\n\t{}:\n\t\t{}",
            error_type, self.name, self.description,
        )
    }
}

impl error::Error for Error {
    fn description(self: &Self) -> &str {
        &self.combined_description
    }

    fn source(self: &Self) -> Option<&(dyn error::Error + 'static)> {
        Some(&self.error_type)
    }
}