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
118
119
120
121
122
123
124
125
126
127

use super::{Stream, Streamer};
use super::message::MessageData;
use super::error::UnrecoverableError;
use super::streamer::RawStreamer;

use std::mem::ManuallyDrop;

use fire::Data;

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


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 mut Option<S>,
	streamer: &'a mut Option<Streamer<S::Message>>
) -> &'a T
where
	T: Any,
	S: Stream + 'static
{
	if is_req::<T, S>() {
		let req = req.as_ref().unwrap();
		<dyn Any>::downcast_ref(req).unwrap()
	} else if is_streamer::<T, S>() {
		let streamer = streamer.as_ref().unwrap();
		<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: &mut Option<S>,
	streamer: &mut Option<Streamer<S::Message>>
) -> T
where
	T: Any,
	S: Stream + 'static
{
	if is_req::<T, S>() {
		let req = req.take().unwrap();
		unsafe {
			transform_owned::<T, S>(req)
		}
	} else if is_streamer::<T, S>() {
		let streamer = streamer.take().unwrap();
		unsafe {
			transform_owned::<T, Streamer<S::Message>>(streamer)
		}
	} else {
		unreachable!()
	}
}

/// Safety you need to know that T is `WebSocket`
unsafe fn transform_owned<T: Any + Sized, R: Any>(from: R) -> T {
	let mut from = ManuallyDrop::new(from);
	(&mut from as *mut ManuallyDrop<R> as *mut T).read()
}

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())
		}
	}
}