cat-dev 0.0.13

A library for interacting with the CAT-DEV hardware units distributed by Nintendo (i.e. a type of Wii-U DevKits).
Documentation 
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

//! A unique identifier for a specific 'live' connection, or TCP Stream.
//!
//! On UDP this will still have a pretty strong guarantee of being unique.
//! Still a lot less guarantees can be made, but the hope it is still decently
//! unique.

use crate::{
	errors::CatBridgeError,
	net::models::{FromRequest, FromRequestParts, Request, Response},
};
use std::{
	convert::Infallible,
	fmt::{Display, Formatter, Result as FmtResult},
	ops::Deref,
};
use tower::{Layer, Service};
use tracing::{
	Id as TracingId, error_span,
	instrument::{Instrument, Instrumented},
};
use valuable::Valuable;

/// A unique identifier for a particular TCP Stream, or connection.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Valuable)]
pub struct StreamID(u64);

impl StreamID {
	#[must_use]
	pub const fn from_existing(id: u64) -> Self {
		Self(id)
	}

	/// Convert this stream id to a raw value.
	#[must_use]
	pub fn to_raw(&self) -> u64 {
		self.0
	}
}

impl Display for StreamID {
	fn fmt(&self, fmt: &mut Formatter<'_>) -> FmtResult {
		write!(fmt, "{}", self.0)
	}
}

impl Deref for StreamID {
	type Target = u64;

	fn deref(&self) -> &Self::Target {
		&self.0
	}
}

impl<State: Clone + Send + Sync + 'static> FromRequestParts<State> for StreamID {
	async fn from_request_parts(parts: &mut Request<State>) -> Result<Self, CatBridgeError> {
		Ok(Self::from_existing(parts.stream_id()))
	}
}

impl<State: Clone + Send + Sync + 'static> FromRequest<State> for StreamID {
	async fn from_request(req: Request<State>) -> Result<Self, CatBridgeError> {
		Ok(Self::from_existing(req.stream_id()))
	}
}

#[derive(Clone, Debug)]
pub struct StreamIDLayer;

impl<Layered> Layer<Layered> for StreamIDLayer
where
	Layered: Clone,
{
	type Service = LayeredStreamID<Layered>;

	fn layer(&self, inner: Layered) -> Self::Service {
		LayeredStreamID { inner }
	}
}

#[derive(Clone)]
pub struct LayeredStreamID<Layered> {
	inner: Layered,
}

impl<Layered, State: Clone + Send + Sync + 'static> Service<Request<State>>
	for LayeredStreamID<Layered>
where
	Layered:
		Service<Request<State>, Response = Response, Error = Infallible> + Clone + Send + 'static,
	Layered::Future: Send + 'static,
{
	type Response = Layered::Response;
	type Error = Layered::Error;
	type Future = Instrumented<Layered::Future>;

	#[inline]
	fn poll_ready(
		&mut self,
		ctx: &mut std::task::Context<'_>,
	) -> std::task::Poll<Result<(), Self::Error>> {
		self.inner.poll_ready(ctx)
	}

	fn call(&mut self, mut req: Request<State>) -> Self::Future {
		let parent_span = req
			.extensions()
			.get::<Option<TracingId>>()
			.cloned()
			.unwrap_or(None);
		let stream_id = StreamID::from_existing(req.stream_id());

		let span = error_span!(
		  parent: parent_span,
		  "WithStreamID",
		  request.stream_id = %stream_id,
		);
		req.extensions_mut().insert::<StreamID>(stream_id);
		req.extensions_mut().insert::<Option<TracingId>>(span.id());
		self.inner.call(req).instrument(span.or_current())
	}
}