nardol 0.0.3

Simple framework that provides structure to data sent and received from network.
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

use serde::{Deserialize, Serialize};

use std::fmt::Display;

use crate::Packet;
use crate::bytes::Bytes;
use crate::error::Error;
use crate::message::{ContentType, MetaDataType};
use crate::ron::{FromRon, ToRon};

use super::message::{Context, Output};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Content(String);

impl Default for Content {
    fn default() -> Self {
        Self::empty()
    }
}

impl FromRon<'_> for Content {}
impl ToRon for Content {}

impl Display for Content {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Content({})", self.string_ref())
    }
}

impl TryFrom<Bytes> for Content {
    type Error = Error;

    fn try_from(value: Bytes) -> Result<Self, Self::Error> {
        todo!()
    }
}

impl TryFrom<Content> for Bytes {
    type Error = Error;

    fn try_from(value: Content) -> Result<Self, Self::Error> {
        todo!()
    }
}

impl<'a, M> ContentType<'a, M, Content> for Content
where
    M: MetaDataType<'a, M, Content>,
{
    type SendContext = Context;
    type ReceiveContext = Context;
    type SendOutput = Output;
    type ReceiveOutput = Output;

    fn send(
        self,
        stream: &mut std::net::TcpStream,
        context: Option<Self::SendContext>,
    ) -> Result<Option<Self::SendOutput>, Error> {
        todo!()
    }

    fn receive(
        stream: &mut std::net::TcpStream,
        metadata: &M,
        context: Option<Self::ReceiveContext>,
    ) -> Result<
        (
            Self,
            Packet,
            Option<<Content as ContentType<'a, M, Content>>::ReceiveOutput>,
        ),
        Error,
    > {
        todo!()
    }
}

impl Content {
    pub fn new(data: String) -> Self {
        Content(data)
    }

    pub fn empty() -> Self {
        Content(String::new())
    }

    pub fn string_ref(&self) -> &String {
        &self.0
    }
}