smalltalk 0.3.0

Utilities for speeding up development of simple networked applications
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 std::{fmt::Debug, net::SocketAddr, ops::{Deref, DerefMut}};

use serde::{de::DeserializeOwned, Serialize};
use tokio::net::TcpStream;

use crate::socket::interface::SocketUtils;

pub mod error {
    use std::fmt::Debug;

    #[derive(Debug, thiserror::Error)]
    #[error("Failed to connect!\n{err}")]
    pub struct ConnectError {
        #[from]
        #[source]
        err: std::io::Error,
    }
}


/// A basic interface to represent a client,
/// with methods for sending and reiving normal rust types
pub struct Client<H, M, O>
where
    H: crate::header::IsHeader,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    sock_interface: SocketUtils<H, M, O>
}

impl<H, M, O> Client<H, M, O>
where
    H: crate::header::IsHeader + Clone + Debug,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    /// Creates a new [`Client`], connecting to `addr`
    ///
    /// # Args
    /// `bincode_opts` is used for serializing and deserializing messages, see [`Options`] for more info
    ///
    /// [`Options`]: bincode::Options
    pub async fn connect(addr: SocketAddr, bincode_opts: O) -> Result<Self, error::ConnectError> {
        let (read_half, write_half) =
            crate::socket::split_stream(TcpStream::connect(addr).await?, bincode_opts);
        let sock_interface = SocketUtils::new(read_half, write_half, addr);
        Ok(Self {
            sock_interface,
        })
    }
}

impl<H, M, O> Deref for Client<H, M, O>
where
    H: crate::header::IsHeader + Debug + Clone,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    type Target = SocketUtils<H, M, O>;
    fn deref(&self) -> &Self::Target {
        &self.sock_interface
    }
}

impl<H, M, O> DerefMut for Client<H, M, O>
where
    H: crate::header::IsHeader + Debug + Clone,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.sock_interface
    }
}