adtp 0.1.1

Alula's Data Transfer Protocol
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use serde::{Deserialize, Serialize};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        println!("{}", Request::create(Method::Read).with_content_string("Hello World".to_string(), ContentType::Text).build());
        println!("{}", Response::create(ResponseCode::Ok).with_content_string("Hello World".to_string(), ContentType::Text).build());
        panic!();
    }    
}

#[derive(Debug,Clone, Serialize, Deserialize)]
pub enum Method {
    /// Used to read existing data
    Read,
    /// Used to create new data
    Insert,
    /// Used to update existing data
    Set,
    /// Used to delete existing data
    Remove,
    /// Used to check if data exists
    Check
}

#[derive(Debug,Clone, Serialize, Deserialize)]
pub enum ContentType {
    Text, // Text in UTF-8
    Binary, // Raw 1s and 0s
    None
}

#[derive(Debug,Clone, Serialize, Deserialize)]
pub struct Request {
    version: i32,
    pub method: Method,
    pub content_type: ContentType,
    pub content: Vec<u8>,
}
impl Request {
    pub fn create(method: Method) -> Request {
        Request {
            version: 1,
            method,
            content_type: ContentType::None,
            content: vec![],
        }
    }
    
    pub fn with_content(mut self, content: Vec<u8>, content_type: ContentType) -> Request {
        self.content = content;
        self.content_type = content_type;
        self
    }
    
    pub fn with_content_string(mut self, content: String, content_type: ContentType) -> Request {
        self.content = content.into_bytes();
        self.content_type = content_type;
        self
    }
    
    pub fn build(self) -> String {
        serde_json::to_string(&self).unwrap()
    }
}
impl From<String> for Request {
    fn from(value: String) -> Self {
        serde_json::from_str(&value).unwrap()
    }
}
impl From<Vec<u8>> for Request {
    fn from(value: Vec<u8>) -> Self {
        serde_json::from_str(&String::from_utf8(value).unwrap()).unwrap()
    }
}

#[derive(Debug,Clone, Serialize, Deserialize)]
pub enum ResponseCode {
    SwitchProtocols, // Server is switching protocol. Check content for protocol type
    Ok, // Server has acknowledged your request.
    Pending, // Request is pending. Wait for follow up.
    Redirect, // Content is no longer at requested location. Check content for new location.
    Denied, // Server has denied request.
    BadRequest, // Request is malformed.
    Unauthorized, // You are not authorized to view the content
    NotFound, // Server could not find the requested content.
    TooManyRequests, // Server has received too many requests from this client
    InternalServerError, // Server has encountered an error
}

#[derive(Debug,Clone, Serialize, Deserialize)]
pub struct Response {
    version: i32,
    pub code: ResponseCode,
    pub content_type: ContentType,
    pub content: Vec<u8>,
}
impl Response {
    pub fn create(code: ResponseCode) -> Response {
        Response {
            version: 1,
            code,
            content_type: ContentType::None,
            content: vec![],
        }
    }
    
    pub fn with_content(mut self, content: Vec<u8>, content_type: ContentType) -> Response {
        self.content = content;
        self.content_type = content_type;
        self
    }
    
    pub fn with_content_string(mut self, content: String, content_type: ContentType) -> Response {
        self.content = content.into_bytes();
        self.content_type = content_type;
        self
    }
    
    pub fn build(self) -> String {
        serde_json::to_string(&self).unwrap()
    }
}
impl From<String> for Response {
    fn from(value: String) -> Self {
        serde_json::from_str(&value).unwrap()
    }
}
impl From<Vec<u8>> for Response {
    fn from(value: Vec<u8>) -> Self {
        serde_json::from_str(&String::from_utf8(value).unwrap()).unwrap()
    }
}