dbus-server-address-parser 1.0.1

Library to encode and decode DBus server address
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
99
100
101
102
103
104
105
106
107
108
109
110

use super::{
    unescape::{unescape, UnescapeError},
    GuidError,
};
use crate::{Unix, UnixType};
use std::convert::TryFrom;
use thiserror::Error;

use super::guid::decode_guid;

#[derive(Error, Debug, Clone)]
pub enum UnixError {
    #[error("Could not unescape: {0}")]
    UnescapeError(#[from] UnescapeError),
    #[error("GUID error: {0}")]
    GuidError(#[from] GuidError),
    #[error("Unknown key")]
    UnknownKey,
    #[error("Unknown runtime")]
    UnknownRuntime,
    #[error("Type is duplicate")]
    TypeDuplicate,
    #[error("Type is missing")]
    TypeMissing,
}

impl Unix {
    fn decode_type(type_str: &str, r#type: &mut Option<UnixType>) -> Result<(), UnixError> {
        if r#type.is_none() {
            *r#type = Some(UnixType::try_from(type_str)?);
            Ok(())
        } else {
            Err(UnixError::TypeDuplicate)
        }
    }
}

impl TryFrom<&str> for Unix {
    type Error = UnixError;

    fn try_from(server_address: &str) -> Result<Self, Self::Error> {
        let mut r#type = None;
        let mut guid = None;

        for key_value in server_address.split(',') {
            if let Some(guid_str) = key_value.strip_prefix("guid=") {
                decode_guid(guid_str, &mut guid)?;
            } else {
                Unix::decode_type(key_value, &mut r#type)?;
            }
        }

        if let Some(r#type) = r#type {
            Ok(Unix { r#type, guid })
        } else {
            Err(UnixError::TypeMissing)
        }
    }
}

impl UnixType {
    fn decode_path(path: &str) -> Result<UnixType, UnixError> {
        let path = UnixType::Path(unescape(path)?);
        Ok(path)
    }

    fn decode_dir(dir: &str) -> Result<UnixType, UnixError> {
        let dir = UnixType::Dir(unescape(dir)?);
        Ok(dir)
    }

    fn decode_tmpdir(tmpdir: &str) -> Result<UnixType, UnixError> {
        let tmpdir = UnixType::Tmpdir(unescape(tmpdir)?);
        Ok(tmpdir)
    }

    fn decode_abstract(abstract_: &str) -> Result<UnixType, UnixError> {
        let abstract_ = UnixType::Abstract(unescape(abstract_)?);
        Ok(abstract_)
    }

    fn decode_runtime(runtime: &str) -> Result<UnixType, UnixError> {
        let runtime = unescape(runtime)?;
        if &runtime == "yes" {
            Ok(UnixType::Runtime)
        } else {
            Err(UnixError::UnknownRuntime)
        }
    }
}

impl TryFrom<&str> for UnixType {
    type Error = UnixError;

    fn try_from(server_address: &str) -> Result<Self, Self::Error> {
        if let Some(path) = server_address.strip_prefix("path=") {
            UnixType::decode_path(path)
        } else if let Some(dir) = server_address.strip_prefix("dir=") {
            UnixType::decode_dir(dir)
        } else if let Some(tmpdir) = server_address.strip_prefix("tmpdir=") {
            UnixType::decode_tmpdir(tmpdir)
        } else if let Some(abstract_) = server_address.strip_prefix("abstract=") {
            UnixType::decode_abstract(abstract_)
        } else if let Some(runtime) = server_address.strip_prefix("runtime=") {
            UnixType::decode_runtime(runtime)
        } else {
            Err(UnixError::UnknownKey)
        }
    }
}