kvsd 0.1.3

Simple key value store
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

use std::fmt;

use crate::common::Result;
use crate::protocol::message::{MessageFrames, MessageType, Parse};

const UNDEFINED: &str = "UNDEFINED";
const UNAUTHENTICATED: &str = "UNAUTHENTICATED";
const UNEXPECTED_MESSAGE: &str = "UNEXPECTED_MESSAGE";

#[derive(Debug, Copy, Clone, PartialEq)]
pub(crate) enum FailCode {
    Undefined,
    Unauthenticated,
    UnexpectedMessage,
}

impl fmt::Display for FailCode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{}",
            match self {
                FailCode::Undefined => UNDEFINED,
                FailCode::Unauthenticated => UNAUTHENTICATED,
                FailCode::UnexpectedMessage => UNEXPECTED_MESSAGE,
            }
        )
    }
}

impl From<String> for FailCode {
    fn from(s: String) -> Self {
        match s.as_str() {
            UNAUTHENTICATED => FailCode::Unauthenticated,
            UNEXPECTED_MESSAGE => FailCode::UnexpectedMessage,
            _ => FailCode::Undefined,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct Fail {
    code: FailCode,
    message: String,
}

impl Fail {
    pub(crate) fn new(code: FailCode) -> Self {
        Self {
            code,
            message: "".into(),
        }
    }

    pub(crate) fn with_message(mut self, message: impl Into<String>) -> Self {
        self.message = message.into();
        self
    }

    pub(crate) fn parse_frames(parse: &mut Parse) -> Result<Self> {
        let code = parse.next_string()?;
        let message = parse.next_string()?;

        Ok(Fail::new(FailCode::from(code)).with_message(message))
    }
}
impl From<Fail> for MessageFrames {
    fn from(fail: Fail) -> Self {
        let mut frames = MessageFrames::with_capacity(MessageType::Fail, 1);

        frames.push_string(fail.code.to_string());
        frames.push_string(fail.message);

        frames
    }
}

impl From<FailCode> for Fail {
    fn from(code: FailCode) -> Self {
        Fail::new(code)
    }
}