wtx 0.28.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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
128
129

use crate::{
  database::Database,
  misc::{Either, Encode},
};

/// Any element that has a corresponding database type.
pub trait Typed<D>
where
  D: Database,
{
  /// Type that is only known at runtime.
  fn runtime_ty(&self) -> Option<D::Ty>;

  /// Type that is known at compile time.
  fn static_ty() -> Option<D::Ty>
  where
    Self: Sized;
}

impl<D, T> Typed<D> for &T
where
  D: Database,
  T: Typed<D>,
{
  #[inline]
  fn runtime_ty(&self) -> Option<D::Ty> {
    (**self).runtime_ty()
  }

  #[inline]
  fn static_ty() -> Option<D::Ty> {
    T::static_ty()
  }
}

impl<D> Typed<D> for &dyn Typed<D>
where
  D: Database,
{
  #[inline]
  fn runtime_ty(&self) -> Option<D::Ty> {
    (**self).runtime_ty()
  }

  #[inline]
  fn static_ty() -> Option<D::Ty> {
    None
  }
}

impl<D, L, R> Typed<D> for Either<L, R>
where
  D: Database,
  L: Typed<D>,
  R: Typed<D>,
{
  #[inline]
  fn runtime_ty(&self) -> Option<D::Ty> {
    match self {
      Either::Left(elem) => elem.runtime_ty(),
      Either::Right(elem) => elem.runtime_ty(),
    }
  }

  #[inline]
  fn static_ty() -> Option<D::Ty> {
    None
  }
}

impl<D, T> Typed<D> for Option<T>
where
  D: Database,
  T: Typed<D>,
{
  #[inline]
  fn runtime_ty(&self) -> Option<D::Ty> {
    T::static_ty()
  }

  #[inline]
  fn static_ty() -> Option<D::Ty> {
    T::static_ty()
  }
}

/// Marker used for elements that implement both [`Encode`] and [`Typed`].
pub trait TypedEncode<D>: Encode<D> + Typed<D>
where
  D: Database,
{
}

impl<D> Encode<D> for &dyn TypedEncode<D>
where
  D: Database,
{
  #[inline]
  fn encode(&self, aux: &mut D::Aux, ew: &mut D::EncodeWrapper<'_, '_>) -> Result<(), D::Error> {
    (**self).encode(aux, ew)
  }

  #[inline]
  fn is_null(&self) -> bool {
    (**self).is_null()
  }
}

impl<D> Typed<D> for &dyn TypedEncode<D>
where
  D: Database,
{
  #[inline]
  fn runtime_ty(&self) -> Option<D::Ty> {
    (**self).runtime_ty()
  }

  #[inline]
  fn static_ty() -> Option<D::Ty> {
    None
  }
}

impl<D, T> TypedEncode<D> for T
where
  D: Database,
  T: Encode<D> + Typed<D>,
{
}