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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use super::error::UnrecoverableError;
use super::message::MessageData;
use super::streamer::RawStreamer;
use super::{Stream, Streamer};
use crate::util::{transform_owned, DataManager};

use fire::Data;

use std::any::{Any, TypeId};

fn is_req<T: Any, R: Any>() -> bool {
	TypeId::of::<T>() == TypeId::of::<R>()
}

fn is_streamer<T: Any, R: Stream>() -> bool
where
	R::Message: 'static,
{
	TypeId::of::<T>() == TypeId::of::<Streamer<R::Message>>()
}

fn is_data<T: Any>() -> bool {
	TypeId::of::<T>() == TypeId::of::<Data>()
}

/// fn to check if a type can be accessed in a websocket handler as reference
#[inline]
pub fn valid_stream_data_as_ref<T, S>(data: &Data) -> bool
where
	T: Any,
	S: Stream + 'static,
{
	is_req::<T, S>()
		|| is_streamer::<T, S>()
		|| is_data::<T>()
		|| data.exists::<T>()
}

/// fn to check if a type can be accessed in a websocket handler as owned
#[inline]
pub fn valid_stream_data_as_owned<T, S>(_: &Data) -> bool
where
	T: Any,
	S: Stream + 'static,
{
	is_req::<T, S>() || is_streamer::<T, S>()
}

#[inline]
pub fn get_stream_data_as_ref<'a, T, S>(
	data: &'a Data,
	req: &'a DataManager<S>,
	streamer: &'a DataManager<Streamer<S::Message>>,
) -> &'a T
where
	T: Any,
	S: Stream + 'static,
{
	if is_req::<T, S>() {
		let req = req.as_ref();
		<dyn Any>::downcast_ref(req).unwrap()
	} else if is_streamer::<T, S>() {
		let streamer = streamer.as_ref();
		<dyn Any>::downcast_ref(streamer).unwrap()
	} else if is_data::<T>() {
		<dyn Any>::downcast_ref(data).unwrap()
	} else {
		data.get::<T>().unwrap()
	}
}

#[inline]
pub fn get_stream_data_as_owned<T, S>(
	_data: &Data,
	req: &DataManager<S>,
	streamer: &DataManager<Streamer<S::Message>>,
) -> T
where
	T: Any,
	S: Stream + 'static,
{
	if is_req::<T, S>() {
		let req = req.take();
		unsafe { transform_owned::<T, S>(req) }
	} else if is_streamer::<T, S>() {
		let streamer = streamer.take();
		unsafe { transform_owned::<T, Streamer<S::Message>>(streamer) }
	} else {
		unreachable!()
	}
}

pub fn deserialize_req<S: Stream>(
	msg: MessageData,
) -> Result<S, UnrecoverableError> {
	msg.deserialize()
		.map_err(|e| format!("failed to deserialize stream request {e}").into())
}

#[inline]
pub fn transform_streamer<S: Stream>(
	streamer: RawStreamer,
) -> Streamer<S::Message> {
	streamer.assign_message()
}

pub fn error_to_data<S: Stream>(
	r: Result<(), S::Error>,
) -> Result<MessageData, UnrecoverableError> {
	match r {
		Ok(_) => Ok(MessageData::null()),
		Err(e) => {
			// try to convert the error into a message
			MessageData::serialize(e).map_err(|e| e.to_string().into())
		}
	}
}