libtw2_gamenet_ddnet/
traits.rs

1use crate::msg;
2use crate::snap_obj;
3use buffer::CapacityError;
4use libtw2_gamenet_common::error::Error;
5use libtw2_gamenet_common::msg::MessageId;
6use libtw2_gamenet_common::msg::SystemOrGame;
7use libtw2_gamenet_common::traits;
8use libtw2_packer::ExcessData;
9use libtw2_packer::IntUnpacker;
10use libtw2_packer::Packer;
11use libtw2_packer::Unpacker;
12use libtw2_packer::Warning;
13use warn::Warn;
14
15pub struct Protocol(());
16
17impl traits::ProtocolStatic for Protocol {
18    type SnapObj = snap_obj::SnapObj;
19    fn obj_size(type_id: u16) -> Option<u32> {
20        snap_obj::obj_size(type_id)
21    }
22}
23
24impl<'a> traits::Protocol<'a> for Protocol {
25    type Game = msg::Game<'a>;
26    type System = msg::System<'a>;
27}
28
29impl traits::SnapObj for crate::SnapObj {
30    fn decode_obj<W: Warn<ExcessData>>(
31        warn: &mut W,
32        obj_type_id: snap_obj::TypeId,
33        p: &mut IntUnpacker,
34    ) -> Result<Self, Error> {
35        crate::SnapObj::decode_obj(warn, obj_type_id, p)
36    }
37    fn obj_type_id(&self) -> snap_obj::TypeId {
38        self.obj_type_id()
39    }
40    fn encode(&self) -> &[i32] {
41        self.encode()
42    }
43}
44
45impl<'a> traits::Message<'a> for msg::Game<'a> {
46    fn decode_msg<W: Warn<Warning>>(
47        warn: &mut W,
48        id: SystemOrGame<MessageId, MessageId>,
49        p: &mut Unpacker<'a>,
50    ) -> Result<msg::Game<'a>, Error> {
51        if let SystemOrGame::Game(id) = id {
52            msg::Game::decode_msg(warn, id, p)
53        } else {
54            Err(Error::UnknownId)
55        }
56    }
57    fn msg_id(&self) -> SystemOrGame<MessageId, MessageId> {
58        SystemOrGame::Game(self.msg_id())
59    }
60    fn encode_msg<'d, 's>(&self, p: Packer<'d, 's>) -> Result<&'d [u8], CapacityError> {
61        self.encode_msg(p)
62    }
63}
64
65impl<'a> traits::Message<'a> for msg::System<'a> {
66    fn decode_msg<W: Warn<Warning>>(
67        warn: &mut W,
68        id: SystemOrGame<MessageId, MessageId>,
69        p: &mut Unpacker<'a>,
70    ) -> Result<msg::System<'a>, Error> {
71        if let SystemOrGame::System(id) = id {
72            msg::System::decode_msg(warn, id, p)
73        } else {
74            Err(Error::UnknownId)
75        }
76    }
77    fn msg_id(&self) -> SystemOrGame<MessageId, MessageId> {
78        SystemOrGame::System(self.msg_id())
79    }
80    fn encode_msg<'d, 's>(&self, p: Packer<'d, 's>) -> Result<&'d [u8], CapacityError> {
81        self.encode_msg(p)
82    }
83}