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

use serde::{Deserialize, Serialize};

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 MetaData {}

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

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

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

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

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

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

impl<'a, C> MetaDataType<'a, MetaData, C> for MetaData
where
    C: ContentType<'a, MetaData, C>,
{
    type SendContext = Context;
    type ReceiveContext = Context;

    fn send(
        self,
        stream: &mut std::net::TcpStream,
        context: Option<Self::SendContext>,
    ) -> Result<Option<<C as ContentType<'a, MetaData, C>>::SendContext>, Error> {
        todo!()
    }

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

impl MetaData {
    pub fn new() -> Self {
        Self {}
    }

    pub fn empty() -> Self {
        Self {}
    }
}