naia_shared/messages/
message_container.rs

1use std::{any::Any, collections::HashSet};
2
3use naia_serde::BitWrite;
4
5use crate::{
6    world::entity::{
7        entity_converters::LocalEntityAndGlobalEntityConverterMut, local_entity::RemoteEntity,
8    },
9    LocalEntityAndGlobalEntityConverter, Message, MessageKind, MessageKinds,
10};
11
12#[derive(Clone)]
13pub struct MessageContainer {
14    inner: Box<dyn Message>,
15    bit_length: Option<u32>,
16}
17
18impl MessageContainer {
19    pub fn from_write(
20        message: Box<dyn Message>,
21        converter: &mut dyn LocalEntityAndGlobalEntityConverterMut,
22    ) -> Self {
23        let bit_length = message.bit_length(converter);
24        Self {
25            inner: message,
26            bit_length: Some(bit_length),
27        }
28    }
29
30    pub fn from_read(message: Box<dyn Message>) -> Self {
31        Self {
32            inner: message,
33            bit_length: None,
34        }
35    }
36
37    pub fn name(&self) -> String {
38        self.inner.name()
39    }
40
41    pub fn bit_length(&self) -> u32 {
42        self.bit_length.expect("bit_length should never be called on a MessageContainer that was created from a read operation")
43    }
44
45    pub fn write(
46        &self,
47        message_kinds: &MessageKinds,
48        writer: &mut dyn BitWrite,
49        converter: &mut dyn LocalEntityAndGlobalEntityConverterMut,
50    ) {
51        if writer.is_counter() {
52            writer.count_bits(self.bit_length());
53        } else {
54            self.inner.write(message_kinds, writer, converter);
55        }
56    }
57
58    pub fn is_fragment(&self) -> bool {
59        return self.inner.is_fragment();
60    }
61
62    pub fn is_request_or_response(&self) -> bool {
63        return self.inner.is_request();
64    }
65
66    pub fn to_boxed_any(self) -> Box<dyn Any> {
67        return self.inner.to_boxed_any();
68    }
69
70    pub fn kind(&self) -> MessageKind {
71        return self.inner.kind();
72    }
73
74    pub fn relations_waiting(&self) -> Option<HashSet<RemoteEntity>> {
75        return self.inner.relations_waiting();
76    }
77
78    pub fn relations_complete(&mut self, converter: &dyn LocalEntityAndGlobalEntityConverter) {
79        self.inner.relations_complete(converter);
80    }
81}