wtx 0.43.1

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

macro_rules! impl_primitive {
  ($instance:expr, [$($elem:ident),+], $ty:ident, $pg_ty:expr) => {
    impl<E> Decode<'_, Mysql<E>> for $ty
    where
      E: From<crate::Error>,
    {
      #[inline]
      fn decode(dw: &mut DecodeWrapper<'_, '_>) -> Result<Self, E> {
        if let &[$($elem,)+] = dw.bytes() {
          return Ok(<Self>::from_le_bytes([$($elem),+]));
        }
        Err(E::from(DatabaseError::UnexpectedBufferSize {
          expected: Usize::from(size_of::<Self>()).into_saturating_u32(),
          received: Usize::from(dw.bytes().len()).into_saturating_u32()
        }.into()))
      }
    }

    impl<E> Encode<Mysql<E>> for $ty
    where
      E: From<crate::Error>,
    {
      #[inline]
      fn encode(&self, ew: &mut EncodeWrapper<'_>) -> Result<(), E> {
        ew.buffer().extend_from_copyable_slice(&self.to_le_bytes()).map_err(Into::into)?;
        Ok(())
      }
    }

    impl<E> Typed<Mysql<E>> for $ty
    where
      E: From<crate::Error>
    {
      #[inline]
      fn runtime_ty(&self) -> Option<TyParams> {
        <Self as Typed<Mysql<E>>>::static_ty()
      }
      #[inline]
      fn static_ty() -> Option<TyParams> {
        Some($pg_ty)
      }
    }
    test!($ty, $ty, $instance);
  }
}

macro_rules! kani {
  ($name:ident, $ty:ty) => {
    #[cfg(kani)]
    #[kani::proof]
    fn $name(instance: $ty) {
      let mut vec = &mut crate::misc::FilledBuffer::_new();
      {
        let mut sw = crate::misc::FilledBufferWriter::new(0, &mut vec);
        let mut ew = EncodeValue::new(&mut sw);
        Encode::<Mysql<crate::Error>>::encode(&instance, &mut ew).unwrap();
        let decoded: $ty = Decode::<Mysql<crate::Error>>::decode(&DecodeValue::new(
          ew.sw()._curr_bytes(),
          crate::database::client::mysql::Ty::Null,
        ))
        .unwrap();
        assert_eq!(instance, decoded);
      }
      vec._clear();
    }
  };
}

macro_rules! test {
  ($name:ident, $ty:ty, $instance:expr) => {
    #[cfg(test)]
    #[test]
    fn $name() {
      let mut vec = crate::collection::Vector::new();
      let mut ew = EncodeWrapper::new(&mut vec);
      let instance: $ty = $instance;
      Encode::<Mysql<crate::Error>>::encode(&instance, &mut ew).unwrap();
      let decoded: $ty = Decode::<Mysql<crate::Error>>::decode(&mut DecodeWrapper::new(
        ew.buffer(),
        "",
        crate::database::client::mysql::TyParams::empty(crate::database::client::mysql::Ty::Tiny),
      ))
      .unwrap();
      assert_eq!(instance, decoded);
    }
  };
}