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

use crate::serialization::network::{Network as ProtoNetwork, Network_oneof_request};
use crate::traits::{Decode, Encode, Exception, Proto};
use protobuf::{CodedInputStream, Message as ProtoMessage};
use std::error::Error;

pub struct NetworkMessage {
    pub message_type: Network_oneof_request,
}

impl NetworkMessage {
    pub fn new(message_type: Network_oneof_request) -> Self {
        Self { message_type }
    }
}

impl Decode for NetworkMessage {
    fn decode(buffer: &[u8]) -> Result<Self, Box<Error>> {
        let mut message: ProtoNetwork = ProtoNetwork::new();
        if let Err(_) = message.merge_from(&mut CodedInputStream::from_bytes(buffer)) {
            // return Err(Box::new(Exception::new("Decoding fail")));
        }
        if let Some(message_type) = message.request {
            return Ok(Self { message_type });
        }
        Err(Box::new(Exception::new("Decode Failed")))
    }
}

impl Encode for NetworkMessage {
    fn encode(&self) -> Result<Vec<u8>, Box<Error>> {
        let proto_message = self.to_proto()?;
        Ok(proto_message.write_to_bytes()?)
    }
}

impl Proto for NetworkMessage {
    type ProtoType = ProtoNetwork;
    fn to_proto(&self) -> Result<Self::ProtoType, Box<Error>> {
        let mut proto_message = Self::ProtoType::new();
        match self.message_type.clone() {
            Network_oneof_request::status(v) => {
                proto_message.set_status(v);
            }
            Network_oneof_request::statusReturn(v) => {
                proto_message.set_statusReturn(v);
            }
            Network_oneof_request::getPeersReturn(p) => {
                proto_message.set_getPeersReturn(p);
            }
            Network_oneof_request::getTipReturn(t) => {
                proto_message.set_getTipReturn(t);
            }
            Network_oneof_request::getPeers(n) => {
                proto_message.set_getPeers(n);
            }
            Network_oneof_request::putTxReturn(t) => {
                proto_message.set_putTxReturn(t);
            }
            Network_oneof_request::putBlockReturn(b) => {
                proto_message.set_putBlockReturn(b);
            }
            Network_oneof_request::getTip(t) => {
                proto_message.set_getTip(t);
            }
            Network_oneof_request::getHash(h) => {
                proto_message.set_getHash(h);
            }
            Network_oneof_request::getHeadersByRange(r) => {
                proto_message.set_getHeadersByRange(r);
            }
            _ => {}
        }
        Ok(proto_message)
    }

    fn from_proto(prototype: &ProtoNetwork) -> Result<Self, Box<Error>> {
        if let Some(message) = &prototype.request {
            Ok(Self {
                message_type: message.clone(),
            })
        } else {
            Err(Box::new(Exception::new("No Message")))
        }
    }
}
#[derive(Clone)]
pub struct NetworkManager {}

impl NetworkManager {
    pub fn decode(bytes: &Vec<u8>) -> Result<NetworkMessage, Box<Error>> {
        NetworkMessage::decode(bytes)
    }
}