mxp 1.2.0

Rust implementation of the MXP (Mud eXtension Protocol) standard
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

use std::num::ParseIntError;
use std::str::FromStr;

use crate::color::RgbColor;
use crate::parse::UnrecognizedVariant;
use crate::{Error, ErrorKind};

pub(crate) trait ExpectArg {
    type Arg;

    fn expect_color(self) -> crate::Result<Option<RgbColor>>
    where
        Self::Arg: AsRef<str>;

    fn expect_some(self, name: &str) -> crate::Result<Self::Arg>;

    fn expect_number<T>(self) -> crate::Result<Option<T>>
    where
        Self::Arg: AsRef<str>,
        T: FromStr<Err = ParseIntError>;

    fn expect_variant<T>(self) -> crate::Result<Option<T>>
    where
        Self::Arg: AsRef<str>,
        T: FromStr<Err = UnrecognizedVariant<T>>;
}

impl<S> ExpectArg for Option<S> {
    type Arg = S;

    fn expect_color(self) -> crate::Result<Option<RgbColor>>
    where
        Self::Arg: AsRef<str>,
    {
        let Some(arg) = self else {
            return Ok(None);
        };
        let arg = arg.as_ref();
        if arg.is_empty() {
            return Ok(None);
        }
        match RgbColor::named(arg) {
            Some(color) => Ok(Some(color)),
            None => Err(Error::new(arg, ErrorKind::UnknownColor)),
        }
    }

    fn expect_some(self, name: &str) -> crate::Result<Self::Arg> {
        match self {
            Some(arg) => Ok(arg),
            None => Err(Error::new(name, ErrorKind::MissingArguments)),
        }
    }

    fn expect_number<T>(self) -> crate::Result<Option<T>>
    where
        Self::Arg: AsRef<str>,
        T: FromStr<Err = ParseIntError>,
    {
        let Some(arg) = self else {
            return Ok(None);
        };
        let arg = arg.as_ref();
        if arg.is_empty() {
            return Ok(None);
        }
        match arg.parse() {
            Ok(parsed) => Ok(Some(parsed)),
            Err(_) => Err(Error::new(arg, ErrorKind::InvalidNumber)),
        }
    }

    fn expect_variant<T>(self) -> crate::Result<Option<T>>
    where
        Self::Arg: AsRef<str>,
        T: FromStr<Err = UnrecognizedVariant<T>>,
    {
        let Some(arg) = self else {
            return Ok(None);
        };
        let arg = arg.as_ref();
        if arg.is_empty() {
            return Ok(None);
        }
        match arg.parse() {
            Ok(parsed) => Ok(Some(parsed)),
            Err(_) => Err(Error::new(arg, ErrorKind::UnexpectedArgument)),
        }
    }
}